changeset 10964:658e9e777354

Merge
author lana
date Thu, 13 Nov 2014 09:39:22 -0800
parents 1d41042b9e4f ed08e1d47bfd
children f1ed1540da70
files
diffstat 92 files changed, 7198 insertions(+), 802 deletions(-) [+]
line wrap: on
line diff
--- a/src/java.base/share/classes/java/lang/reflect/Executable.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.base/share/classes/java/lang/reflect/Executable.java	Thu Nov 13 09:39:22 2014 -0800
@@ -286,6 +286,53 @@
     }
 
     /**
+     * Behaves like {@code getGenericParameterTypes}, but returns type
+     * information for all parameters, including synthetic parameters.
+     */
+    Type[] getAllGenericParameterTypes() {
+        final boolean genericInfo = hasGenericInformation();
+
+        // Easy case: we don't have generic parameter information.  In
+        // this case, we just return the result of
+        // getParameterTypes().
+        if (!genericInfo) {
+            return getParameterTypes();
+        } else {
+            final boolean realParamData = hasRealParameterData();
+            final Type[] genericParamTypes = getGenericParameterTypes();
+            final Type[] nonGenericParamTypes = getParameterTypes();
+            final Type[] out = new Type[nonGenericParamTypes.length];
+            final Parameter[] params = getParameters();
+            int fromidx = 0;
+            // If we have real parameter data, then we use the
+            // synthetic and mandate flags to our advantage.
+            if (realParamData) {
+                for (int i = 0; i < out.length; i++) {
+                    final Parameter param = params[i];
+                    if (param.isSynthetic() || param.isImplicit()) {
+                        // If we hit a synthetic or mandated parameter,
+                        // use the non generic parameter info.
+                        out[i] = nonGenericParamTypes[i];
+                    } else {
+                        // Otherwise, use the generic parameter info.
+                        out[i] = genericParamTypes[fromidx];
+                        fromidx++;
+                    }
+                }
+            } else {
+                // Otherwise, use the non-generic parameter data.
+                // Without method parameter reflection data, we have
+                // no way to figure out which parameters are
+                // synthetic/mandated, thus, no way to match up the
+                // indexes.
+                return genericParamTypes.length == nonGenericParamTypes.length ?
+                    genericParamTypes : nonGenericParamTypes;
+            }
+            return out;
+        }
+    }
+
+    /**
      * Returns an array of {@code Parameter} objects that represent
      * all the parameters to the underlying executable represented by
      * this object.  Returns an array of length 0 if the executable
@@ -646,7 +693,7 @@
                         getConstantPool(getDeclaringClass()),
                 this,
                 getDeclaringClass(),
-                getGenericParameterTypes(),
+                getAllGenericParameterTypes(),
                 TypeAnnotation.TypeAnnotationTarget.METHOD_FORMAL_PARAMETER);
     }
 
--- a/src/java.base/share/classes/java/lang/reflect/Parameter.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.base/share/classes/java/lang/reflect/Parameter.java	Thu Nov 13 09:39:22 2014 -0800
@@ -198,7 +198,7 @@
     public Type getParameterizedType() {
         Type tmp = parameterTypeCache;
         if (null == tmp) {
-            tmp = executable.getGenericParameterTypes()[index];
+            tmp = executable.getAllGenericParameterTypes()[index];
             parameterTypeCache = tmp;
         }
 
--- a/src/java.base/share/classes/sun/reflect/BootstrapConstructorAccessorImpl.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.base/share/classes/sun/reflect/BootstrapConstructorAccessorImpl.java	Thu Nov 13 09:39:22 2014 -0800
@@ -32,7 +32,7 @@
     bootstrapping. */
 
 class BootstrapConstructorAccessorImpl extends ConstructorAccessorImpl {
-    private Constructor<?> constructor;
+    private final Constructor<?> constructor;
 
     BootstrapConstructorAccessorImpl(Constructor<?> c) {
         this.constructor = c;
--- a/src/java.base/share/classes/sun/reflect/InstantiationExceptionConstructorAccessorImpl.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.base/share/classes/sun/reflect/InstantiationExceptionConstructorAccessorImpl.java	Thu Nov 13 09:39:22 2014 -0800
@@ -33,7 +33,7 @@
 
 class InstantiationExceptionConstructorAccessorImpl
     extends ConstructorAccessorImpl {
-    private String message;
+    private final String message;
 
     InstantiationExceptionConstructorAccessorImpl(String message) {
         this.message = message;
--- a/src/java.base/share/classes/sun/reflect/Label.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.base/share/classes/sun/reflect/Label.java	Thu Nov 13 09:39:22 2014 -0800
@@ -47,10 +47,10 @@
         }
         // This won't work for more than one assembler anyway, so this is
         // unnecessary
-        ClassFileAssembler asm;
-        short instrBCI;
-        short patchBCI;
-        int   stackDepth;
+        final ClassFileAssembler asm;
+        final short instrBCI;
+        final short patchBCI;
+        final int   stackDepth;
     }
     private List<PatchInfo> patches = new ArrayList<>();
 
--- a/src/java.base/share/classes/sun/reflect/NativeConstructorAccessorImpl.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.base/share/classes/sun/reflect/NativeConstructorAccessorImpl.java	Thu Nov 13 09:39:22 2014 -0800
@@ -32,7 +32,7 @@
     afterward, switches to bytecode-based implementation */
 
 class NativeConstructorAccessorImpl extends ConstructorAccessorImpl {
-    private Constructor<?> c;
+    private final Constructor<?> c;
     private DelegatingConstructorAccessorImpl parent;
     private int numInvocations;
 
--- a/src/java.base/share/classes/sun/reflect/NativeMethodAccessorImpl.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.base/share/classes/sun/reflect/NativeMethodAccessorImpl.java	Thu Nov 13 09:39:22 2014 -0800
@@ -32,7 +32,7 @@
     switches to bytecode-based implementation */
 
 class NativeMethodAccessorImpl extends MethodAccessorImpl {
-    private Method method;
+    private final Method method;
     private DelegatingMethodAccessorImpl parent;
     private int numInvocations;
 
--- a/src/java.base/share/classes/sun/reflect/ReflectionFactory.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.base/share/classes/sun/reflect/ReflectionFactory.java	Thu Nov 13 09:39:22 2014 -0800
@@ -50,9 +50,9 @@
 public class ReflectionFactory {
 
     private static boolean initted = false;
-    private static Permission reflectionFactoryAccessPerm
+    private static final Permission reflectionFactoryAccessPerm
         = new RuntimePermission("reflectionFactoryAccess");
-    private static ReflectionFactory soleInstance = new ReflectionFactory();
+    private static final ReflectionFactory soleInstance = new ReflectionFactory();
     // Provides access to package-private mechanisms in java.lang.reflect
     private static volatile LangReflectAccess langReflectAccess;
 
--- a/src/java.base/share/classes/sun/reflect/SignatureIterator.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.base/share/classes/sun/reflect/SignatureIterator.java	Thu Nov 13 09:39:22 2014 -0800
@@ -28,7 +28,7 @@
 /** Assists in iterating down a method's signature */
 
 public class SignatureIterator {
-    private String sig;
+    private final String sig;
     private int idx;
 
     public SignatureIterator(String sig) {
--- a/src/java.base/share/classes/sun/reflect/generics/factory/CoreReflectionFactory.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.base/share/classes/sun/reflect/generics/factory/CoreReflectionFactory.java	Thu Nov 13 09:39:22 2014 -0800
@@ -45,8 +45,8 @@
  * core reflection (java.lang.reflect).
  */
 public class CoreReflectionFactory implements GenericsFactory {
-    private GenericDeclaration decl;
-    private Scope scope;
+    private final GenericDeclaration decl;
+    private final Scope scope;
 
     private CoreReflectionFactory(GenericDeclaration d, Scope s) {
         decl = d;
--- a/src/java.base/share/classes/sun/reflect/generics/reflectiveObjects/GenericArrayTypeImpl.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.base/share/classes/sun/reflect/generics/reflectiveObjects/GenericArrayTypeImpl.java	Thu Nov 13 09:39:22 2014 -0800
@@ -34,7 +34,7 @@
  */
 public class GenericArrayTypeImpl
     implements GenericArrayType {
-    private Type genericComponentType;
+    private final Type genericComponentType;
 
     // private constructor enforces use of static factory
     private GenericArrayTypeImpl(Type ct) {
--- a/src/java.base/share/classes/sun/reflect/generics/reflectiveObjects/LazyReflectiveObjectGenerator.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.base/share/classes/sun/reflect/generics/reflectiveObjects/LazyReflectiveObjectGenerator.java	Thu Nov 13 09:39:22 2014 -0800
@@ -40,7 +40,7 @@
  *
 */
 public abstract class LazyReflectiveObjectGenerator {
-    private GenericsFactory factory; // cached factory
+    private final GenericsFactory factory; // cached factory
 
     protected LazyReflectiveObjectGenerator(GenericsFactory f) {
         factory = f;
--- a/src/java.base/share/classes/sun/reflect/generics/reflectiveObjects/ParameterizedTypeImpl.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.base/share/classes/sun/reflect/generics/reflectiveObjects/ParameterizedTypeImpl.java	Thu Nov 13 09:39:22 2014 -0800
@@ -38,9 +38,9 @@
 /** Implementing class for ParameterizedType interface. */
 
 public class ParameterizedTypeImpl implements ParameterizedType {
-    private Type[] actualTypeArguments;
-    private Class<?>  rawType;
-    private Type   ownerType;
+    private final Type[] actualTypeArguments;
+    private final Class<?>  rawType;
+    private final Type   ownerType;
 
     private ParameterizedTypeImpl(Class<?> rawType,
                                   Type[] actualTypeArguments,
--- a/src/java.base/share/classes/sun/reflect/generics/repository/AbstractRepository.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.base/share/classes/sun/reflect/generics/repository/AbstractRepository.java	Thu Nov 13 09:39:22 2014 -0800
@@ -40,9 +40,9 @@
 
     // A factory used to produce reflective objects. Provided when the
     //repository is created. Will vary across implementations.
-    private GenericsFactory factory;
+    private final GenericsFactory factory;
 
-    private T tree; // the AST for the generic type info
+    private final T tree; // the AST for the generic type info
 
     //accessors
     private GenericsFactory getFactory() { return factory;}
--- a/src/java.base/share/classes/sun/reflect/generics/scope/AbstractScope.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.base/share/classes/sun/reflect/generics/scope/AbstractScope.java	Thu Nov 13 09:39:22 2014 -0800
@@ -41,7 +41,7 @@
 public abstract class AbstractScope<D extends GenericDeclaration>
     implements Scope {
 
-    private D recvr; // the declaration whose scope this instance represents
+    private final D recvr; // the declaration whose scope this instance represents
     private Scope enclosingScope; // the enclosing scope of this scope
 
     /**
--- a/src/java.base/share/classes/sun/reflect/generics/scope/DummyScope.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.base/share/classes/sun/reflect/generics/scope/DummyScope.java	Thu Nov 13 09:39:22 2014 -0800
@@ -38,7 +38,7 @@
 public class DummyScope implements Scope {
     // Caches the unique instance of this class; instances contain no data
     // so we can use the singleton pattern
-    private static DummyScope singleton = new DummyScope();
+    private static final DummyScope singleton = new DummyScope();
 
     // constructor is private to enforce use of factory method
     private DummyScope(){}
--- a/src/java.base/share/classes/sun/reflect/generics/tree/ArrayTypeSignature.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.base/share/classes/sun/reflect/generics/tree/ArrayTypeSignature.java	Thu Nov 13 09:39:22 2014 -0800
@@ -28,7 +28,7 @@
 import sun.reflect.generics.visitor.TypeTreeVisitor;
 
 public class ArrayTypeSignature implements FieldTypeSignature {
-    private TypeSignature componentType;
+    private final TypeSignature componentType;
 
     private ArrayTypeSignature(TypeSignature ct) {componentType = ct;}
 
--- a/src/java.base/share/classes/sun/reflect/generics/tree/BooleanSignature.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.base/share/classes/sun/reflect/generics/tree/BooleanSignature.java	Thu Nov 13 09:39:22 2014 -0800
@@ -29,7 +29,7 @@
 
 /** AST that represents the type boolean. */
 public class BooleanSignature implements BaseType {
-    private static BooleanSignature singleton = new BooleanSignature();
+    private static final BooleanSignature singleton = new BooleanSignature();
 
     private BooleanSignature(){}
 
--- a/src/java.base/share/classes/sun/reflect/generics/tree/BottomSignature.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.base/share/classes/sun/reflect/generics/tree/BottomSignature.java	Thu Nov 13 09:39:22 2014 -0800
@@ -28,7 +28,7 @@
 import sun.reflect.generics.visitor.TypeTreeVisitor;
 
 public class BottomSignature implements FieldTypeSignature {
-    private static BottomSignature singleton = new BottomSignature();
+    private static final BottomSignature singleton = new BottomSignature();
 
     private BottomSignature(){}
 
--- a/src/java.base/share/classes/sun/reflect/generics/tree/ByteSignature.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.base/share/classes/sun/reflect/generics/tree/ByteSignature.java	Thu Nov 13 09:39:22 2014 -0800
@@ -29,7 +29,7 @@
 
 /** AST that represents the type byte. */
 public class ByteSignature implements BaseType {
-    private static ByteSignature singleton = new ByteSignature();
+    private static final ByteSignature singleton = new ByteSignature();
 
     private ByteSignature(){}
 
--- a/src/java.base/share/classes/sun/reflect/generics/tree/CharSignature.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.base/share/classes/sun/reflect/generics/tree/CharSignature.java	Thu Nov 13 09:39:22 2014 -0800
@@ -29,7 +29,7 @@
 
 /** AST that represents the type char. */
 public class CharSignature implements BaseType {
-    private static CharSignature singleton = new CharSignature();
+    private static final CharSignature singleton = new CharSignature();
 
     private CharSignature(){}
 
--- a/src/java.base/share/classes/sun/reflect/generics/tree/ClassSignature.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.base/share/classes/sun/reflect/generics/tree/ClassSignature.java	Thu Nov 13 09:39:22 2014 -0800
@@ -28,9 +28,9 @@
 import sun.reflect.generics.visitor.Visitor;
 
 public class ClassSignature implements Signature {
-    private FormalTypeParameter[] formalTypeParams;
-    private ClassTypeSignature superclass;
-    private ClassTypeSignature[] superInterfaces;
+    private final FormalTypeParameter[] formalTypeParams;
+    private final ClassTypeSignature superclass;
+    private final ClassTypeSignature[] superInterfaces;
 
     private ClassSignature(FormalTypeParameter[] ftps,
                                       ClassTypeSignature sc,
--- a/src/java.base/share/classes/sun/reflect/generics/tree/ClassTypeSignature.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.base/share/classes/sun/reflect/generics/tree/ClassTypeSignature.java	Thu Nov 13 09:39:22 2014 -0800
@@ -33,7 +33,7 @@
  * AST representing class types.
  */
 public class ClassTypeSignature implements FieldTypeSignature {
-    private List<SimpleClassTypeSignature> path;
+    private final List<SimpleClassTypeSignature> path;
 
 
     private ClassTypeSignature(List<SimpleClassTypeSignature> p) {
--- a/src/java.base/share/classes/sun/reflect/generics/tree/DoubleSignature.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.base/share/classes/sun/reflect/generics/tree/DoubleSignature.java	Thu Nov 13 09:39:22 2014 -0800
@@ -29,7 +29,7 @@
 
 /** AST that represents the type double. */
 public class DoubleSignature implements BaseType {
-    private static DoubleSignature singleton = new DoubleSignature();
+    private static final DoubleSignature singleton = new DoubleSignature();
 
     private DoubleSignature(){}
 
--- a/src/java.base/share/classes/sun/reflect/generics/tree/FloatSignature.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.base/share/classes/sun/reflect/generics/tree/FloatSignature.java	Thu Nov 13 09:39:22 2014 -0800
@@ -29,7 +29,7 @@
 
 /** AST that represents the type float. */
 public class FloatSignature implements BaseType {
-    private static FloatSignature singleton = new FloatSignature();
+    private static final FloatSignature singleton = new FloatSignature();
 
     private FloatSignature(){}
 
--- a/src/java.base/share/classes/sun/reflect/generics/tree/FormalTypeParameter.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.base/share/classes/sun/reflect/generics/tree/FormalTypeParameter.java	Thu Nov 13 09:39:22 2014 -0800
@@ -29,8 +29,8 @@
 
 /** AST that represents a formal type parameter. */
 public class FormalTypeParameter implements TypeTree {
-    private String name;
-    private FieldTypeSignature[] bounds;
+    private final String name;
+    private final FieldTypeSignature[] bounds;
 
     private FormalTypeParameter(String n, FieldTypeSignature[] bs) {
         name = n;
--- a/src/java.base/share/classes/sun/reflect/generics/tree/IntSignature.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.base/share/classes/sun/reflect/generics/tree/IntSignature.java	Thu Nov 13 09:39:22 2014 -0800
@@ -29,7 +29,7 @@
 
 /** AST that represents the type int. */
 public class IntSignature implements BaseType {
-    private static IntSignature singleton = new IntSignature();
+    private static final IntSignature singleton = new IntSignature();
 
     private IntSignature(){}
 
--- a/src/java.base/share/classes/sun/reflect/generics/tree/LongSignature.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.base/share/classes/sun/reflect/generics/tree/LongSignature.java	Thu Nov 13 09:39:22 2014 -0800
@@ -29,7 +29,7 @@
 
 /** AST that represents the type long. */
 public class LongSignature implements BaseType {
-    private static LongSignature singleton = new LongSignature();
+    private static final LongSignature singleton = new LongSignature();
 
     private LongSignature(){}
 
--- a/src/java.base/share/classes/sun/reflect/generics/tree/MethodTypeSignature.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.base/share/classes/sun/reflect/generics/tree/MethodTypeSignature.java	Thu Nov 13 09:39:22 2014 -0800
@@ -28,10 +28,10 @@
 import sun.reflect.generics.visitor.Visitor;
 
 public class MethodTypeSignature implements Signature {
-    private FormalTypeParameter[] formalTypeParams;
-    private TypeSignature[] parameterTypes;
-    private ReturnType returnType;
-    private FieldTypeSignature[] exceptionTypes;
+    private final FormalTypeParameter[] formalTypeParams;
+    private final TypeSignature[] parameterTypes;
+    private final ReturnType returnType;
+    private final FieldTypeSignature[] exceptionTypes;
 
     private MethodTypeSignature(FormalTypeParameter[] ftps,
                                 TypeSignature[] pts,
--- a/src/java.base/share/classes/sun/reflect/generics/tree/ShortSignature.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.base/share/classes/sun/reflect/generics/tree/ShortSignature.java	Thu Nov 13 09:39:22 2014 -0800
@@ -29,7 +29,7 @@
 
 /** AST that represents the type short. */
 public class ShortSignature implements BaseType {
-    private static ShortSignature singleton = new ShortSignature();
+    private static final ShortSignature singleton = new ShortSignature();
 
     private ShortSignature(){}
 
--- a/src/java.base/share/classes/sun/reflect/generics/tree/SimpleClassTypeSignature.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.base/share/classes/sun/reflect/generics/tree/SimpleClassTypeSignature.java	Thu Nov 13 09:39:22 2014 -0800
@@ -28,9 +28,9 @@
 import sun.reflect.generics.visitor.TypeTreeVisitor;
 
 public class SimpleClassTypeSignature implements FieldTypeSignature {
-    private boolean dollar;
-    private String name;
-    private TypeArgument[] typeArgs;
+    private final boolean dollar;
+    private final String name;
+    private final TypeArgument[] typeArgs;
 
     private SimpleClassTypeSignature(String n, boolean dollar, TypeArgument[] tas) {
         name = n;
--- a/src/java.base/share/classes/sun/reflect/generics/tree/TypeVariableSignature.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.base/share/classes/sun/reflect/generics/tree/TypeVariableSignature.java	Thu Nov 13 09:39:22 2014 -0800
@@ -28,7 +28,7 @@
 import sun.reflect.generics.visitor.TypeTreeVisitor;
 
 public class TypeVariableSignature implements FieldTypeSignature {
-    private String identifier;
+    private final String identifier;
 
     private TypeVariableSignature(String id) {identifier = id;}
 
--- a/src/java.base/share/classes/sun/reflect/generics/tree/VoidDescriptor.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.base/share/classes/sun/reflect/generics/tree/VoidDescriptor.java	Thu Nov 13 09:39:22 2014 -0800
@@ -30,7 +30,7 @@
 
 /** AST that represents the pseudo-type void. */
 public class VoidDescriptor implements ReturnType {
-    private static VoidDescriptor singleton = new VoidDescriptor();
+    private static final VoidDescriptor singleton = new VoidDescriptor();
 
     private VoidDescriptor(){}
 
--- a/src/java.base/share/classes/sun/reflect/misc/MethodUtil.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.base/share/classes/sun/reflect/misc/MethodUtil.java	Thu Nov 13 09:39:22 2014 -0800
@@ -76,9 +76,9 @@
  * Create a trampoline class.
  */
 public final class MethodUtil extends SecureClassLoader {
-    private static String MISC_PKG = "sun.reflect.misc.";
-    private static String TRAMPOLINE = MISC_PKG + "Trampoline";
-    private static Method bounce = getTrampoline();
+    private static final String MISC_PKG = "sun.reflect.misc.";
+    private static final String TRAMPOLINE = MISC_PKG + "Trampoline";
+    private static final Method bounce = getTrampoline();
 
     private MethodUtil() {
         super();
--- a/src/java.base/windows/native/libnio/MappedByteBuffer.c	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.base/windows/native/libnio/MappedByteBuffer.c	Thu Nov 13 09:39:22 2014 -0800
@@ -83,9 +83,9 @@
         HANDLE h;
         if (handle_fdID == NULL) {
             jclass clazz = (*env)->FindClass(env, "java/io/FileDescriptor");
-            if (clazz == NULL)
-                return; // exception thrown
+            CHECK_NULL(clazz); //exception thrown
             handle_fdID = (*env)->GetFieldID(env, clazz, "handle", "J");
+            CHECK_NULL(handle_fdID);
         }
         h = jlong_to_ptr((*env)->GetLongField(env, fdo, handle_fdID));
         result = FlushFileBuffers(h);
--- a/src/java.desktop/macosx/classes/sun/lwawt/macosx/CPlatformWindow.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.desktop/macosx/classes/sun/lwawt/macosx/CPlatformWindow.java	Thu Nov 13 09:39:22 2014 -0800
@@ -678,7 +678,7 @@
         final long nsWindowPtr = getNSWindowPtr();
         LWCToolkit lwcToolkit = (LWCToolkit) Toolkit.getDefaultToolkit();
         Window w = DefaultKeyboardFocusManager.getCurrentKeyboardFocusManager().getActiveWindow();
-        if( w != null
+        if( w != null && w.getPeer() != null
                 && ((LWWindowPeer)w.getPeer()).getPeerType() == LWWindowPeer.PeerType.EMBEDDED_FRAME
                 && !lwcToolkit.isApplicationActive()) {
             lwcToolkit.activateApplicationIgnoringOtherApps();
--- a/src/java.desktop/macosx/native/libawt_lwawt/java2d/opengl/CGLGraphicsConfig.m	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.desktop/macosx/native/libawt_lwawt/java2d/opengl/CGLGraphicsConfig.m	Thu Nov 13 09:39:22 2014 -0800
@@ -72,7 +72,9 @@
             }
             [pool drain];
             free(ctxinfo);
+            oglc->ctxInfo = NULL;
         }
+        cglinfo->context = NULL;
     }
 
     free(cglinfo);
--- a/src/java.desktop/macosx/native/libawt_lwawt/java2d/opengl/CGLSurfaceData.m	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.desktop/macosx/native/libawt_lwawt/java2d/opengl/CGLSurfaceData.m	Thu Nov 13 09:39:22 2014 -0800
@@ -187,6 +187,11 @@
     }
 
     OGLContext *oglc = cglInfo->context;
+    if (oglc == NULL) {
+        J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSD_SetScratchContext: ogl context is null");
+        return NULL;
+    }
+
     CGLCtxInfo *ctxinfo = (CGLCtxInfo *)oglc->ctxInfo;
 
 JNF_COCOA_ENTER(env);
--- a/src/java.desktop/share/classes/java/awt/Component.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.desktop/share/classes/java/awt/Component.java	Thu Nov 13 09:39:22 2014 -0800
@@ -8607,7 +8607,7 @@
      * @param propertyName the programmatic name of the property
      *          that was changed
      * @param oldValue the old value of the property (as a short)
-     * @param newValue the old value of the property (as a short)
+     * @param newValue the new value of the property (as a short)
      * @see #firePropertyChange(java.lang.String, java.lang.Object,
      *          java.lang.Object)
      * @since 1.5
--- a/src/java.desktop/share/classes/java/awt/Robot.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.desktop/share/classes/java/awt/Robot.java	Thu Nov 13 09:39:22 2014 -0800
@@ -34,9 +34,12 @@
 import java.awt.image.WritableRaster;
 import java.awt.peer.RobotPeer;
 import java.lang.reflect.InvocationTargetException;
+import java.security.AccessController;
+
 import sun.awt.AWTPermissions;
 import sun.awt.ComponentFactory;
 import sun.awt.SunToolkit;
+import sun.awt.OSInfo;
 import sun.awt.image.SunWritableRaster;
 
 /**
@@ -555,15 +558,21 @@
      */
     public synchronized void waitForIdle() {
         checkNotDispatchThread();
-        // post a dummy event to the queue so we know when
-        // all the events before it have been processed
+
         try {
             SunToolkit.flushPendingEvents();
-            EventQueue.invokeAndWait( new Runnable() {
-                                            public void run() {
-                                                // dummy implementation
-                                            }
-                                        } );
+            // 7185258: realSync() call blocks all DnD tests on OS X
+            if (AccessController.doPrivileged(OSInfo.getOSTypeAction()) == OSInfo.OSType.MACOSX) {
+                // post a dummy event to the queue so we know when
+                // all the events before it have been processed
+                EventQueue.invokeAndWait( new Runnable() {
+                                                public void run() {
+                                                    // dummy implementation
+                                                }
+                                            } );
+            } else {
+                ((SunToolkit) Toolkit.getDefaultToolkit()).realSync();
+            }
         } catch(InterruptedException ite) {
             System.err.println("Robot.waitForIdle, non-fatal exception caught:");
             ite.printStackTrace();
--- a/src/java.desktop/share/classes/javax/swing/JComboBox.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.desktop/share/classes/javax/swing/JComboBox.java	Thu Nov 13 09:39:22 2014 -0800
@@ -1320,7 +1320,8 @@
      */
     public void actionPerformed(ActionEvent e) {
         ComboBoxEditor editor = getEditor();
-        if ((editor != null) && (e != null) && (editor == e.getSource())) {
+        if ((editor != null) && (e != null)
+                && (editor.getEditorComponent() == e.getSource())) {
             setPopupVisible(false);
             getModel().setSelectedItem(editor.getItem());
             String oldCommand = getActionCommand();
--- a/src/java.desktop/share/classes/sun/java2d/pipe/DrawImage.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.desktop/share/classes/sun/java2d/pipe/DrawImage.java	Thu Nov 13 09:39:22 2014 -0800
@@ -278,18 +278,34 @@
                                      Color bgColor, int interpType,
                                      double coords[])
     {
-        double dx = coords[0];
-        double dy = coords[1];
-        double dw = coords[2] - dx;
-        double dh = coords[3] - dy;
+        double dx1 = coords[0];
+        double dy1 = coords[1];
+        double dx2 = coords[2];
+        double dy2 = coords[3];
+        double dw = dx2 - dx1;
+        double dh = dy2 - dy1;
+
+        /* If any of the destination coordinates exceed the integer range,
+         * then the calculations performed in calls made here cannot be
+         * guaranteed to be correct, or to converge (terminate).
+         * So return out of here, deferring to code that can handle this.
+         */
+        if (dx1 < Integer.MIN_VALUE || dx1 > Integer.MAX_VALUE ||
+            dy1 < Integer.MIN_VALUE || dy1 > Integer.MAX_VALUE ||
+            dx2 < Integer.MIN_VALUE || dx2 > Integer.MAX_VALUE ||
+            dy2 < Integer.MIN_VALUE || dy2 > Integer.MAX_VALUE)
+        {
+            return false;
+        }
+
         // First check if width and height are very close to img w&h.
         if (closeToInteger(sx2-sx1, dw) && closeToInteger(sy2-sy1, dh)) {
             // Round location to nearest pixel and then test
             // if it will cause interpolation anomalies.
-            int idx = (int) Math.floor(dx + 0.5);
-            int idy = (int) Math.floor(dy + 0.5);
+            int idx = (int) Math.floor(dx1 + 0.5);
+            int idy = (int) Math.floor(dy1 + 0.5);
             if (interpType == AffineTransformOp.TYPE_NEAREST_NEIGHBOR ||
-                (closeToInteger(idx, dx) && closeToInteger(idy, dy)))
+                (closeToInteger(idx, dx1) && closeToInteger(idy, dy1)))
             {
                 renderImageCopy(sg, img, bgColor,
                                 idx, idy,
@@ -302,7 +318,7 @@
         if (dw > 0 && dh > 0) {
             if (renderImageScale(sg, img, bgColor, interpType,
                                  sx1, sy1, sx2, sy2,
-                                 coords[0], coords[1], coords[2], coords[3]))
+                                 dx1, dy1, dx2, dy2))
             {
                 return true;
             }
@@ -494,7 +510,7 @@
         // We need to transform to a temp image and then copy
         // just the pieces that are valid data to the dest.
         BufferedImage tmpimg = new BufferedImage(dx2-dx1, dy2-dy1,
-                                                 BufferedImage.TYPE_INT_ARGB);
+                                                 BufferedImage.TYPE_INT_ARGB_PRE);
         SurfaceData tmpData = SurfaceData.getPrimarySurfaceData(tmpimg);
         SurfaceType tmpType = tmpData.getSurfaceType();
         MaskBlit tmpmaskblit =
--- a/src/java.desktop/windows/classes/sun/java2d/d3d/D3DBlitLoops.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.desktop/windows/classes/sun/java2d/d3d/D3DBlitLoops.java	Thu Nov 13 09:39:22 2014 -0800
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2007, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2007, 2014, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -48,7 +48,7 @@
 import static sun.java2d.pipe.BufferedOpCodes.*;
 import sun.java2d.windows.GDIWindowSurfaceData;
 
-class D3DBlitLoops {
+final class D3DBlitLoops {
 
     static void register() {
         Blit blitIntArgbPreToSurface =
@@ -57,7 +57,9 @@
         Blit blitIntArgbPreToTexture =
             new D3DSwToTextureBlit(SurfaceType.IntArgbPre,
                                    D3DSurfaceData.ST_INT_ARGB_PRE);
-
+        TransformBlit transformBlitIntArgbPreToSurface =
+            new D3DSwToSurfaceTransform(SurfaceType.IntArgbPre,
+                                        D3DSurfaceData.ST_INT_ARGB_PRE);
         GraphicsPrimitive[] primitives = {
             // prevent D3DSurface -> Screen blits
             new D3DSurfaceToGDIWindowSurfaceBlit(),
@@ -123,8 +125,6 @@
 
             new D3DSwToSurfaceTransform(SurfaceType.IntArgb,
                                         D3DSurfaceData.ST_INT_ARGB),
-            new D3DSwToSurfaceTransform(SurfaceType.IntArgbPre,
-                                        D3DSurfaceData.ST_INT_ARGB_PRE),
             new D3DSwToSurfaceTransform(SurfaceType.IntRgb,
                                         D3DSurfaceData.ST_INT_RGB),
             new D3DSwToSurfaceTransform(SurfaceType.IntBgr,
@@ -140,6 +140,9 @@
             // REMIND: we don't have a native sw loop to back this loop up
 //            new D3DSwToSurfaceTransform(SurfaceType.ByteIndexedBm,
 //                                        D3DSurfaceData.ST_BYTE_INDEXED_BM),
+            transformBlitIntArgbPreToSurface,
+
+            new D3DGeneralTransformedBlit(transformBlitIntArgbPreToSurface),
 
             // texture->surface ops
             new D3DTextureToSurfaceBlit(),
@@ -712,11 +715,11 @@
  * This general Blit implementation converts any source surface to an
  * intermediate IntArgbPre surface, and then uses the more specific
  * IntArgbPre->D3DSurface/Texture loop to get the intermediate
- * (premultiplied) surface down to D3D.
+ * (premultiplied) surface down to D3D using simple blit.
  */
 class D3DGeneralBlit extends Blit {
 
-    private Blit performop;
+    private final Blit performop;
     private WeakReference<SurfaceData> srcTmp;
 
     D3DGeneralBlit(SurfaceType dstType,
@@ -757,6 +760,49 @@
     }
 }
 
+/**
+ * This general TransformedBlit implementation converts any source surface to an
+ * intermediate IntArgbPre surface, and then uses the more specific
+ * IntArgbPre->D3DSurface/Texture loop to get the intermediate
+ * (premultiplied) surface down to D3D using simple transformBlit.
+ */
+final class D3DGeneralTransformedBlit extends TransformBlit {
+
+    private final TransformBlit performop;
+    private WeakReference<SurfaceData> srcTmp;
+
+    D3DGeneralTransformedBlit(final TransformBlit performop) {
+        super(SurfaceType.Any, CompositeType.AnyAlpha,
+                D3DSurfaceData.D3DSurface);
+        this.performop = performop;
+    }
+
+    @Override
+    public synchronized void Transform(SurfaceData src, SurfaceData dst,
+                                       Composite comp, Region clip,
+                                       AffineTransform at, int hint, int srcx,
+                                       int srcy, int dstx, int dsty, int width,
+                                       int height){
+        Blit convertsrc = Blit.getFromCache(src.getSurfaceType(),
+                                            CompositeType.SrcNoEa,
+                                            SurfaceType.IntArgbPre);
+        // use cached intermediate surface, if available
+        final SurfaceData cachedSrc = srcTmp != null ? srcTmp.get() : null;
+        // convert source to IntArgbPre
+        src = convertFrom(convertsrc, src, srcx, srcy, width, height, cachedSrc,
+                          BufferedImage.TYPE_INT_ARGB_PRE);
+
+        // transform IntArgbPre intermediate surface to D3D surface
+        performop.Transform(src, dst, comp, clip, at, hint, 0, 0, dstx, dsty,
+                            width, height);
+
+        if (src != cachedSrc) {
+            // cache the intermediate surface
+            srcTmp = new WeakReference<>(src);
+        }
+    }
+}
+
 /*
  * The following classes prohibit copying D3DSurfaces to the screen
  * (the D3D->sysmem->GDI path is known to be very very slow).
--- a/src/java.management/share/classes/com/sun/management/HotSpotDiagnosticMXBean.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.management/share/classes/com/sun/management/HotSpotDiagnosticMXBean.java	Thu Nov 13 09:39:22 2014 -0800
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2005, 2014, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -25,7 +25,6 @@
 
 package com.sun.management;
 
-import java.util.List;
 import java.lang.management.PlatformManagedObject;
 
 /**
@@ -109,7 +108,7 @@
      * @throws IllegalArgumentException if the VM option of the given name
      *                                     does not exist.
      * @throws IllegalArgumentException if the new value is invalid.
-     * @throws IllegalArgumentException if the VM option is not writeable.
+     * @throws IllegalArgumentException if the VM option is not writable.
      * @throws NullPointerException if name or value is <tt>null</tt>.
      *
      * @throws  java.lang.SecurityException
--- a/src/java.management/share/classes/sun/management/Flag.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.management/share/classes/sun/management/Flag.java	Thu Nov 13 09:39:22 2014 -0800
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2014, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -110,6 +110,7 @@
     // These set* methods are synchronized on the class object
     // to avoid multiple threads updating the same flag at the same time.
     static synchronized native void setLongValue(String name, long value);
+    static synchronized native void setDoubleValue(String name, double value);
     static synchronized native void setBooleanValue(String name, boolean value);
     static synchronized native void setStringValue(String name, String value);
 
--- a/src/java.management/share/classes/sun/management/HotSpotDiagnostic.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.management/share/classes/sun/management/HotSpotDiagnostic.java	Thu Nov 13 09:39:22 2014 -0800
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2005, 2014, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -40,6 +40,7 @@
     public HotSpotDiagnostic() {
     }
 
+    @Override
     public void dumpHeap(String outputFile, boolean live) throws IOException {
         SecurityManager security = System.getSecurityManager();
         if (security != null) {
@@ -52,6 +53,7 @@
 
     private native void dumpHeap0(String outputFile, boolean live) throws IOException;
 
+    @Override
     public List<VMOption> getDiagnosticOptions() {
         List<Flag> allFlags = Flag.getAllFlags();
         List<VMOption> result = new ArrayList<>();
@@ -63,6 +65,7 @@
         return result;
     }
 
+    @Override
     public VMOption getVMOption(String name) {
         if (name == null) {
             throw new NullPointerException("name cannot be null");
@@ -76,6 +79,7 @@
         return f.getVMOption();
     }
 
+    @Override
     public void setVMOption(String name, String value) {
         if (name == null) {
             throw new NullPointerException("name cannot be null");
@@ -102,12 +106,18 @@
                 long l = Long.parseLong(value);
                 Flag.setLongValue(name, l);
             } catch (NumberFormatException e) {
-                IllegalArgumentException iae =
-                    new IllegalArgumentException("Invalid value:" +
+                throw new IllegalArgumentException("Invalid value:" +
                         " VM Option \"" + name + "\"" +
-                        " expects numeric value");
-                iae.initCause(e);
-                throw iae;
+                        " expects numeric value", e);
+            }
+        } else if (v instanceof Double) {
+            try {
+                double d = Double.parseDouble(value);
+                Flag.setDoubleValue(name, d);
+            } catch (NumberFormatException e) {
+                throw new IllegalArgumentException("Invalid value:" +
+                        " VM Option \"" + name + "\"" +
+                        " expects numeric value", e);
             }
         } else if (v instanceof Boolean) {
             if (!value.equalsIgnoreCase("true") &&
@@ -126,6 +136,7 @@
         }
     }
 
+    @Override
     public ObjectName getObjectName() {
         return Util.newObjectName("com.sun.management:type=HotSpotDiagnostic");
     }
--- a/src/java.management/share/native/include/jmm.h	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.management/share/native/include/jmm.h	Thu Nov 13 09:39:22 2014 -0800
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2014, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -143,7 +143,8 @@
   JMM_VMGLOBAL_TYPE_UNKNOWN  = 0,
   JMM_VMGLOBAL_TYPE_JBOOLEAN = 1,
   JMM_VMGLOBAL_TYPE_JSTRING  = 2,
-  JMM_VMGLOBAL_TYPE_JLONG    = 3
+  JMM_VMGLOBAL_TYPE_JLONG    = 3,
+  JMM_VMGLOBAL_TYPE_JDOUBLE  = 4
 } jmmVMGlobalType;
 
 typedef enum {
--- a/src/java.management/share/native/libmanagement/Flag.c	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.management/share/native/libmanagement/Flag.c	Thu Nov 13 09:39:22 2014 -0800
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2014, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -133,6 +133,10 @@
             valueObj = JNU_NewObjectByName(env, "java/lang/Long", "(J)V",
                                            globals[i].value.j);
             break;
+        case JMM_VMGLOBAL_TYPE_JDOUBLE:
+            valueObj = JNU_NewObjectByName(env, "java/lang/Double", "(D)V",
+                                           globals[i].value.d);
+            break;
         default:
             // ignore unsupported type
             continue;
@@ -202,6 +206,16 @@
 }
 
 JNIEXPORT void JNICALL
+Java_sun_management_Flag_setDoubleValue
+  (JNIEnv *env, jclass cls, jstring name, jdouble value)
+{
+   jvalue v;
+   v.d = value;
+
+   jmm_interface->SetVMGlobal(env, name, v);
+}
+
+JNIEXPORT void JNICALL
 Java_sun_management_Flag_setBooleanValue
   (JNIEnv *env, jclass cls, jstring name, jboolean value)
 {
--- a/src/java.management/windows/native/libmanagement/OperatingSystemImpl.c	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/java.management/windows/native/libmanagement/OperatingSystemImpl.c	Thu Nov 13 09:39:22 2014 -0800
@@ -53,8 +53,6 @@
 typedef unsigned __int32 juint;
 typedef unsigned __int64 julong;
 
-typedef enum boolean_values { false=0, true=1};
-
 static void set_low(jlong* value, jint low) {
     *value &= (jlong)0xffffffff << 32;
     *value |= (jlong)(julong)(juint)low;
@@ -66,22 +64,22 @@
 }
 
 static jlong jlong_from(jint h, jint l) {
-  jlong result = 0; // initialization to avoid warning
-  set_high(&result, h);
-  set_low(&result,  l);
-  return result;
+    jlong result = 0; // initialization to avoid warning
+    set_high(&result, h);
+    set_low(&result,  l);
+    return result;
 }
 
 static HANDLE main_process;
 
-int perfiInit(void);
+static void perfInit(void);
 
 JNIEXPORT void JNICALL
 Java_sun_management_OperatingSystemImpl_initialize0
   (JNIEnv *env, jclass cls)
 {
     main_process = GetCurrentProcess();
-     perfiInit();
+    perfInit();
 }
 
 JNIEXPORT jlong JNICALL
@@ -155,26 +153,7 @@
     return (jlong) ms.ullTotalPhys;
 }
 
-// Seems WinXP PDH returns PDH_MORE_DATA whenever we send in a NULL buffer.
-// Let's just ignore it, since we make sure we have enough buffer anyway.
-static int
-pdh_fail(PDH_STATUS pdhStat) {
-    return pdhStat != ERROR_SUCCESS && pdhStat != PDH_MORE_DATA;
-}
-
-// INFO: Using PDH APIs Correctly in a Localized Language (Q287159)
-//       http://support.microsoft.com/default.aspx?scid=kb;EN-US;q287159
-// The index value for the base system counters and objects like processor,
-// process, thread, memory, and so forth are always the same irrespective
-// of the localized version of the operating system or service pack installed.
-#define PDH_PROCESSOR_IDX        ((DWORD) 238)
-#define PDH_PROCESSOR_TIME_IDX        ((DWORD)   6)
-#define PDH_PRIV_PROCESSOR_TIME_IDX ((DWORD) 144)
-#define PDH_PROCESS_IDX            ((DWORD) 230)
-#define PDH_ID_PROCESS_IDX        ((DWORD) 784)
-#define PDH_CONTEXT_SWITCH_RATE_IDX ((DWORD) 146)
-#define PDH_SYSTEM_IDX            ((DWORD)   2)
-#define PDH_VIRTUAL_BYTES_IDX        ((DWORD) 174)
+/* Performance Data Helper API (PDH) support */
 
 typedef PDH_STATUS (WINAPI *PdhAddCounterFunc)(
                            HQUERY      hQuery,
@@ -183,48 +162,44 @@
                            HCOUNTER    *phCounter
                            );
 typedef PDH_STATUS (WINAPI *PdhOpenQueryFunc)(
-                          LPCWSTR     szDataSource,
-                          DWORD       dwUserData,
-                          HQUERY      *phQuery
-                          );
+                           LPCWSTR     szDataSource,
+                           DWORD       dwUserData,
+                           HQUERY      *phQuery
+                           );
+typedef PDH_STATUS (WINAPI *PdhCollectQueryDataFunc)(
+                           HQUERY      hQuery
+                           );
+
+typedef PDH_STATUS (WINAPI *PdhEnumObjectItemsFunc)(
+                           LPCTSTR     szDataSource,
+                           LPCTSTR     szMachineName,
+                           LPCTSTR     szObjectName,
+                           LPTSTR      mszCounterList,
+                           LPDWORD     pcchCounterListLength,
+                           LPTSTR      mszInstanceList,
+                           LPDWORD     pcchInstanceListLength,
+                           DWORD       dwDetailLevel,
+                           DWORD       dwFlags
+                           );
+typedef PDH_STATUS (WINAPI *PdhRemoveCounterFunc)(
+                           HCOUNTER   hCounter
+                           );
+typedef PDH_STATUS (WINAPI *PdhLookupPerfNameByIndexFunc)(
+                           LPCSTR     szMachineName,
+                           DWORD      dwNameIndex,
+                           LPSTR      szNameBuffer,
+                           LPDWORD    pcchNameBufferSize
+                           );
 typedef DWORD (WINAPI *PdhCloseQueryFunc)(
                       HQUERY      hQuery
                       );
-typedef PDH_STATUS (WINAPI *PdhCollectQueryDataFunc)(
-                             HQUERY      hQuery
-                             );
+
 typedef DWORD (WINAPI *PdhGetFormattedCounterValueFunc)(
-                            HCOUNTER                hCounter,
-                            DWORD                   dwFormat,
-                            LPDWORD                 lpdwType,
-                            PPDH_FMT_COUNTERVALUE   pValue
-                            );
-typedef PDH_STATUS (WINAPI *PdhEnumObjectItemsFunc)(
-                            LPCTSTR    szDataSource,
-                            LPCTSTR    szMachineName,
-                            LPCTSTR    szObjectName,
-                            LPTSTR     mszCounterList,
-                            LPDWORD    pcchCounterListLength,
-                            LPTSTR     mszInstanceList,
-                            LPDWORD    pcchInstanceListLength,
-                            DWORD      dwDetailLevel,
-                            DWORD      dwFlags
-                            );
-typedef PDH_STATUS (WINAPI *PdhRemoveCounterFunc)(
-                          HCOUNTER  hCounter
-                          );
-typedef PDH_STATUS (WINAPI *PdhLookupPerfNameByIndexFunc)(
-                              LPCSTR  szMachineName,
-                              DWORD   dwNameIndex,
-                              LPSTR   szNameBuffer,
-                              LPDWORD pcchNameBufferSize
-                              );
-typedef PDH_STATUS (WINAPI *PdhMakeCounterPathFunc)(
-                            PDH_COUNTER_PATH_ELEMENTS *pCounterPathElements,
-                            LPTSTR szFullPathBuffer,
-                            LPDWORD pcchBufferSize,
-                            DWORD dwFlags
-                            );
+                      HCOUNTER                hCounter,
+                      DWORD                   dwFormat,
+                      LPDWORD                 lpdwType,
+                      PPDH_FMT_COUNTERVALUE   pValue
+                      );
 
 static PdhAddCounterFunc PdhAddCounter_i;
 static PdhOpenQueryFunc PdhOpenQuery_i;
@@ -234,76 +209,757 @@
 static PdhEnumObjectItemsFunc PdhEnumObjectItems_i;
 static PdhRemoveCounterFunc PdhRemoveCounter_i;
 static PdhLookupPerfNameByIndexFunc PdhLookupPerfNameByIndex_i;
-static PdhMakeCounterPathFunc PdhMakeCounterPath_i;
 
-static HANDLE thisProcess;
-static double cpuFactor;
-static DWORD  num_cpus;
-
-#define FT2JLONG(X)  ((((jlong)X.dwHighDateTime) << 32) | ((jlong)X.dwLowDateTime))
-#define COUNTER_BUF_SIZE 256
-// Min time between query updates.
-#define MIN_UPDATE_INTERVAL 500
-#define CONFIG_SUCCESSFUL 0
-
-/**
+/*
  * Struct for PDH queries.
  */
 typedef struct {
     HQUERY      query;
-    uint64_t      lastUpdate; // Last time query was updated (current millis).
+    uint64_t    lastUpdate; // Last time query was updated (ticks)
 } UpdateQueryS, *UpdateQueryP;
 
-/**
- * Struct for the processor load counters.
+// Min time between query updates (ticks)
+static const int MIN_UPDATE_INTERVAL = 500;
+
+/*
+ * Struct for a PDH query with multiple counters.
  */
 typedef struct {
-    UpdateQueryS      query;
-    HCOUNTER*      counters;
-    int          noOfCounters;
+    UpdateQueryS  query;
+    HCOUNTER*     counters;
+    int           noOfCounters;
 } MultipleCounterQueryS, *MultipleCounterQueryP;
 
-/**
- * Struct for the jvm process load counter.
+/*
+ * Struct for a PDH query with a single counter.
  */
 typedef struct {
-    UpdateQueryS      query;
+    UpdateQueryS  query;
     HCOUNTER      counter;
 } SingleCounterQueryS, *SingleCounterQueryP;
 
-static char* getProcessPDHHeader(void);
 
-/**
- * Currently available counters.
+typedef struct {
+    CRITICAL_SECTION cs;
+    DWORD owningThread;
+    DWORD recursionCount;
+} PdhCriticalSectionS, *PdhCriticalSectionP;
+
+static PdhCriticalSectionS initializationLock;
+
+static void InitializePdhCriticalSection(PdhCriticalSectionP criticalSection) {
+    assert(criticalSection);
+
+    InitializeCriticalSection(&criticalSection->cs);
+    criticalSection->owningThread = 0;
+    criticalSection->recursionCount = 0;
+}
+
+static void EnterPdhCriticalSection(PdhCriticalSectionP criticalSection) {
+    assert(criticalSection);
+
+    EnterCriticalSection(&criticalSection->cs);
+    criticalSection->recursionCount++;
+    if (!criticalSection->owningThread) {
+        criticalSection->owningThread = GetCurrentThreadId();
+    }
+}
+
+static void LeavePdhCriticalSection(PdhCriticalSectionP criticalSection) {
+    assert(criticalSection);
+    assert(GetCurrentThreadId() == criticalSection->owningThread);
+    assert(criticalSection->recursionCount >= 1);
+
+    criticalSection->recursionCount--;
+    if (!criticalSection->recursionCount) {
+        criticalSection->owningThread = 0;
+    }
+    LeaveCriticalSection(&criticalSection->cs);
+}
+
+/*
+ * INFO: Using PDH APIs Correctly in a Localized Language (Q287159)
+ *   http://support.microsoft.com/default.aspx?scid=kb;EN-US;q287159
+ * The index value for the base system counters and objects like processor,
+ * process, thread, memory, and so forth are always the same irrespective
+ * of the localized version of the operating system or service pack installed.
+ * To find the correct index for an object or counter, inspect the registry key/value:
+ * [HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Perflib\009\Counter]
  */
-static SingleCounterQueryS cntCtxtSwitchRate;
-static SingleCounterQueryS cntVirtualSize;
-static SingleCounterQueryS cntProcLoad;
-static SingleCounterQueryS cntProcSystemLoad;
-static MultipleCounterQueryS multiCounterCPULoad;
+static const DWORD PDH_PROCESSOR_IDX = 238;
+static const DWORD PDH_PROCESSOR_TIME_IDX = 6;
+static const DWORD PDH_PROCESS_IDX = 230;
+static const DWORD PDH_ID_PROCESS_IDX = 784;
 
-static CRITICAL_SECTION processHeaderLock;
-static CRITICAL_SECTION initializationLock;
+/* useful pdh fmt's */
+static const char* const OBJECT_COUNTER_FMT = "\\%s\\%s";
+static const size_t OBJECT_COUNTER_FMT_LEN = 2;
+static const char* const OBJECT_WITH_INSTANCES_COUNTER_FMT = "\\%s(%s)\\%s";
+static const size_t OBJECT_WITH_INSTANCES_COUNTER_FMT_LEN = 4;
+static const char* const PROCESS_OBJECT_INSTANCE_COUNTER_FMT = "\\%s(%s#%s)\\%s";
+static const size_t PROCESS_OBJECT_INSTANCE_COUNTER_FMT_LEN = 5;
 
-/**
- * Initialize the perf module at startup.
+static const char* pdhProcessImageName = NULL; /* "java" */
+static char* pdhIDProcessCounterFmt = NULL;    /* "\Process(java#%d)\ID Process" */
+
+static int numberOfJavaProcessesAtInitialization = 0;
+
+/*
+ * Currently used CPU queries/counters and variables
  */
-int
-perfiInit(void)
-{
-    InitializeCriticalSection(&processHeaderLock);
-    InitializeCriticalSection(&initializationLock);
+static SingleCounterQueryP processTotalCPULoad = NULL;
+static MultipleCounterQueryP multiCounterCPULoad = NULL;
+static double cpuFactor = .0;
+static DWORD  numCpus = 0;
+
+/*
+ * Seems WinXP PDH returns PDH_MORE_DATA whenever we send in a NULL buffer.
+ * Let's just ignore it, since we make sure we have enough buffer anyway.
+ */
+static int
+pdhFail(PDH_STATUS pdhStat) {
+    return pdhStat != ERROR_SUCCESS && pdhStat != PDH_MORE_DATA;
+}
+
+static const char*
+allocateAndCopy(const char* const originalString) {
+    size_t len;
+    char* allocatedString;
+
+    assert(originalString);
+
+    len = strlen(originalString);
+
+    allocatedString = malloc(len + 1);
+
+    if (!allocatedString) {
+        return NULL;
+    }
+
+    strncpy(allocatedString, originalString, len);
+    allocatedString[len] = '\0';
+
+    return allocatedString;
+}
+
+/*
+ * Allocates memory into the supplied pointer and
+ * fills it with the localized PDH artifact description, if indexed correctly.
+ * Caller owns the memory from the point of returning from this function.
+ *
+ * @param index    the PDH counter index as specified in the registry
+ * @param ppBuffer pointer to a char*.
+ * @return         0 if successful, negative on failure.
+ */
+static int
+lookupNameByIndex(DWORD index, char** ppBuffer) {
+    DWORD size;
+
+    assert(ppBuffer);
+
+    /* determine size needed */
+    if (PdhLookupPerfNameByIndex_i(NULL, index, NULL, &size) != PDH_MORE_DATA) {
+      /* invalid index? */
+      return -1;
+    }
+
+    *ppBuffer = malloc((size_t)size);
+
+    if (!*ppBuffer) {
+        return -1;
+    }
+
+    if (PdhLookupPerfNameByIndex_i(NULL, index, *ppBuffer, &size) != ERROR_SUCCESS) {
+        free(*ppBuffer);
+        *ppBuffer = NULL;
+        return -1;
+    }
+
+    /* windows vista does not null-terminate the string
+     * (although the docs says it will) */
+    (*ppBuffer)[size - 1] = '\0';
+
     return 0;
 }
 
-/**
+/*
+* Construct a fully qualified PDH path
+*
+* @param objectName   a PDH Object string representation (required)
+* @param counterName  a PDH Counter string representation (required)
+* @param imageName    a process image name string, ex. "java" (opt)
+* @param instance     an instance string, ex. "0", "1", ... (opt)
+* @return             the fully qualified PDH path.
+*
+* Caller will own the returned malloc:ed string
+*/
+static const char*
+makeFullCounterPath(const char* const objectName,
+                    const char* const counterName,
+                    const char* const imageName,
+                    const char* const instance) {
+
+    size_t fullCounterPathLen;
+    char* fullCounterPath;
+
+    assert(objectName);
+    assert(counterName);
+
+    fullCounterPathLen = strlen(objectName);
+    fullCounterPathLen += strlen(counterName);
+
+    if (imageName) {
+        /*
+         * For paths using the "Process" Object.
+         *
+         * Examples:
+         * abstract: "\Process(imageName#instance)\Counter"
+         * actual:   "\Process(java#2)\ID Process"
+         */
+        fullCounterPathLen += PROCESS_OBJECT_INSTANCE_COUNTER_FMT_LEN;
+        fullCounterPathLen += strlen(imageName);
+
+        /*
+         * imageName must be passed together with an associated
+         * instance "number" ("0", "1", "2", ...).
+         * This is required in order to create valid "Process" Object paths.
+         *
+         * Examples: "\Process(java#0)", \Process(java#1"), ...
+         */
+        assert(instance);
+
+        fullCounterPathLen += strlen(instance);
+
+        fullCounterPath = malloc(fullCounterPathLen + 1);
+
+        if (!fullCounterPath) {
+            return NULL;
+        }
+
+        _snprintf(fullCounterPath,
+                  fullCounterPathLen,
+                  PROCESS_OBJECT_INSTANCE_COUNTER_FMT,
+                  objectName,
+                  imageName,
+                  instance,
+                  counterName);
+    } else {
+        if (instance) {
+            /*
+             * For paths where the Object has multiple instances.
+             *
+             * Examples:
+             * abstract: "\Object(instance)\Counter"
+             * actual:   "\Processor(0)\% Privileged Time"
+             */
+            fullCounterPathLen += strlen(instance);
+            fullCounterPathLen += OBJECT_WITH_INSTANCES_COUNTER_FMT_LEN;
+        } else {
+            /*
+             * For "normal" paths.
+             *
+             * Examples:
+             * abstract: "\Object\Counter"
+             * actual:   "\Memory\Available Mbytes"
+             */
+            fullCounterPathLen += OBJECT_COUNTER_FMT_LEN;
+        }
+
+        fullCounterPath = malloc(fullCounterPathLen + 1);
+
+        if (!fullCounterPath) {
+            return NULL;
+        }
+
+        if (instance) {
+            _snprintf(fullCounterPath,
+                      fullCounterPathLen,
+                      OBJECT_WITH_INSTANCES_COUNTER_FMT,
+                      objectName,
+                      instance,
+                      counterName);
+        } else {
+            _snprintf(fullCounterPath,
+                      fullCounterPathLen,
+                      OBJECT_COUNTER_FMT,
+                      objectName,
+                      counterName);
+        }
+    }
+
+    fullCounterPath[fullCounterPathLen] = '\0';
+
+    return fullCounterPath;
+}
+
+/*
+ * Resolves an index for a PDH artifact to
+ * a localized, malloc:ed string representation.
+ * Caller will own the returned malloc:ed string.
+ *
+ * @param pdhArtifactIndex  PDH index
+ * @return                  malloc:ed string representation
+ *                          of the requested pdh artifact (localized).
+ *                          NULL on failure.
+ */
+static const char*
+getPdhLocalizedArtifact(DWORD pdhArtifactIndex) {
+    char* pdhLocalizedArtifactString;
+
+    if (lookupNameByIndex(pdhArtifactIndex,
+                          &pdhLocalizedArtifactString) != 0) {
+        return NULL;
+    }
+
+    return pdhLocalizedArtifactString;
+}
+
+static void
+pdhCleanup(HQUERY* const query, HCOUNTER* const counter) {
+    if (counter && *counter) {
+        PdhRemoveCounter_i(*counter);
+        *counter = NULL;
+    }
+    if (query && *query) {
+        PdhCloseQuery_i(*query);
+        *query = NULL;
+    }
+}
+
+static void
+destroySingleCounter(SingleCounterQueryP counterQuery) {
+    if (counterQuery) {
+        pdhCleanup(&counterQuery->query.query, &counterQuery->counter);
+    }
+}
+
+static void
+destroyMultiCounter(MultipleCounterQueryP multiCounterQuery) {
+    int i;
+    if (multiCounterQuery) {
+        if (multiCounterQuery->counters) {
+            for (i = 0; i < multiCounterQuery->noOfCounters; i++) {
+                pdhCleanup(NULL, &multiCounterQuery->counters[i]);
+            }
+            free(multiCounterQuery->counters);
+            multiCounterQuery->counters = NULL;
+        }
+        pdhCleanup(&multiCounterQuery->query.query, NULL);
+    }
+}
+
+static int
+openQuery(HQUERY* const query) {
+    assert(query);
+
+    if (PdhOpenQuery_i(NULL, 0, query) != ERROR_SUCCESS) {
+        return -1;
+    }
+
+    return 0;
+}
+
+static int
+addCounter(HQUERY query,
+           const char* const fullCounterPath,
+           HCOUNTER* const counter) {
+
+    assert(fullCounterPath);
+    assert(counter);
+
+    if (PdhAddCounter_i(query,
+                        fullCounterPath,
+                        0,
+                        counter) != ERROR_SUCCESS) {
+        return -1;
+    }
+
+    return 0;
+}
+
+/*
+ * Sets up the supplied SingleCounterQuery to listen for the specified counter.
+ *
+ * @param counterQuery       the counter query to set up.
+ * @param fullCounterPath    the string specifying the full path to the counter.
+ * @returns                  0 if successful, negative on failure.
+ */
+static int
+initializeSingleCounterQuery(SingleCounterQueryP counterQuery,
+                             const char* const fullCounterPath) {
+    assert(counterQuery);
+    assert(fullCounterPath);
+
+    if (openQuery(&counterQuery->query.query) == 0) {
+        if (addCounter(counterQuery->query.query,
+                       fullCounterPath,
+                       &counterQuery->counter) == 0) {
+            return 0;
+        }
+    }
+
+    return -1;
+}
+
+/*
+ * Sets up a SingleCounterQuery
+ *
+ * param counter             the counter query to set up.
+ * param localizedObject     string representing the PDH object to query
+ * param localizedCounter    string representing the PDH counter to query
+ * param processImageName    if the counter query needs the process image name ("java")
+ * param instance            if the counter has instances, this is the instance ("\Processor(0)\")
+                                 where 0 is the instance
+ * param firstSampleOnInit   for counters that need two queries to yield their values,
+                                 the first query can be issued just after initialization
+ *
+ * @returns                   0 if successful, negative on failure.
+ */
+static int
+initializeSingleCounter(SingleCounterQueryP const counter,
+                        const char* const localizedObject,
+                        const char* const localizedCounter,
+                        const char* const processImageName,
+                        const char* const instance,
+                        BOOL firstSampleOnInit) {
+    int retValue = -1;
+
+    const char* fullCounterPath = makeFullCounterPath(localizedObject,
+                                                      localizedCounter,
+                                                      processImageName,
+                                                      instance);
+
+    if (fullCounterPath) {
+
+        assert(counter);
+
+        if (initializeSingleCounterQuery(counter, fullCounterPath) == 0) {
+            /*
+             * According to the MSDN documentation, rate counters must be read twice:
+             *
+             * "Obtaining the value of rate counters such as Page faults/sec requires that
+             *  PdhCollectQueryData be called twice, with a specific time interval between
+             *  the two calls, before calling PdhGetFormattedCounterValue. Call Sleep to
+             *  implement the waiting period between the two calls to PdhCollectQueryData."
+             *
+             *  Take the first sample here already to allow for the next (first) "real" sample
+             *  to succeed.
+             */
+            if (firstSampleOnInit) {
+                PdhCollectQueryData_i(counter->query.query);
+            }
+
+            retValue = 0;
+        }
+        free((char*)fullCounterPath);
+    }
+
+    return retValue;
+}
+
+static void
+perfInit(void) {
+    InitializePdhCriticalSection(&initializationLock);
+}
+
+static int
+getProcessID() {
+    static int myPid = 0;
+    if (0 == myPid) {
+        myPid = _getpid();
+    }
+    return myPid;
+}
+
+/*
+ * Working against the Process object and it's related counters is inherently problematic
+ * when using the PDH API:
+ *
+ * For PDH, a process is not primarily identified by it's process id,
+ * but with a sequential number, for example \Process(java#0), \Process(java#1), ....
+ * The really bad part is that this list is reset as soon as one process exits:
+ * If \Process(java#1) exits, \Process(java#3) now becomes \Process(java#2) etc.
+ *
+ * The PDH query api requires a process identifier to be submitted when registering
+ * a query, but as soon as the list resets, the query is invalidated (since the name
+ * changed).
+ *
+ * Solution:
+ * The #number identifier for a Process query can only decrease after process creation.
+ *
+ * Therefore we create an array of counter queries for all process object instances
+ * up to and including ourselves:
+ *
+ * Ex. we come in as third process instance (java#2), we then create and register
+ * queries for the following Process object instances:
+ * java#0, java#1, java#2
+ *
+ * currentQueryIndexForProcess() keeps track of the current "correct" query
+ * (in order to keep this index valid when the list resets from underneath,
+ * ensure to call getCurrentQueryIndexForProcess() before every query involving
+ * Process object instance data).
+ */
+static int
+currentQueryIndexForProcess(void) {
+    HQUERY tmpQuery = NULL;
+    HCOUNTER handleCounter = NULL;
+    int retValue = -1;
+
+    assert(pdhProcessImageName);
+    assert(pdhIDProcessCounterFmt);
+
+    if (openQuery(&tmpQuery) == 0) {
+        int index;
+
+        /* iterate over all instance indexes and try to find our own pid */
+        for (index = 0; index < INT_MAX; ++index) {
+            char fullIDProcessCounterPath[MAX_PATH];
+            PDH_FMT_COUNTERVALUE counterValue;
+            PDH_STATUS res;
+
+            _snprintf(fullIDProcessCounterPath,
+                      MAX_PATH,
+                      pdhIDProcessCounterFmt,
+                      index);
+
+            if (addCounter(tmpQuery, fullIDProcessCounterPath, &handleCounter) != 0) {
+                break;
+            }
+
+            res = PdhCollectQueryData_i(tmpQuery);
+
+            if (PDH_INVALID_HANDLE == res || PDH_NO_DATA == res) {
+                break;
+            }
+
+            PdhGetFormattedCounterValue_i(handleCounter,
+                                          PDH_FMT_LONG,
+                                          NULL,
+                                          &counterValue);
+            /*
+             * This check seems to be needed for Win2k SMP boxes, since
+             * they for some reason don't return PDH_NO_DATA for non existing
+             * counters.
+             */
+            if (counterValue.CStatus != PDH_CSTATUS_VALID_DATA) {
+                break;
+            }
+
+            if ((LONG)getProcessID() == counterValue.longValue) {
+                retValue = index;
+                break;
+            }
+        }
+    }
+
+    pdhCleanup(&tmpQuery, &handleCounter);
+
+    return retValue;
+}
+
+/*
+ * If successful, returns the #index corresponding to our PID
+ * as resolved by the pdh query:
+ * "\Process(java#index)\ID Process" (or localized equivalent)
+ *
+ * This function should be called before attempting to read
+ * from any Process related counter(s), and the return value
+ * is the index to be used for indexing an array of Process object query's:
+ *
+ * Example:
+ * processTotalCPULoad[currentQueryIndex].query
+ *
+ * Returns -1 on failure.
+ */
+static int
+getCurrentQueryIndexForProcess() {
+    int currentQueryIndex = currentQueryIndexForProcess();
+
+    assert(currentQueryIndex >= 0 &&
+           currentQueryIndex < numberOfJavaProcessesAtInitialization);
+
+    return currentQueryIndex;
+}
+
+/*
+ * Returns the PDH string identifying the current process image name.
+ * Use this name as a qualifier when getting counters from the PDH Process Object
+ * representing your process.
+
+ * Example:
+ * "\Process(java#0)\Virtual Bytes" - where "java" is the PDH process
+ * image name.
+ *
+ * Please note that the process image name is not necessarily "java",
+ * hence the use of GetModuleFileName() to detect the process image name.
+ *
+ * @return   the process image name to be used when retrieving
+ *           PDH counters from the current process. The caller will
+             own the returned malloc:ed string. NULL if failure.
+ */
+static const char*
+getPdhProcessImageName() {
+    char moduleName[MAX_PATH];
+    char* processImageName;
+    char* dotPos;
+
+    // Find our module name and use it to extract the image name used by PDH
+    DWORD getmfnReturn = GetModuleFileName(NULL, moduleName, sizeof(moduleName));
+
+    if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
+        return NULL;
+    }
+
+    if (getmfnReturn >= MAX_PATH || 0 == getmfnReturn) {
+        return NULL;
+    }
+
+    processImageName = strrchr(moduleName, '\\'); //drop path
+    processImageName++;                           //skip slash
+    dotPos = strrchr(processImageName, '.');      //drop .exe
+    dotPos[0] = '\0';
+
+    return allocateAndCopy(processImageName);
+}
+
+/*
+ * Sets up the supplied MultipleCounterQuery to check on the processors via PDH CPU counters.
+ * TODO: Refactor and prettify as with the the SingleCounter queries
+ * if more MultipleCounterQueries are discovered/needed.
+ *
+ * @param multiCounterCPULoad  a pointer to a MultipleCounterQueryS, will be filled in with
+ *                             the necessary info to check the PDH processor counters.
+ * @return                     0 if successful, negative on failure.
+ */
+static int
+initializeMultipleCounterForCPUs(MultipleCounterQueryP multiCounterCPULoad) {
+    DWORD cSize = 0;
+    DWORD iSize = 0;
+    DWORD pCount;
+    DWORD index;
+    char* processor = NULL; //'Processor' == PDH_PROCESSOR_IDX
+    char* time = NULL;      //'Time' == PDH_PROCESSOR_TIME_IDX
+    char* instances = NULL;
+    char* tmp;
+    int   retValue = -1;
+    PDH_STATUS pdhStat;
+
+    if (lookupNameByIndex(PDH_PROCESSOR_IDX, &processor) != 0) {
+        goto end;
+    }
+
+    if (lookupNameByIndex(PDH_PROCESSOR_TIME_IDX, &time) != 0) {
+        goto end;
+    }
+
+    //ok, now we have enough to enumerate all processors.
+    pdhStat = PdhEnumObjectItems_i(
+                                   NULL, // reserved
+                                   NULL, // local machine
+                                   processor, // object to enumerate
+                                   NULL, // pass in NULL buffers
+                                   &cSize, // and 0 length to get
+                                   NULL, // required size
+                                   &iSize, // of the buffers in chars
+                                   PERF_DETAIL_WIZARD, // counter detail level
+                                   0);
+
+    if (pdhFail(pdhStat)) {
+        goto end;
+    }
+
+    instances = calloc(iSize, 1);
+
+    if (!instances) {
+        goto end;
+    }
+
+    cSize = 0;
+
+    pdhStat = PdhEnumObjectItems_i(
+                                   NULL, // reserved
+                                   NULL, // local machine
+                                   processor, // object to enumerate
+                                   NULL, // pass in NULL buffers
+                                   &cSize,
+                                   instances, // now allocated to be filled in
+                                   &iSize, // and size is known
+                                   PERF_DETAIL_WIZARD, // counter detail level
+                                   0);
+
+    if (pdhFail(pdhStat)) {
+        goto end;
+    }
+
+    // enumerate the Processor instances ("\Processor(0)", "\Processor(1)", ..., "\Processor(_Total)")
+    for (pCount = 0, tmp = instances; *tmp != '\0'; tmp = &tmp[strlen(tmp)+1], pCount++);
+
+    assert(pCount == numCpus+1);
+
+    //ok, we now have the number of Processor instances - allocate an HCOUNTER for each
+    multiCounterCPULoad->counters = (HCOUNTER*)malloc(pCount * sizeof(HCOUNTER));
+
+    if (!multiCounterCPULoad->counters) {
+        goto end;
+    }
+
+    multiCounterCPULoad->noOfCounters = pCount;
+
+    if (openQuery(&multiCounterCPULoad->query.query) != 0) {
+        goto end;
+    }
+
+    // fetch instance and register its corresponding HCOUNTER with the query
+    for (index = 0, tmp = instances; *tmp != '\0'; tmp = &tmp[strlen(tmp)+1], ++index) {
+        const char* const fullCounterPath = makeFullCounterPath(processor, time, NULL, tmp);
+
+        if (!fullCounterPath) {
+            goto end;
+        }
+
+        retValue = addCounter(multiCounterCPULoad->query.query,
+                              fullCounterPath,
+                              &multiCounterCPULoad->counters[index]);
+
+        free((char*)fullCounterPath);
+
+        if (retValue != 0) {
+            goto end;
+        }
+    }
+
+    // Query once to initialize the counters which require at least two samples
+    // (like the % CPU usage) to calculate correctly.
+    PdhCollectQueryData_i(multiCounterCPULoad->query.query);
+
+  end:
+    if (processor) {
+        free(processor);
+    }
+
+    if (time) {
+        free(time);
+    }
+
+    if (instances) {
+        free(instances);
+    }
+
+    return retValue;
+}
+
+/*
  * Dynamically sets up function pointers to the PDH library.
  *
- * @return CONFIG_SUCCESSFUL on success, negative on failure.
+ * @param h  HMODULE for the PDH library
+ * @return   0 on success, negative on failure.
  */
 static int
-get_functions(HMODULE h, char *ebuf, size_t elen) {
-    // The 'A' at the end means the ANSI (not the UNICODE) vesions of the methods
+bindPdhFunctionPointers(HMODULE h) {
+    assert(h);
+    assert(GetCurrentThreadId() == initializationLock.owningThread);
+
+    /* The 'A' at the end means the ANSI (not the UNICODE) vesions of the methods */
     PdhAddCounter_i         = (PdhAddCounterFunc)GetProcAddress(h, "PdhAddCounterA");
     PdhOpenQuery_i         = (PdhOpenQueryFunc)GetProcAddress(h, "PdhOpenQueryA");
     PdhCloseQuery_i         = (PdhCloseQueryFunc)GetProcAddress(h, "PdhCloseQuery");
@@ -312,42 +968,41 @@
     PdhEnumObjectItems_i         = (PdhEnumObjectItemsFunc)GetProcAddress(h, "PdhEnumObjectItemsA");
     PdhRemoveCounter_i         = (PdhRemoveCounterFunc)GetProcAddress(h, "PdhRemoveCounter");
     PdhLookupPerfNameByIndex_i     = (PdhLookupPerfNameByIndexFunc)GetProcAddress(h, "PdhLookupPerfNameByIndexA");
-    PdhMakeCounterPath_i         = (PdhMakeCounterPathFunc)GetProcAddress(h, "PdhMakeCounterPathA");
 
-    if (PdhAddCounter_i == NULL || PdhOpenQuery_i == NULL ||
-    PdhCloseQuery_i == NULL || PdhCollectQueryData_i == NULL ||
-    PdhGetFormattedCounterValue_i == NULL || PdhEnumObjectItems_i == NULL ||
-    PdhRemoveCounter_i == NULL || PdhLookupPerfNameByIndex_i == NULL || PdhMakeCounterPath_i == NULL)
+    if (!PdhAddCounter_i || !PdhOpenQuery_i ||
+        !PdhCloseQuery_i || !PdhCollectQueryData_i ||
+        !PdhGetFormattedCounterValue_i || !PdhEnumObjectItems_i ||
+        !PdhRemoveCounter_i || !PdhLookupPerfNameByIndex_i)
     {
-        _snprintf(ebuf, elen, "Required method could not be found.");
         return -1;
     }
-    return CONFIG_SUCCESSFUL;
+    return 0;
 }
 
-/**
+/*
  * Returns the counter value as a double for the specified query.
  * Will collect the query data and update the counter values as necessary.
  *
  * @param query       the query to update (if needed).
- * @param c          the counter to read.
+ * @param c           the counter to read.
  * @param value       where to store the formatted value.
  * @param format      the format to use (i.e. PDH_FMT_DOUBLE, PDH_FMT_LONG etc)
- * @return            CONFIG_SUCCESSFUL if no error
+ * @return            0 if no error
  *                    -1 if PdhCollectQueryData fails
  *                    -2 if PdhGetFormattedCounterValue fails
  */
 static int
 getPerformanceData(UpdateQueryP query, HCOUNTER c, PDH_FMT_COUNTERVALUE* value, DWORD format) {
-    clock_t now;
-    now = clock();
+    clock_t now = clock();
 
-    // Need to limit how often we update the query
-    // to mimise the heisenberg effect.
-    // (PDH behaves erratically if the counters are
-    // queried too often, especially counters that
-    // store and use values from two consecutive updates,
-    // like cpu load.)
+    /*
+     * Need to limit how often we update the query
+     * to minimize the Heisenberg effect.
+     * (PDH behaves erratically if the counters are
+     * queried too often, especially counters that
+     * store and use values from two consecutive updates,
+     * like cpu load.)
+     */
     if (now - query->lastUpdate > MIN_UPDATE_INTERVAL) {
         if (PdhCollectQueryData_i(query->query) != ERROR_SUCCESS) {
             return -1;
@@ -358,500 +1013,308 @@
     if (PdhGetFormattedCounterValue_i(c, format, NULL, value) != ERROR_SUCCESS) {
         return -2;
     }
-    return CONFIG_SUCCESSFUL;
+
+    return 0;
 }
 
-/**
- * Places the resolved counter name of the counter at the specified index in the
- * supplied buffer. There must be enough space in the buffer to hold the counter name.
- *
- * @param index   the counter index as specified in the registry.
- * @param buf     the buffer in which to place the counter name.
- * @param size      the size of the counter name buffer.
- * @param ebuf    the error message buffer.
- * @param elen    the length of the error buffer.
- * @return        CONFIG_SUCCESSFUL if successful, negative on failure.
- */
 static int
-find_name(DWORD index, char *buf, DWORD size) {
-    PDH_STATUS res;
+allocateAndInitializePdhConstants() {
+    const char* pdhLocalizedProcessObject = NULL;
+    const char* pdhLocalizedIDProcessCounter = NULL;
+    size_t pdhIDProcessCounterFmtLen;
+    int currentQueryIndex;
+    int retValue = -1;
 
-    if ((res = PdhLookupPerfNameByIndex_i(NULL, index, buf, &size)) != ERROR_SUCCESS) {
+    assert(GetCurrentThreadId() == initializationLock.owningThread);
 
-        /* printf("Could not open counter %d: error=0x%08x", index, res); */
-        /* if (res == PDH_CSTATUS_NO_MACHINE) { */
-        /*      printf("User probably does not have sufficient privileges to use"); */
-        /*      printf("performance counters. If you are running on Windows 2003"); */
-        /*      printf("or Windows Vista, make sure the user is in the"); */
-        /*      printf("Performance Logs user group."); */
-        /* } */
+    assert(!pdhProcessImageName);
+    pdhProcessImageName = getPdhProcessImageName();
+    if (!pdhProcessImageName) {
+        goto end;
+    }
+
+    pdhLocalizedProcessObject = getPdhLocalizedArtifact(PDH_PROCESS_IDX);
+    if (!pdhLocalizedProcessObject) {
+        goto end;
+    }
+
+    pdhLocalizedIDProcessCounter = getPdhLocalizedArtifact(PDH_ID_PROCESS_IDX);
+    if (!pdhLocalizedIDProcessCounter) {
+        goto end;
+    }
+
+    assert(!pdhIDProcessCounterFmt);
+
+    pdhIDProcessCounterFmtLen = strlen(pdhProcessImageName);
+    pdhIDProcessCounterFmtLen += strlen(pdhLocalizedProcessObject);
+    pdhIDProcessCounterFmtLen += strlen(pdhLocalizedIDProcessCounter);
+    pdhIDProcessCounterFmtLen += PROCESS_OBJECT_INSTANCE_COUNTER_FMT_LEN;
+    pdhIDProcessCounterFmtLen += 2; // "%d"
+
+    assert(pdhIDProcessCounterFmtLen < MAX_PATH);
+    pdhIDProcessCounterFmt = malloc(pdhIDProcessCounterFmtLen + 1);
+    if (!pdhIDProcessCounterFmt) {
+        goto end;
+    }
+
+    /* "\Process(java#%d)\ID Process" */
+    _snprintf(pdhIDProcessCounterFmt,
+              pdhIDProcessCounterFmtLen,
+              PROCESS_OBJECT_INSTANCE_COUNTER_FMT,
+              pdhLocalizedProcessObject,
+              pdhProcessImageName,
+              "%d",
+              pdhLocalizedIDProcessCounter);
+
+    pdhIDProcessCounterFmt[pdhIDProcessCounterFmtLen] = '\0';
+
+    assert(0 == numberOfJavaProcessesAtInitialization);
+    currentQueryIndex = currentQueryIndexForProcess();
+    if (-1 == currentQueryIndex) {
+        goto end;
+    }
+
+    numberOfJavaProcessesAtInitialization = currentQueryIndex + 1;
+    assert(numberOfJavaProcessesAtInitialization >= 1);
+
+    retValue = 0;
+
+  end:
+
+    if (pdhLocalizedProcessObject) {
+        free((char*)pdhLocalizedProcessObject);
+    }
+
+    if (pdhLocalizedIDProcessCounter) {
+        free((char*)pdhLocalizedIDProcessCounter);
+    }
+
+    return retValue;
+}
+
+static void
+deallocatePdhConstants() {
+    assert(GetCurrentThreadId() == initializationLock.owningThread);
+
+    if (pdhProcessImageName) {
+        free((char*)pdhProcessImageName);
+        pdhProcessImageName = NULL;
+    }
+
+    if (pdhIDProcessCounterFmt) {
+      free(pdhIDProcessCounterFmt);
+      pdhIDProcessCounterFmt = NULL;
+    }
+
+    numberOfJavaProcessesAtInitialization = 0;
+}
+
+static int
+initializeCPUCounters() {
+    SYSTEM_INFO si;
+    char* localizedProcessObject;
+    char* localizedProcessorTimeCounter;
+    int i;
+    int retValue = -1;
+
+    assert(GetCurrentThreadId() == initializationLock.owningThread);
+
+    assert(0 == numCpus);
+    GetSystemInfo(&si);
+    numCpus = si.dwNumberOfProcessors;
+    assert(numCpus >= 1);
+
+    /* Initialize the denominator for the jvm load calculations */
+    assert(.0 == cpuFactor);
+    cpuFactor = numCpus * 100;
+
+    if (lookupNameByIndex(PDH_PROCESS_IDX,
+                          &localizedProcessObject) == 0) {
+
+        if (lookupNameByIndex(PDH_PROCESSOR_TIME_IDX,
+                              &localizedProcessorTimeCounter) == 0) {
+
+            assert(processTotalCPULoad);
+            assert(pdhProcessImageName);
+
+            for (i = 0; i < numberOfJavaProcessesAtInitialization; ++i) {
+                char instanceIndexBuffer[32];
+                retValue = initializeSingleCounter(&processTotalCPULoad[i],
+                                                   localizedProcessObject,
+                                                   localizedProcessorTimeCounter,
+                                                   pdhProcessImageName,
+                                                   itoa(i, instanceIndexBuffer, 10),
+                                                   TRUE);
+                if (retValue != 0) {
+                    break;
+                }
+            }
+            free(localizedProcessorTimeCounter);
+        }
+        free(localizedProcessObject);
+    }
+
+    if (retValue != 0) {
         return -1;
     }
 
-    if (size == 0) {
-        /* printf("Failed to get counter name for %d: empty string", index); */
+    assert(multiCounterCPULoad);
+    return initializeMultipleCounterForCPUs(multiCounterCPULoad);
+}
+
+static void
+deallocateCPUCounters() {
+    int i;
+
+    assert(GetCurrentThreadId() == initializationLock.owningThread);
+
+    if (processTotalCPULoad) {
+        for (i = 0; i < numberOfJavaProcessesAtInitialization; ++i) {
+            destroySingleCounter(&processTotalCPULoad[i]);
+        }
+        free(processTotalCPULoad);
+        processTotalCPULoad = NULL;
+    }
+
+    if (multiCounterCPULoad) {
+        destroyMultiCounter(multiCounterCPULoad);
+        free(multiCounterCPULoad);
+        multiCounterCPULoad = NULL;
+    }
+
+    cpuFactor = .0;
+    numCpus = 0;
+}
+
+static void
+pdhInitErrorHandler(HMODULE h) {
+    assert(GetCurrentThreadId() == initializationLock.owningThread);
+
+    deallocatePdhConstants();
+
+    if (h) {
+        FreeLibrary(h);
+    }
+}
+
+/*
+ * Helper to initialize the PDH library, function pointers and constants.
+ *
+ * @return  0 if successful, negative on failure.
+ */
+static int
+pdhInit() {
+    static BOOL initialized = FALSE;
+    int retValue;
+
+    if (initialized) {
+        return 0;
+    }
+
+    retValue = 0;
+
+    EnterPdhCriticalSection(&initializationLock); {
+        if (!initialized) {
+            HMODULE h = NULL;
+            if ((h = LoadLibrary("pdh.dll")) == NULL) {
+                retValue = -1;
+            } else if (bindPdhFunctionPointers(h) < 0) {
+                retValue = -1;
+            } else if (allocateAndInitializePdhConstants() < 0) {
+                retValue = -1;
+            }
+
+            if (0 == retValue) {
+                initialized = TRUE;
+            } else {
+                pdhInitErrorHandler(h);
+            }
+        }
+    } LeavePdhCriticalSection(&initializationLock);
+
+    return retValue;
+}
+
+static int
+allocateCPUCounters() {
+    assert(GetCurrentThreadId() == initializationLock.owningThread);
+    assert(numberOfJavaProcessesAtInitialization >= 1);
+    assert(!processTotalCPULoad);
+    assert(!multiCounterCPULoad);
+
+    /*
+     * Create an array of Process object queries, for each instance
+     * up to and including our own (java#0, java#1, java#2, ...).
+     */
+    processTotalCPULoad = calloc(numberOfJavaProcessesAtInitialization,
+                                 sizeof(SingleCounterQueryS));
+
+    if (!processTotalCPULoad) {
         return -1;
     }
 
-    // windows vista does not null-terminate the string (allthough the docs says it will)
-    buf[size - 1] = '\0';
-    return CONFIG_SUCCESSFUL;
-}
+    multiCounterCPULoad = calloc(1, sizeof(MultipleCounterQueryS));
 
-/**
- * Sets up the supplied SingleCounterQuery to listen for the specified counter.
- * initPDH() must have been run prior to calling this function!
- *
- * @param counterQuery   the counter query to set up.
- * @param counterString  the string specifying the path to the counter.
- * @param ebuf           the error buffer.
- * @param elen           the length of the error buffer.
- * @returns              CONFIG_SUCCESSFUL if successful, negative on failure.
- */
-static int
-initSingleCounterQuery(SingleCounterQueryP counterQuery, char *counterString) {
-    if (PdhOpenQuery_i(NULL, 0, &counterQuery->query.query) != ERROR_SUCCESS) {
-        /* printf("Could not open query for %s", counterString); */
+    if (!multiCounterCPULoad) {
         return -1;
     }
-    if (PdhAddCounter_i(counterQuery->query.query, counterString, 0, &counterQuery->counter) != ERROR_SUCCESS) {
-        /* printf("Could not add counter %s for query", counterString); */
-        if (counterQuery->counter != NULL) {
-            PdhRemoveCounter_i(counterQuery->counter);
-        }
-        if (counterQuery->query.query != NULL) {
-            PdhCloseQuery_i(counterQuery->query.query);
-        }
-        memset(counterQuery, 0, sizeof(SingleCounterQueryS));
-        return -1;
-    }
-    return CONFIG_SUCCESSFUL;
-}
 
-/**
- * Sets up the supplied SingleCounterQuery to listen for the time spent
- * by the HotSpot process.
- *
- * @param counterQuery   the counter query to set up as a process counter.
- * @param ebuf           the error buffer.
- * @param elen           the length of the error buffer.
- * @returns              CONFIG_SUCCESSFUL if successful, negative on failure.
- */
-static int
-initProcLoadCounter(void) {
-    char time[COUNTER_BUF_SIZE];
-    char counter[COUNTER_BUF_SIZE*2];
-
-    if (find_name(PDH_PROCESSOR_TIME_IDX, time, sizeof(time)-1) < 0) {
-        return -1;
-    }
-    _snprintf(counter, sizeof(counter)-1, "%s\\%s", getProcessPDHHeader(), time);
-    return initSingleCounterQuery(&cntProcLoad, counter);
+    return 0;
 }
 
 static int
-initProcSystemLoadCounter(void) {
-    char time[COUNTER_BUF_SIZE];
-    char counter[COUNTER_BUF_SIZE*2];
+initializePdhCPUCounters() {
+    static BOOL initialized = FALSE;
+    int retValue;
 
-    if (find_name(PDH_PRIV_PROCESSOR_TIME_IDX, time, sizeof(time)-1) < 0) {
-        return -1;
+    if (initialized) {
+        return 0;
     }
-    _snprintf(counter, sizeof(counter)-1, "%s\\%s", getProcessPDHHeader(), time);
-    return initSingleCounterQuery(&cntProcSystemLoad, counter);
+
+    retValue = 0;
+
+    EnterPdhCriticalSection(&initializationLock); {
+        if (!initialized) {
+            if (pdhInit() < 0) {
+                retValue = -1;
+            }  else if (allocateCPUCounters() < 0) {
+                retValue = -1;
+            } else if (initializeCPUCounters() < 0) {
+                retValue = -1;
+            }
+
+            if (0 == retValue) {
+                initialized = TRUE;
+            } else {
+              deallocateCPUCounters();
+            }
+        }
+    } LeavePdhCriticalSection(&initializationLock);
+
+    return retValue;
 }
 
-/**
- * Sets up the supplied MultipleCounterQuery to check on the processors.
- * (Comment: Refactor and prettify as with the the SingleCounter queries
- * if more MultipleCounterQueries are discovered.)
- *
- * initPDH() must have been run prior to calling this function.
- *
- * @param multiQuery  a pointer to a MultipleCounterQueryS, will be filled in with
- *                    the necessary info to check the PDH processor counters.
- * @return            CONFIG_SUCCESSFUL if successful, negative on failure.
- */
 static int
-initProcessorCounters(void) {
-    char          processor[COUNTER_BUF_SIZE]; //'Processor' == #238
-    char          time[COUNTER_BUF_SIZE];      //'Time' == 6
-    DWORD      c_size, i_size;
-    HQUERY     tmpQuery;
-    DWORD      i, p_count;
-    BOOL          error;
-    char         *instances, *tmp;
-    PDH_STATUS pdhStat;
-
-    c_size   = i_size = 0;
-    tmpQuery = NULL;
-    error    = false;
-
-    // This __try / __except stuff is there since Windows 2000 beta (or so) sometimes triggered
-    // an access violation when the user had insufficient privileges to use the performance
-    // counters. This was previously guarded by a very ugly piece of code which disabled the
-    // global trap handling in JRockit. Don't know if this really is needed anymore, but otoh,
-    // if we keep it we don't crash on Win2k beta. /Ihse, 2005-05-30
-    __try {
-        if (find_name(PDH_PROCESSOR_IDX, processor, sizeof(processor)-1) < 0) {
-            return -1;
-        }
-    } __except (EXCEPTION_EXECUTE_HANDLER) { // We'll catch all exceptions here.
-        /* printf("User does not have sufficient privileges to use performance counters"); */
-        return -1;
-    }
-
-    if (find_name(PDH_PROCESSOR_TIME_IDX, time, sizeof(time)-1) < 0) {
-        return -1;
-    }
-    //ok, now we have enough to enumerate all processors.
-    pdhStat = PdhEnumObjectItems_i (
-                    NULL,                   // reserved
-                    NULL,                   // local machine
-                    processor,          // object to enumerate
-                    NULL,              // pass in NULL buffers
-                    &c_size,              // and 0 length to get
-                    NULL,              // required size
-                    &i_size,              // of the buffers in chars
-                    PERF_DETAIL_WIZARD,     // counter detail level
-                    0);
-    if (pdh_fail(pdhStat)) {
-        /* printf("could not enumerate processors (1) error=%d", pdhStat); */
-        return -1;
-    }
-
-    // use calloc because windows vista does not null terminate the instance names (allthough the docs says it will)
-    instances = calloc(i_size, 1);
-    if (instances == NULL) {
-        /* printf("could not allocate memory (1) %d bytes", i_size); */
-        error = true;
-        goto end;
-    }
-
-    c_size  = 0;
-    pdhStat = PdhEnumObjectItems_i (
-                    NULL,                   // reserved
-                    NULL,                   // local machine
-                    processor,              // object to enumerate
-                    NULL,              // pass in NULL buffers
-                    &c_size,              // and 0 length to get
-                    instances,          // required size
-                    &i_size,              // of the buffers in chars
-                    PERF_DETAIL_WIZARD,     // counter detail level
-                    0);
-
-    if (pdh_fail(pdhStat)) {
-        /* printf("could not enumerate processors (2) error=%d", pdhStat); */
-        error = true;
-        goto end;
-    }
-    //count perf count instances.
-    for (p_count = 0, tmp = instances; *tmp != 0; tmp = &tmp[lstrlen(tmp)+1], p_count++);
-
-    //is this correct for HT?
-    assert(p_count == num_cpus+1);
-
-    //ok, have number of perf counters.
-    multiCounterCPULoad.counters = calloc(p_count, sizeof(HCOUNTER));
-    if (multiCounterCPULoad.counters == NULL) {
-        /* printf("could not allocate memory (2) count=%d", p_count); */
-        error = true;
-        goto end;
-    }
-
-    multiCounterCPULoad.noOfCounters = p_count;
-
-    if (PdhOpenQuery_i(NULL, 0, &multiCounterCPULoad.query.query) != ERROR_SUCCESS) {
-        /* printf("could not create query"); */
-        error = true;
-        goto end;
-    }
-    //now, fetch the counters.
-    for (i = 0, tmp = instances; *tmp != '\0'; tmp = &tmp[lstrlen(tmp)+1], i++) {
-    char counter[2*COUNTER_BUF_SIZE];
-
-    _snprintf(counter, sizeof(counter)-1, "\\%s(%s)\\%s", processor, tmp, time);
-
-    if (PdhAddCounter_i(multiCounterCPULoad.query.query, counter, 0, &multiCounterCPULoad.counters[i]) != ERROR_SUCCESS) {
-            /* printf("error adding processor counter %s", counter); */
-            error = true;
-            goto end;
-        }
-    }
-
-    free(instances);
-    instances = NULL;
-
-    // Query once to initialize the counters needing at least two queries
-    // (like the % CPU usage) to calculate correctly.
-    if (PdhCollectQueryData_i(multiCounterCPULoad.query.query) != ERROR_SUCCESS)
-        error = true;
-
- end:
-    if (instances != NULL) {
-        free(instances);
-    }
-    if (tmpQuery != NULL) {
-        PdhCloseQuery_i(tmpQuery);
-    }
-    if (error) {
-        int i;
-
-        if (multiCounterCPULoad.counters != NULL) {
-            for (i = 0; i < multiCounterCPULoad.noOfCounters; i++) {
-                if (multiCounterCPULoad.counters[i] != NULL) {
-                    PdhRemoveCounter_i(multiCounterCPULoad.counters[i]);
-                }
-            }
-            free(multiCounterCPULoad.counters[i]);
-        }
-        if (multiCounterCPULoad.query.query != NULL) {
-            PdhCloseQuery_i(multiCounterCPULoad.query.query);
-        }
-        memset(&multiCounterCPULoad, 0, sizeof(MultipleCounterQueryS));
-        return -1;
-    }
-    return CONFIG_SUCCESSFUL;
+perfCPUInit() {
+    return initializePdhCPUCounters();
 }
 
-/**
- * Help function that initializes the PDH process header for the JRockit process.
- * (You should probably use getProcessPDHHeader() instead!)
- *
- * initPDH() must have been run prior to calling this function.
- *
- * @param ebuf the error buffer.
- * @param elen the length of the error buffer.
- *
- * @return the PDH instance description corresponding to the JVM process.
- */
-static char*
-initProcessPDHHeader(void) {
-    static char hotspotheader[2*COUNTER_BUF_SIZE];
+static double
+perfGetProcessCPULoad() {
+    PDH_FMT_COUNTERVALUE cv;
+    int currentQueryIndex;
 
-    char           counter[2*COUNTER_BUF_SIZE];
-    char           processes[COUNTER_BUF_SIZE];   //'Process' == #230
-    char           pid[COUNTER_BUF_SIZE];           //'ID Process' == 784
-    char           module_name[MAX_PATH];
-    PDH_STATUS  pdhStat;
-    DWORD       c_size = 0, i_size = 0;
-    HQUERY      tmpQuery = NULL;
-    int           i, myPid = _getpid();
-    BOOL           error = false;
-    char          *instances, *tmp, *instance_name, *dot_pos;
-
-    tmpQuery = NULL;
-    myPid    = _getpid();
-    error    = false;
-
-    if (find_name(PDH_PROCESS_IDX, processes, sizeof(processes) - 1) < 0) {
-        return NULL;
-    }
-
-    if (find_name(PDH_ID_PROCESS_IDX, pid, sizeof(pid) - 1) < 0) {
-        return NULL;
-    }
-    //time is same.
-
-    c_size = 0;
-    i_size = 0;
-
-    pdhStat = PdhEnumObjectItems_i (
-                    NULL,                   // reserved
-                    NULL,                   // local machine
-                    processes,              // object to enumerate
-                    NULL,                   // pass in NULL buffers
-                    &c_size,              // and 0 length to get
-                    NULL,              // required size
-                    &i_size,              // of the buffers in chars
-                    PERF_DETAIL_WIZARD,     // counter detail level
-                    0);
-
-    //ok, now we have enough to enumerate all processes
-    if (pdh_fail(pdhStat)) {
-        /* printf("Could not enumerate processes (1) error=%d", pdhStat); */
-        return NULL;
-    }
-
-    // use calloc because windows vista does not null terminate the instance names (allthough the docs says it will)
-    if ((instances = calloc(i_size, 1)) == NULL) {
-        /* printf("Could not allocate memory %d bytes", i_size); */
-        error = true;
-        goto end;
-    }
-
-    c_size = 0;
-
-    pdhStat = PdhEnumObjectItems_i (
-                    NULL,                   // reserved
-                    NULL,                   // local machine
-                    processes,              // object to enumerate
-                    NULL,              // pass in NULL buffers
-                    &c_size,              // and 0 length to get
-                    instances,          // required size
-                    &i_size,              // of the buffers in chars
-                    PERF_DETAIL_WIZARD,     // counter detail level
-                    0);
-
-    // ok, now we have enough to enumerate all processes
-    if (pdh_fail(pdhStat)) {
-        /* printf("Could not enumerate processes (2) error=%d", pdhStat); */
-        error = true;
-        goto end;
-    }
-
-    if (PdhOpenQuery_i(NULL, 0, &tmpQuery) != ERROR_SUCCESS) {
-        /* printf("Could not create temporary query"); */
-        error = true;
-        goto end;
-    }
-
-    // Find our module name and use it to extract the instance name used by PDH
-    if (GetModuleFileName(NULL, module_name, MAX_PATH) >= MAX_PATH-1) {
-        /* printf("Module name truncated"); */
-        error = true;
-        goto end;
-    }
-    instance_name = strrchr(module_name, '\\'); //drop path
-    instance_name++;                            //skip slash
-    dot_pos = strchr(instance_name, '.');       //drop .exe
-    dot_pos[0] = '\0';
-
-    //now, fetch the counters.
-    for (tmp = instances; *tmp != 0 && !error; tmp = &tmp[lstrlen(tmp)+1]) {
-        HCOUNTER  hc = NULL;
-        BOOL done = false;
-
-        // Skip until we find our own process name
-        if (strcmp(tmp, instance_name) != 0) {
-            continue;
-        }
-
-        // iterate over all instance indexes and try to find our own pid
-        for (i = 0; !done && !error; i++){
-            PDH_STATUS res;
-            _snprintf(counter, sizeof(counter)-1, "\\%s(%s#%d)\\%s", processes, tmp, i, pid);
-
-            if (PdhAddCounter_i(tmpQuery, counter, 0, &hc) != ERROR_SUCCESS) {
-                /* printf("Failed to create process id query"); */
-                error = true;
-                goto end;
-            }
-
-            res = PdhCollectQueryData_i(tmpQuery);
-
-            if (res == PDH_INVALID_HANDLE) {
-                /* printf("Failed to query process id"); */
-                res = -1;
-                done = true;
-            } else if (res == PDH_NO_DATA) {
-                done = true;
-            } else {
-                PDH_FMT_COUNTERVALUE cv;
-
-                PdhGetFormattedCounterValue_i(hc, PDH_FMT_LONG, NULL, &cv);
-               /*
-                 * This check seems to be needed for Win2k SMP boxes, since
-                 * they for some reason don't return PDH_NO_DATA for non existing
-                 * counters.
-                 */
-                if (cv.CStatus != PDH_CSTATUS_VALID_DATA) {
-                    done = true;
-                } else if (cv.longValue == myPid) {
-                    _snprintf(hotspotheader, sizeof(hotspotheader)-1, "\\%s(%s#%d)\0", processes, tmp, i);
-                    PdhRemoveCounter_i(hc);
-                    goto end;
-                }
-            }
-            PdhRemoveCounter_i(hc);
-        }
-    }
- end:
-    if (instances != NULL) {
-        free(instances);
-    }
-    if (tmpQuery != NULL) {
-        PdhCloseQuery_i(tmpQuery);
-    }
-    if (error) {
-        return NULL;
-    }
-    return hotspotheader;
-}
-
-/**
- * Returns the PDH string prefix identifying the HotSpot process. Use this prefix when getting
- * counters from the PDH process object representing HotSpot.
- *
- * Note: this call may take some time to complete.
- *
- * @param ebuf error buffer.
- * @param elen error buffer length.
- *
- * @return the header to be used when retrieving PDH counters from the HotSpot process.
- * Will return NULL if the call failed.
- */
-static char *
-getProcessPDHHeader(void) {
-    static char *processHeader = NULL;
-
-    EnterCriticalSection(&processHeaderLock); {
-        if (processHeader == NULL) {
-            processHeader = initProcessPDHHeader();
-        }
-    } LeaveCriticalSection(&processHeaderLock);
-    return processHeader;
-}
-
-int perfInit(void);
-
-double
-perfGetCPULoad(int which)
-{
-    PDH_FMT_COUNTERVALUE cv;
-    HCOUNTER            c;
-
-    if (perfInit() < 0) {
+    if (perfCPUInit() < 0) {
         // warn?
         return -1.0;
     }
 
-    if (multiCounterCPULoad.query.query == NULL) {
-        // warn?
-        return -1.0;
-    }
+    currentQueryIndex = getCurrentQueryIndexForProcess();
 
-    if (which == -1) {
-        c = multiCounterCPULoad.counters[multiCounterCPULoad.noOfCounters - 1];
-    } else {
-        if (which < multiCounterCPULoad.noOfCounters) {
-            c = multiCounterCPULoad.counters[which];
-        } else {
-            return -1.0;
-        }
-    }
-    if (getPerformanceData(&multiCounterCPULoad.query, c, &cv, PDH_FMT_DOUBLE ) == CONFIG_SUCCESSFUL) {
-        return cv.doubleValue / 100;
-    }
-    return -1.0;
-}
-
-double
-perfGetProcessLoad(void)
-{
-    PDH_FMT_COUNTERVALUE cv;
-
-    if (perfInit() < 0) {
-        // warn?
-        return -1.0;
-    }
-
-    if (cntProcLoad.query.query == NULL) {
-        // warn?
-        return -1.0;
-    }
-
-    if (getPerformanceData(&cntProcLoad.query, cntProcLoad.counter, &cv, PDH_FMT_DOUBLE | PDH_FMT_NOCAP100) == CONFIG_SUCCESSFUL) {
+    if (getPerformanceData(&processTotalCPULoad[currentQueryIndex].query,
+                           processTotalCPULoad[currentQueryIndex].counter,
+                           &cv,
+                           PDH_FMT_DOUBLE | PDH_FMT_NOCAP100) == 0) {
         double d = cv.doubleValue / cpuFactor;
         d = min(1, d);
         d = max(0, d);
@@ -860,70 +1323,29 @@
     return -1.0;
 }
 
-/**
- * Helper to initialize the PDH library. Loads the library and sets up the functions.
- * Note that once loaded, we will never unload the PDH library.
- *
- * @return  CONFIG_SUCCESSFUL if successful, negative on failure.
- */
-int
-perfInit(void) {
-    static HMODULE    h;
-    static BOOL        running, inited;
+static double
+perfGetCPULoad(int which) {
+    PDH_FMT_COUNTERVALUE cv;
+    HCOUNTER c;
 
-    int error;
-
-    if (running) {
-        return CONFIG_SUCCESSFUL;
+    if (perfCPUInit() < 0) {
+        // warn?
+        return -1.0;
     }
 
-    error = CONFIG_SUCCESSFUL;
-
-    // this is double checked locking again, but we try to bypass the worst by
-    // implicit membar at end of lock.
-    EnterCriticalSection(&initializationLock); {
-        if (!inited) {
-            char         buf[64] = "";
-            SYSTEM_INFO si;
-
-            // CMH. But windows will not care about our affinity when giving
-            // us measurements. Need the real, raw num cpus.
-
-            GetSystemInfo(&si);
-            num_cpus  = si.dwNumberOfProcessors;
-            // Initialize the denominator for the jvm load calculations
-            cpuFactor = num_cpus * 100;
-
-            /**
-             * Do this dynamically, so we don't fail to start on systems without pdh.
-             */
-            if ((h = LoadLibrary("pdh.dll")) == NULL) {
-                /* printf("Could not load pdh.dll (%d)", GetLastError()); */
-                error = -2;
-            } else if (get_functions(h, buf, sizeof(buf)) < 0) {
-                FreeLibrary(h);
-                h = NULL;
-                error = -2;
-               /* printf("Failed to init pdh functions: %s.\n", buf); */
-            } else {
-                if (initProcessorCounters() != 0) {
-                    /* printf("Failed to init system load counters.\n"); */
-                } else if (initProcLoadCounter() != 0) {
-                    /* printf("Failed to init process load counter.\n"); */
-                } else if (initProcSystemLoadCounter() != 0) {
-                    /* printf("Failed to init process system load counter.\n"); */
-                } else {
-                    inited = true;
-                }
-            }
+    if (-1 == which) {
+        c = multiCounterCPULoad->counters[multiCounterCPULoad->noOfCounters - 1];
+    } else {
+        if (which < multiCounterCPULoad->noOfCounters) {
+            c = multiCounterCPULoad->counters[which];
+        } else {
+            return -1.0;
         }
-    } LeaveCriticalSection(&initializationLock);
-
-    if (inited && error == CONFIG_SUCCESSFUL) {
-        running = true;
     }
-
-    return error;
+    if (getPerformanceData(&multiCounterCPULoad->query, c, &cv, PDH_FMT_DOUBLE ) == 0) {
+        return cv.doubleValue / 100;
+    }
+    return -1.0;
 }
 
 JNIEXPORT jdouble JNICALL
@@ -937,5 +1359,5 @@
 Java_sun_management_OperatingSystemImpl_getProcessCpuLoad0
 (JNIEnv *env, jobject dummy)
 {
-    return perfGetProcessLoad();
+    return perfGetProcessCPULoad();
 }
--- a/src/jdk.crypto.pkcs11/share/native/libj2pkcs11/p11_crypt.c	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/jdk.crypto.pkcs11/share/native/libj2pkcs11/p11_crypt.c	Thu Nov 13 09:39:22 2014 -0800
@@ -141,8 +141,8 @@
                                     (CK_BYTE_PTR)(outBufP + jOutOfs),
                                     &ckEncryptedPartLen);
 
-    (*env)->ReleasePrimitiveArrayCritical(env, jOut, outBufP, JNI_ABORT);
     (*env)->ReleasePrimitiveArrayCritical(env, jIn, inBufP, JNI_ABORT);
+    (*env)->ReleasePrimitiveArrayCritical(env, jOut, outBufP, JNI_COMMIT);
 
     ckAssertReturnValueOK(env, rv);
     return ckEncryptedPartLen;
@@ -214,7 +214,7 @@
     }
 
     if (directOut == 0) {
-        (*env)->ReleasePrimitiveArrayCritical(env, jOut, outBufP, JNI_ABORT);
+        (*env)->ReleasePrimitiveArrayCritical(env, jOut, outBufP, JNI_COMMIT);
     }
 
     ckAssertReturnValueOK(env, rv);
@@ -266,7 +266,7 @@
     //printf("EF: ckLastEncryptedPartLen=%i", ckLastEncryptedPartLen);
 
     if (directOut == 0) {
-        (*env)->ReleasePrimitiveArrayCritical(env, jOut, outBufP, JNI_ABORT);
+        (*env)->ReleasePrimitiveArrayCritical(env, jOut, outBufP, JNI_COMMIT);
     }
 
     ckAssertReturnValueOK(env, rv);
@@ -361,8 +361,8 @@
                                     (CK_BYTE_PTR)(outBufP + jOutOfs),
                                     &ckPartLen);
 
-    (*env)->ReleasePrimitiveArrayCritical(env, jOut, outBufP, JNI_ABORT);
     (*env)->ReleasePrimitiveArrayCritical(env, jIn, inBufP, JNI_ABORT);
+    (*env)->ReleasePrimitiveArrayCritical(env, jOut, outBufP, JNI_COMMIT);
 
     ckAssertReturnValueOK(env, rv);
 
@@ -429,7 +429,7 @@
     }
 
     if (directOut == 0) {
-        (*env)->ReleasePrimitiveArrayCritical(env, jOut, outBufP, JNI_ABORT);
+        (*env)->ReleasePrimitiveArrayCritical(env, jOut, outBufP, JNI_COMMIT);
     }
 
     ckAssertReturnValueOK(env, rv);
@@ -478,7 +478,7 @@
                                          &ckLastPartLen);
 
     if (directOut == 0) {
-        (*env)->ReleasePrimitiveArrayCritical(env, jOut, outBufP, JNI_ABORT);
+        (*env)->ReleasePrimitiveArrayCritical(env, jOut, outBufP, JNI_COMMIT);
 
     }
 
--- a/src/jdk.deploy.osx/macosx/classes/apple/security/KeychainStore.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/jdk.deploy.osx/macosx/classes/apple/security/KeychainStore.java	Thu Nov 13 09:39:22 2014 -0800
@@ -294,11 +294,11 @@
             if (entry instanceof TrustedCertEntry) {
                 return ((TrustedCertEntry)entry).cert;
             } else {
-                if (((KeyEntry)entry).chain == null) {
+                KeyEntry ke = (KeyEntry)entry;
+                if (ke.chain == null || ke.chain.length == 0) {
                     return null;
-                } else {
-                    return ((KeyEntry)entry).chain[0];
                 }
+                return ke.chain[0];
             }
         } else {
             return null;
@@ -618,10 +618,12 @@
             Object entry = entries.get(alias);
             if (entry instanceof TrustedCertEntry) {
                 certElem = ((TrustedCertEntry)entry).cert;
-            } else if (((KeyEntry)entry).chain != null) {
-                certElem = ((KeyEntry)entry).chain[0];
             } else {
-                continue;
+                KeyEntry ke = (KeyEntry)entry;
+                if (ke.chain == null || ke.chain.length == 0) {
+                    continue;
+                }
+                certElem = ke.chain[0];
             }
             if (certElem.equals(cert)) {
                 return alias;
--- a/src/jdk.deploy.osx/macosx/native/libosx/KeystoreImpl.m	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/jdk.deploy.osx/macosx/native/libosx/KeystoreImpl.m	Thu Nov 13 09:39:22 2014 -0800
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -279,7 +279,8 @@
     // Search the user keychain list for all identities. Identities are a certificate/private key association that
     // can be chosen for a purpose such as signing or an SSL connection.
     SecIdentitySearchRef identitySearch = NULL;
-    OSStatus err = SecIdentitySearchCreate(NULL, CSSM_KEYUSE_ANY, &identitySearch);
+    // Pass 0 if you want all identities returned by this search
+    OSStatus err = SecIdentitySearchCreate(NULL, 0, &identitySearch);
     SecIdentityRef theIdentity = NULL;
     OSErr searchResult = noErr;
 
--- a/src/jdk.runtime/share/classes/sun/security/tools/policytool/PolicyTool.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/src/jdk.runtime/share/classes/sun/security/tools/policytool/PolicyTool.java	Thu Nov 13 09:39:22 2014 -0800
@@ -1400,7 +1400,13 @@
         if (t instanceof NoDisplayException) {
             return;
         }
-        displayErrorDialog(w, t.toString());
+        if (t.getClass() == Exception.class) {
+            // Exception is usually thrown inside policytool for user
+            // interaction error. There is no need to show the type.
+            displayErrorDialog(w, t.getLocalizedMessage());
+        } else {
+            displayErrorDialog(w, t.toString());
+        }
     }
 
     /**
--- a/test/com/sun/jndi/ldap/LdapTimeoutTest.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/test/com/sun/jndi/ldap/LdapTimeoutTest.java	Thu Nov 13 09:39:22 2014 -0800
@@ -46,8 +46,7 @@
 import static java.util.concurrent.TimeUnit.NANOSECONDS;
 
 public class LdapTimeoutTest {
-    private static final ScheduledExecutorService pool =
-        Executors.newScheduledThreadPool(1);
+
     static volatile int passed = 0, failed = 0;
     static void pass() {passed++;}
     static void fail() {failed++; Thread.dumpStack();}
@@ -80,7 +79,6 @@
             new LdapTimeoutTest().simpleAuthConnectTest(env);
         } finally {
             s.interrupt();
-            LdapTimeoutTest.pool.shutdown();
         }
 
         System.out.printf("%nPassed = %d, failed = %d%n%n", passed, failed);
@@ -90,7 +88,6 @@
     void ldapReadTimeoutTest(Hashtable env, boolean ssl) {
         InitialContext ctx = null;
         if (ssl) env.put(Context.SECURITY_PROTOCOL, "ssl");
-        ScheduledFuture killer = killSwitch(5_000);
         long start = System.nanoTime();
         try {
             ctx = new InitialDirContext(env);
@@ -112,13 +109,12 @@
                 pass();
             }
         } finally {
-            if (!shutItDown(killer, ctx)) fail();
+            if (!shutItDown(ctx)) fail();
         }
     }
 
     void simpleAuthConnectTest(Hashtable env) {
         InitialContext ctx = null;
-        ScheduledFuture killer = killSwitch(5_000);
         long start = System.nanoTime();
         try {
             ctx = new InitialDirContext(env);
@@ -141,13 +137,12 @@
                 fail();
             }
         } finally {
-            if (!shutItDown(killer, ctx)) fail();
+            if (!shutItDown(ctx)) fail();
         }
     }
 
     void deadServerNoTimeout(Hashtable env) {
         InitialContext ctx = null;
-        ScheduledFuture killer = killSwitch(30_000);
         long start = System.currentTimeMillis();
         try {
             ctx = new InitialDirContext(env);
@@ -169,12 +164,11 @@
                 pass();
             }
         } finally {
-            if (!shutItDown(killer, ctx)) fail();
+            if (!shutItDown(ctx)) fail();
         }
     }
 
-    boolean shutItDown(ScheduledFuture killer, InitialContext ctx) {
-        killer.cancel(true);
+    boolean shutItDown(InitialContext ctx) {
         try {
             if (ctx != null) ctx.close();
             return true;
@@ -183,17 +177,6 @@
         }
     }
 
-    ScheduledFuture killSwitch(int ms) {
-        final Thread current = Thread.currentThread();
-        return LdapTimeoutTest.pool.schedule(new Callable<Void>() {
-            public Void call() throws Exception {
-                System.err.println("Fail: killSwitch()");
-                System.exit(0);
-                return null;
-            }
-        }, ms, MILLISECONDS);
-    }
-
     static class Server extends Thread {
         final ServerSocket serverSock;
 
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/com/sun/management/HotSpotDiagnosticMXBean/GetDoubleVMOption.java	Thu Nov 13 09:39:22 2014 -0800
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug     8061616
+ * @summary Basic Test for HotSpotDiagnosticMXBean.getVMOption() and double values
+ * @author  Jaroslav Bachorik
+ *
+ * @run main/othervm -XX:CompileThresholdScaling=0.14 GetDoubleVMOption
+ */
+
+import com.sun.management.HotSpotDiagnosticMXBean;
+import com.sun.management.VMOption;
+import java.lang.management.ManagementFactory;
+import java.util.List;
+import javax.management.MBeanServer;
+
+public class GetDoubleVMOption {
+    private static final String COMPILE_THRESHOLD_SCALING = "CompileThresholdScaling";
+    private static final String EXPECTED_VALUE = "0.14";
+    private static final String HOTSPOT_DIAGNOSTIC_MXBEAN_NAME =
+        "com.sun.management:type=HotSpotDiagnostic";
+
+    public static void main(String[] args) throws Exception {
+        List<HotSpotDiagnosticMXBean> list =
+            ManagementFactory.getPlatformMXBeans(HotSpotDiagnosticMXBean.class);
+        HotSpotDiagnosticMXBean mbean = list.get(0);
+        checkVMOption(mbean);
+
+        MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
+        mbean = ManagementFactory.newPlatformMXBeanProxy(mbs,
+                    HOTSPOT_DIAGNOSTIC_MXBEAN_NAME,
+                    HotSpotDiagnosticMXBean.class);
+        checkVMOption(mbean);
+    }
+
+    private static void checkVMOption(HotSpotDiagnosticMXBean mbean) {
+        VMOption option = mbean.getVMOption(COMPILE_THRESHOLD_SCALING);
+        if (!option.getValue().equalsIgnoreCase(EXPECTED_VALUE)) {
+            throw new RuntimeException("Unexpected value: " +
+                option.getValue() + " expected: " + EXPECTED_VALUE);
+        }
+    }
+}
--- a/test/com/sun/management/HotSpotDiagnosticMXBean/GetVMOption.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/test/com/sun/management/HotSpotDiagnosticMXBean/GetVMOption.java	Thu Nov 13 09:39:22 2014 -0800
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2005, 2008, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2005, 2014, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -32,16 +32,15 @@
 
 import com.sun.management.HotSpotDiagnosticMXBean;
 import com.sun.management.VMOption;
-import com.sun.management.VMOption.Origin;
 import java.lang.management.ManagementFactory;
 import java.util.List;
 import javax.management.MBeanServer;
 
 public class GetVMOption {
-    private static String PRINT_GC_DETAILS = "PrintGCDetails";
-    private static String EXPECTED_VALUE = "true";
-    private static String BAD_OPTION = "BadOption";
-    private static String HOTSPOT_DIAGNOSTIC_MXBEAN_NAME =
+    private static final String PRINT_GC_DETAILS = "PrintGCDetails";
+    private static final String EXPECTED_VALUE = "true";
+    private static final String BAD_OPTION = "BadOption";
+    private static final String HOTSPOT_DIAGNOSTIC_MXBEAN_NAME =
         "com.sun.management:type=HotSpotDiagnostic";
 
     public static void main(String[] args) throws Exception {
--- a/test/com/sun/management/HotSpotDiagnosticMXBean/SetVMOption.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/test/com/sun/management/HotSpotDiagnosticMXBean/SetVMOption.java	Thu Nov 13 09:39:22 2014 -0800
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2005, 2014, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -39,11 +39,11 @@
 import com.sun.management.VMOption.Origin;
 
 public class SetVMOption {
-    private static String PRINT_GC_DETAILS = "PrintGCDetails";
-    private static String EXPECTED_VALUE = "true";
-    private static String BAD_VALUE = "yes";
-    private static String NEW_VALUE = "false";
-    private static String MANAGEMENT_SERVER = "ManagementServer";
+    private static final String PRINT_GC_DETAILS = "PrintGCDetails";
+    private static final String EXPECTED_VALUE = "true";
+    private static final String BAD_VALUE = "yes";
+    private static final String NEW_VALUE = "false";
+    private static final String MANAGEMENT_SERVER = "ManagementServer";
     private static HotSpotDiagnosticMXBean mbean;
 
     public static void main(String[] args) throws Exception {
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/java/awt/Frame/DisposeStressTest/DisposeStressTest.html	Thu Nov 13 09:39:22 2014 -0800
@@ -0,0 +1,21 @@
+<html>
+<!--  
+  @test
+  @bug 4051487 4145670
+  @summary Tests that disposing of an empty Frame or a Frame with a MenuBar
+           while it is being created does not crash the VM.
+  @author dpm area=Threads
+  @run applet/timeout=7200 DisposeStressTest.html
+  -->
+<head>
+<title>DisposeStressTest</title>
+</head>
+<body>
+
+<h1>DisposeStressTest<br>Bug ID: 4051487, 4145670</h1>
+
+<p> This is an AUTOMATIC test, simply wait for completion </p>
+
+<APPLET CODE="DisposeStressTest.class" WIDTH=200 HEIGHT=200></APPLET>
+</body>
+</html>
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/java/awt/Frame/DisposeStressTest/DisposeStressTest.java	Thu Nov 13 09:39:22 2014 -0800
@@ -0,0 +1,247 @@
+/*
+ * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+
+/*
+  test
+  @bug 4051487 4145670 8062021
+  @summary Tests that disposing of an empty Frame or a Frame with a MenuBar
+           while it is being created does not crash the VM.
+  @author dpm area=Threads
+  @run applet/timeout=7200 DisposeStressTest.html
+*/
+
+// Note there is no @ in front of test above.  This is so that the
+//  harness will not mistake this file as a test file.  It should
+//  only see the html file as a test file. (the harness runs all
+//  valid test files, so it would run this test twice if this file
+//  were valid as well as the html file.)
+// Also, note the area= after Your Name in the author tag.  Here, you
+//  should put which functional area the test falls in.  See the
+//  AWT-core home page -> test areas and/or -> AWT team  for a list of
+//  areas.
+// Note also the 'DisposeStressTest.html' in the run tag.  This should
+//  be changed to the name of the test.
+
+
+/**
+ * DisposeStressTest.java
+ *
+ * summary:
+ */
+
+import java.applet.Applet;
+import java.awt.*;
+
+
+//Automated tests should run as applet tests if possible because they
+// get their environments cleaned up, including AWT threads, any
+// test created threads, and any system resources used by the test
+// such as file descriptors.  (This is normally not a problem as
+// main tests usually run in a separate VM, however on some platforms
+// such as the Mac, separate VMs are not possible and non-applet
+// tests will cause problems).  Also, you don't have to worry about
+// synchronisation stuff in Applet tests they way you do in main
+// tests...
+
+
+public class DisposeStressTest extends Applet
+ {
+   //Declare things used in the test, like buttons and labels here
+
+   public void init()
+    {
+      //Create instructions for the user here, as well as set up
+      // the environment -- set the layout manager, add buttons,
+      // etc.
+
+      this.setLayout (new BorderLayout ());
+
+      String[] instructions =
+       {
+         "This is an AUTOMATIC test",
+         "simply wait until it is done"
+       };
+      Sysout.createDialog( );
+      Sysout.printInstructions( instructions );
+
+    }//End  init()
+
+   public void start ()
+    {
+        for (int i = 0; i < 1000; i++) {
+            Frame f = new Frame();
+            f.setBounds(10, 10, 10, 10);
+            f.show();
+            f.dispose();
+
+            Frame f2 = new Frame();
+            f2.setBounds(10, 10, 100, 100);
+            MenuBar bar = new MenuBar();
+            Menu menu = new Menu();
+            menu.add(new MenuItem("foo"));
+            bar.add(menu);
+            f2.setMenuBar(bar);
+            f2.show();
+            f2.dispose();
+        }
+    }// start()
+
+ }// class DisposeStressTest
+
+
+/****************************************************
+ Standard Test Machinery
+ DO NOT modify anything below -- it's a standard
+  chunk of code whose purpose is to make user
+  interaction uniform, and thereby make it simpler
+  to read and understand someone else's test.
+ ****************************************************/
+
+/**
+ This is part of the standard test machinery.
+ It creates a dialog (with the instructions), and is the interface
+  for sending text messages to the user.
+ To print the instructions, send an array of strings to Sysout.createDialog
+  WithInstructions method.  Put one line of instructions per array entry.
+ To display a message for the tester to see, simply call Sysout.println
+  with the string to be displayed.
+ This mimics System.out.println but works within the test harness as well
+  as standalone.
+ */
+
+class Sysout
+ {
+   private static TestDialog dialog;
+
+   public static void createDialogWithInstructions( String[] instructions )
+    {
+      dialog = new TestDialog( new Frame(), "Instructions" );
+      dialog.printInstructions( instructions );
+      dialog.show();
+      println( "Any messages for the tester will display here." );
+    }
+
+   public static void createDialog( )
+    {
+      dialog = new TestDialog( new Frame(), "Instructions" );
+      String[] defInstr = { "Instructions will appear here. ", "" } ;
+      dialog.printInstructions( defInstr );
+      dialog.show();
+      println( "Any messages for the tester will display here." );
+    }
+
+
+   public static void printInstructions( String[] instructions )
+    {
+      dialog.printInstructions( instructions );
+    }
+
+
+   public static void println( String messageIn )
+    {
+      dialog.displayMessage( messageIn );
+    }
+
+ }// Sysout  class
+
+/**
+  This is part of the standard test machinery.  It provides a place for the
+   test instructions to be displayed, and a place for interactive messages
+   to the user to be displayed.
+  To have the test instructions displayed, see Sysout.
+  To have a message to the user be displayed, see Sysout.
+  Do not call anything in this dialog directly.
+  */
+class TestDialog extends Dialog
+ {
+
+   TextArea instructionsText;
+   TextArea messageText;
+   int maxStringLength = 80;
+
+   //DO NOT call this directly, go through Sysout
+   public TestDialog( Frame frame, String name )
+    {
+      super( frame, name );
+      int scrollBoth = TextArea.SCROLLBARS_BOTH;
+      instructionsText = new TextArea( "", 15, maxStringLength, scrollBoth );
+      add( "North", instructionsText );
+
+      messageText = new TextArea( "", 5, maxStringLength, scrollBoth );
+      add("South", messageText);
+
+      pack();
+
+      show();
+    }// TestDialog()
+
+   //DO NOT call this directly, go through Sysout
+   public void printInstructions( String[] instructions )
+    {
+      //Clear out any current instructions
+      instructionsText.setText( "" );
+
+      //Go down array of instruction strings
+
+      String printStr, remainingStr;
+      for( int i=0; i < instructions.length; i++ )
+       {
+         //chop up each into pieces maxSringLength long
+         remainingStr = instructions[ i ];
+         while( remainingStr.length() > 0 )
+          {
+            //if longer than max then chop off first max chars to print
+            if( remainingStr.length() >= maxStringLength )
+             {
+               //Try to chop on a word boundary
+               int posOfSpace = remainingStr.
+                  lastIndexOf( ' ', maxStringLength - 1 );
+
+               if( posOfSpace <= 0 ) posOfSpace = maxStringLength - 1;
+
+               printStr = remainingStr.substring( 0, posOfSpace + 1 );
+               remainingStr = remainingStr.substring( posOfSpace + 1 );
+             }
+            //else just print
+            else
+             {
+               printStr = remainingStr;
+               remainingStr = "";
+             }
+
+            instructionsText.append( printStr + "\n" );
+
+          }// while
+
+       }// for
+
+    }//printInstructions()
+
+   //DO NOT call this directly, go through Sysout
+   public void displayMessage( String messageIn )
+    {
+      messageText.append( messageIn + "\n" );
+    }
+
+ }// TestDialog  class
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/java/awt/TrayIcon/SecurityCheck/NoPermissionTest/tray.policy	Thu Nov 13 09:39:22 2014 -0800
@@ -0,0 +1,3 @@
+//NoPermission Test
+grant{
+};
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/java/awt/geom/AffineTransform/GetTypeOptimization.java	Thu Nov 13 09:39:22 2014 -0800
@@ -0,0 +1,307 @@
+/*
+ * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/**
+ * @test
+ * @bug 4418285
+ * @summary Tests that transforms modified with degenerate operations
+ *          continue to return their more optimal type from getType().
+ *          This test also confirms that isIdentity() returns the
+ *          optimal value under all histories of modification.
+ * @run main GetTypeOptimization
+ */
+
+import java.awt.geom.AffineTransform;
+import java.util.Random;
+
+public class GetTypeOptimization {
+    static int TYPE_IDENTITY          = AffineTransform.TYPE_IDENTITY;
+    static int TYPE_TRANSLATION       = AffineTransform.TYPE_TRANSLATION;
+    static int TYPE_UNIFORM_SCALE     = AffineTransform.TYPE_UNIFORM_SCALE;
+    static int TYPE_GENERAL_SCALE     = AffineTransform.TYPE_GENERAL_SCALE;
+    static int TYPE_FLIP              = AffineTransform.TYPE_FLIP;
+    static int TYPE_QUADRANT_ROTATION = AffineTransform.TYPE_QUADRANT_ROTATION;
+    static int TYPE_GENERAL_ROTATION  = AffineTransform.TYPE_GENERAL_ROTATION;
+    static int TYPE_GENERAL_TRANSFORM = AffineTransform.TYPE_GENERAL_TRANSFORM;
+
+    public static Random rand = new Random();
+
+    public static boolean verbose;
+    public static int numerrors;
+
+    public static void main(String argv[]) {
+        verbose = (argv.length != 0);
+
+        checkBug4418285();
+
+        checkAtType(new AffineTransform());
+        checkAtType(AffineTransform.getTranslateInstance(0, 0));
+        checkAtType(AffineTransform.getScaleInstance(1, 1));
+        checkAtType(AffineTransform.getShearInstance(0, 0));
+        checkAtType(AffineTransform.getRotateInstance(0));
+        checkAtType(AffineTransform.getRotateInstance(0, 0, 0));
+        for (int i = 90; i <= 360; i += 90) {
+            double angle = Math.toRadians(i);
+            checkAtType(AffineTransform.getRotateInstance(angle));
+            checkAtType(AffineTransform.getRotateInstance(angle, 0, 0));
+        }
+
+        AffineTransform at = new AffineTransform();
+        checkAtType(at);
+
+        at.setToIdentity(); checkAtType(at);
+        at.setToTranslation(0.0, 0.0); checkAtType(at);
+        at.setToScale(1.0, 1.0); checkAtType(at);
+        at.setToShear(0.0, 0.0); checkAtType(at);
+        at.setToRotation(0); checkAtType(at);
+        at.setToRotation(0, 0, 0); checkAtType(at);
+        for (int i = 90; i <= 360; i += 90) {
+            double angle = Math.toRadians(i);
+            at.setToRotation(angle); checkAtType(at);
+            at.setToRotation(angle, 0, 0); checkAtType(at);
+        }
+
+        at.setToIdentity(); at.scale(1, 1); checkAtType(at);
+        at.setToIdentity(); at.translate(0, 0); checkAtType(at);
+        at.setToIdentity(); at.shear(0, 0); checkAtType(at);
+        at.setToIdentity(); at.rotate(0); checkAtType(at);
+        for (int i = 90; i <= 360; i += 90) {
+            double angle = Math.toRadians(i);
+            at.setToIdentity(); at.rotate(angle); checkAtType(at);
+            at.setToIdentity(); at.rotate(angle, 0, 0); checkAtType(at);
+        }
+
+        at.setToIdentity();
+        for (int i = 0; i < 4; i++) {
+            at.rotate(Math.toRadians(90)); checkAtType(at);
+        }
+
+        at.setToIdentity();
+        at.scale(2, 2); checkAtType(at);
+        at.scale(.5, .5); checkAtType(at);
+
+        for (int n = 1; n <= 3; n++) {
+            for (int i = 0; i < 500; i++) {
+                checkAtType(makeRandomTransform(n));
+            }
+        }
+        if (numerrors != 0) {
+            if (!verbose) {
+                System.err.println("Rerun test with an argument for details");
+            }
+            throw new RuntimeException(numerrors+" tests failed!");
+        }
+    }
+
+    public static void checkBug4418285() {
+        AffineTransform id =
+            new AffineTransform ();
+        AffineTransform translate0 =
+            AffineTransform.getTranslateInstance (0, 0);
+        if (id.isIdentity() != translate0.isIdentity() ||
+            id.getType() != translate0.getType())
+        {
+            numerrors++;
+            if (verbose) {
+                System.err.println("id=        " + id         +
+                                   ", isIdentity()=" +
+                                   id.isIdentity());
+                System.err.println("translate0=" + translate0 +
+                                   ", isIdentity()=" +
+                                   translate0.isIdentity());
+                System.err.println("equals="     + id.equals (translate0));
+                System.err.println();
+            }
+        }
+    }
+
+    public static AffineTransform makeRandomTransform(int numops) {
+        AffineTransform at = new AffineTransform();
+        while (--numops >= 0) {
+            switch (rand.nextInt(4)) {
+            case 0:
+                at.scale(rand.nextDouble() * 5 - 2.5,
+                         rand.nextDouble() * 5 - 2.5);
+                break;
+            case 1:
+                at.shear(rand.nextDouble() * 5 - 2.5,
+                         rand.nextDouble() * 5 - 2.5);
+                break;
+            case 2:
+                at.rotate(rand.nextDouble() * Math.PI * 2);
+                break;
+            case 3:
+                at.translate(rand.nextDouble() * 50 - 25,
+                             rand.nextDouble() * 50 - 25);
+                break;
+            default:
+                throw new InternalError("bad case!");
+            }
+        }
+        return at;
+    }
+
+    public static void checkAtType(AffineTransform at) {
+        int reftype = getRefType(at);
+        boolean isident = isIdentity(at);
+        for (int i = 0; i < 5; i++) {
+            boolean atisident = at.isIdentity();
+            int attype = at.getType();
+            if (isident != atisident || reftype != attype) {
+                numerrors++;
+                if (verbose) {
+                    System.err.println(at+".isIdentity() == "+atisident);
+                    System.err.println(at+".getType() == "+attype);
+                    System.err.println("should be "+isident+", "+reftype);
+                    new Throwable().printStackTrace();
+                    System.err.println();
+                }
+                break;
+            }
+        }
+    }
+
+    public static boolean isIdentity(AffineTransform at) {
+        return (at.getScaleX() == 1 &&
+                at.getScaleY() == 1 &&
+                at.getShearX() == 0 &&
+                at.getShearY() == 0 &&
+                at.getTranslateX() == 0 &&
+                at.getTranslateY() == 0);
+
+    }
+
+    public static int getRefType(AffineTransform at) {
+        double m00 = at.getScaleX();
+        double m11 = at.getScaleY();
+        double m01 = at.getShearX();
+        double m10 = at.getShearY();
+        if (m00 * m01 + m10 * m11 != 0) {
+            // Transformed unit vectors are not perpendicular...
+            return TYPE_GENERAL_TRANSFORM;
+        }
+        int type = ((at.getTranslateX() != 0 || at.getTranslateY() != 0)
+                    ? TYPE_TRANSLATION : TYPE_IDENTITY);
+        boolean sgn0, sgn1;
+        if (m01 == 0 && m10 == 0) {
+            sgn0 = (m00 >= 0.0);
+            sgn1 = (m11 >= 0.0);
+            if (sgn0 == sgn1) {
+                if (sgn0) {
+                    // Both scaling factors non-negative - simple scale
+                    if (m00 != m11) {
+                        type |= TYPE_GENERAL_SCALE;
+                    } else if (m00 != 1.0) {
+                        type |= TYPE_UNIFORM_SCALE;
+                    }
+                } else {
+                    // Both scaling factors negative - 180 degree rotation
+                    type |= TYPE_QUADRANT_ROTATION;
+                    if (m00 != m11) {
+                        type |= TYPE_GENERAL_SCALE;
+                    } else if (m00 != -1.0) {
+                        type |= TYPE_UNIFORM_SCALE;
+                    }
+                }
+            } else {
+                // Scaling factor signs different - flip about some axis
+                type |= TYPE_FLIP;
+                if (m00 != -m11) {
+                    type |= TYPE_GENERAL_SCALE;
+                } else if (m00 != 1.0 && m00 != -1.0) {
+                    type |= TYPE_UNIFORM_SCALE;
+                }
+            }
+        } else if (m00 == 0 && m11 == 0) {
+            sgn0 = (m01 >= 0.0);
+            sgn1 = (m10 >= 0.0);
+            if (sgn0 != sgn1) {
+                // Different signs - simple 90 degree rotation
+                if (m01 != -m10) {
+                    type |= (TYPE_QUADRANT_ROTATION | TYPE_GENERAL_SCALE);
+                } else if (m01 != 1.0 && m01 != -1.0) {
+                    type |= (TYPE_QUADRANT_ROTATION | TYPE_UNIFORM_SCALE);
+                } else {
+                    type |= TYPE_QUADRANT_ROTATION;
+                }
+            } else {
+                // Same signs - 90 degree rotation plus an axis flip too
+                if (m01 == m10) {
+                    if (m01 == 0) {
+                        // All four m[01][01] elements are 0
+                        type |= TYPE_UNIFORM_SCALE;
+                    } else {
+                        // Note - shouldn't (1,1) be no scale at all?
+                        type |= (TYPE_QUADRANT_ROTATION |
+                                 TYPE_FLIP |
+                                 TYPE_UNIFORM_SCALE);
+                    }
+                } else {
+                    type |= (TYPE_QUADRANT_ROTATION |
+                             TYPE_FLIP |
+                             TYPE_GENERAL_SCALE);
+                }
+            }
+        } else {
+            if (m00 * m11 >= 0.0) {
+                // sgn(m00) == sgn(m11) therefore sgn(m01) == -sgn(m10)
+                // This is the "unflipped" (right-handed) state
+                if (m00 != m11 || m01 != -m10) {
+                    type |= (TYPE_GENERAL_ROTATION | TYPE_GENERAL_SCALE);
+                } else if (m00 == 0) {
+                    // then m11 == 0 also
+                    if (m01 == -m10) {
+                        type |= (TYPE_QUADRANT_ROTATION | TYPE_UNIFORM_SCALE);
+                    } else {
+                        type |= (TYPE_QUADRANT_ROTATION | TYPE_GENERAL_SCALE);
+                    }
+                } else if (m00 * m11 - m01 * m10 != 1.0) {
+                    type |= (TYPE_GENERAL_ROTATION | TYPE_UNIFORM_SCALE);
+                } else {
+                    type |= TYPE_GENERAL_ROTATION;
+                }
+            } else {
+                // sgn(m00) == -sgn(m11) therefore sgn(m01) == sgn(m10)
+                // This is the "flipped" (left-handed) state
+                if (m00 != -m11 || m01 != m10) {
+                    type |= (TYPE_GENERAL_ROTATION |
+                             TYPE_FLIP |
+                             TYPE_GENERAL_SCALE);
+                } else if (m01 == 0) {
+                    if (m00 == 1.0 || m00 == -1.0) {
+                        type |= TYPE_FLIP;
+                    } else {
+                        type |= (TYPE_FLIP | TYPE_UNIFORM_SCALE);
+                    }
+                } else if (m00 * m11 - m01 * m10 != 1.0) {
+                    type |= (TYPE_GENERAL_ROTATION |
+                             TYPE_FLIP |
+                             TYPE_UNIFORM_SCALE);
+                } else {
+                    type |= (TYPE_GENERAL_ROTATION | TYPE_FLIP);
+                }
+            }
+        }
+        return type;
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/java/awt/geom/AffineTransform/TestInvertMethods.java	Thu Nov 13 09:39:22 2014 -0800
@@ -0,0 +1,483 @@
+/*
+ * Copyright (c) 2005, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/**
+ * @test
+ * @bug 4987374
+ * @summary Unit test for inversion methods:
+ *
+ *          AffineTransform.createInverse();
+ *          AffineTransform.invert();
+ *
+ * @author flar
+ * @run main TestInvertMethods
+ */
+
+import java.awt.geom.AffineTransform;
+import java.awt.geom.NoninvertibleTransformException;
+
+/*
+ * Instances of the inner class Tester are "nodes" which take an input
+ * AffineTransform (AT), modify it in some way and pass the modified
+ * AT onto another Tester node.
+ *
+ * There is one particular Tester node of note called theVerifier.
+ * This is a leaf node which takes the input AT and tests the various
+ * inversion methods on that matrix.
+ *
+ * Most of the other Tester nodes will perform a single affine operation
+ * on their input, such as a rotate by various angles, or a scale by
+ * various predefined scale  values, and then pass the modified AT on
+ * to the next node in the chain which may be a verifier or another
+ * modifier.
+ *
+ * The Tester instances can also be chained together using the chain
+ * method so that we can test not only matrices modified by some single
+ * affine operation (scale, rotate, etc.) but also composite matrices
+ * that represent multiple operations concatenated together.
+ */
+public class TestInvertMethods {
+    public static boolean verbose;
+
+    public static final double MAX_ULPS = 2.0;
+    public static double MAX_TX_ULPS = MAX_ULPS;
+    public static double maxulps = 0.0;
+    public static double maxtxulps = 0.0;
+    public static int numtests = 0;
+
+    public static void main(String argv[]) {
+        Tester rotate = new Tester.Rotate();
+        Tester scale = new Tester.Scale();
+        Tester shear = new Tester.Shear();
+        Tester translate = new Tester.Translate();
+
+        if (argv.length > 1) {
+            // This next line verifies that chaining works correctly...
+            scale.chain(translate.chain(new Tester.Debug())).test(false);
+            return;
+        }
+
+        verbose = (argv.length > 0);
+
+        new Tester.Identity().test(true);
+        translate.test(true);
+        scale.test(true);
+        rotate.test(true);
+        shear.test(true);
+        scale.chain(translate).test(true);
+        rotate.chain(translate).test(true);
+        shear.chain(translate).test(true);
+        translate.chain(scale).test(true);
+        translate.chain(rotate).test(true);
+        translate.chain(shear).test(true);
+        translate.chain(scale.chain(rotate.chain(shear))).test(false);
+        shear.chain(rotate.chain(scale.chain(translate))).test(false);
+
+        System.out.println(numtests+" tests performed");
+        System.out.println("Max scale and shear difference: "+maxulps+" ulps");
+        System.out.println("Max translate difference: "+maxtxulps+" ulps");
+    }
+
+    public abstract static class Tester {
+        public static AffineTransform IdentityTx = new AffineTransform();
+
+        /*
+         * This is the leaf node that performs inversion testing
+         * on the incoming AffineTransform.
+         */
+        public static final Tester theVerifier = new Tester() {
+            public void test(AffineTransform at, boolean full) {
+                numtests++;
+                AffineTransform inv1, inv2;
+                boolean isinvertible =
+                    (Math.abs(at.getDeterminant()) >= Double.MIN_VALUE);
+                try {
+                    inv1 = at.createInverse();
+                    if (!isinvertible) missingNTE("createInverse", at);
+                } catch (NoninvertibleTransformException e) {
+                    inv1 = null;
+                    if (isinvertible) extraNTE("createInverse", at);
+                }
+                inv2 = new AffineTransform(at);
+                try {
+                    inv2.invert();
+                    if (!isinvertible) missingNTE("invert", at);
+                } catch (NoninvertibleTransformException e) {
+                    if (isinvertible) extraNTE("invert", at);
+                }
+                if (verbose) System.out.println("at = "+at);
+                if (isinvertible) {
+                    if (verbose) System.out.println(" inv1 = "+inv1);
+                    if (verbose) System.out.println(" inv2 = "+inv2);
+                    if (!inv1.equals(inv2)) {
+                        report(at, inv1, inv2,
+                               "invert methods do not agree");
+                    }
+                    inv1.concatenate(at);
+                    inv2.concatenate(at);
+                    // "Fix" some values that don't always behave
+                    // well with all the math that we've done up
+                    // to this point.
+                    // See the note on the concatfix method below.
+                    concatfix(inv1);
+                    concatfix(inv2);
+                    if (verbose) System.out.println("  at*inv1 = "+inv1);
+                    if (verbose) System.out.println("  at*inv2 = "+inv2);
+                    if (!compare(inv1, IdentityTx)) {
+                        report(at, inv1, IdentityTx,
+                               "createInverse() check failed");
+                    }
+                    if (!compare(inv2, IdentityTx)) {
+                        report(at, inv2, IdentityTx,
+                               "invert() check failed");
+                    }
+                } else {
+                    if (verbose) System.out.println(" is not invertible");
+                }
+                if (verbose) System.out.println();
+            }
+
+            void missingNTE(String methodname, AffineTransform at) {
+                throw new RuntimeException("Noninvertible was not "+
+                                           "thrown from "+methodname+
+                                           " for: "+at);
+            }
+
+            void extraNTE(String methodname, AffineTransform at) {
+                throw new RuntimeException("Unexpected Noninvertible "+
+                                           "thrown from "+methodname+
+                                           " for: "+at);
+            }
+        };
+
+        /*
+         * The inversion math may work out fairly exactly, but when
+         * we concatenate the inversions back with the original matrix
+         * in an attempt to restore them to the identity matrix,
+         * then we can end up compounding errors to a fairly high
+         * level, particularly if the component values had mantissas
+         * that were repeating fractions.  This function therefore
+         * "fixes" the results of concatenating the inversions back
+         * with their original matrices to get rid of small variations
+         * in the values that should have ended up being 0.0.
+         */
+        public void concatfix(AffineTransform at) {
+            double m00 = at.getScaleX();
+            double m10 = at.getShearY();
+            double m01 = at.getShearX();
+            double m11 = at.getScaleY();
+            double m02 = at.getTranslateX();
+            double m12 = at.getTranslateY();
+            if (Math.abs(m02) < 1E-10) m02 = 0.0;
+            if (Math.abs(m12) < 1E-10) m12 = 0.0;
+            if (Math.abs(m01) < 1E-15) m01 = 0.0;
+            if (Math.abs(m10) < 1E-15) m10 = 0.0;
+            at.setTransform(m00, m10,
+                            m01, m11,
+                            m02, m12);
+        }
+
+        public void test(boolean full) {
+            test(IdentityTx, full);
+        }
+
+        public void test(AffineTransform init, boolean full) {
+            test(init, theVerifier, full);
+        }
+
+        public void test(AffineTransform init, Tester next, boolean full) {
+            next.test(init, full);
+        }
+
+        public Tester chain(Tester next) {
+            return new Chain(this, next);
+        }
+
+        /*
+         * Utility node used to chain together two other nodes for
+         * implementing the "chain" method.
+         */
+        public static class Chain extends Tester {
+            Tester prev;
+            Tester next;
+
+            public Chain(Tester prev, Tester next) {
+                this.prev = prev;
+                this.next = next;
+            }
+
+            public void test(AffineTransform init, boolean full) {
+                prev.test(init, next, full);
+            }
+
+            public Tester chain(Tester next) {
+                this.next = this.next.chain(next);
+                return this;
+            }
+        }
+
+        /*
+         * Utility node for testing.
+         */
+        public static class Fail extends Tester {
+            public void test(AffineTransform init, Tester next, boolean full) {
+                throw new RuntimeException("Debug: Forcing failure");
+            }
+        }
+
+        /*
+         * Utility node for testing that chaining works.
+         */
+        public static class Debug extends Tester {
+            public void test(AffineTransform init, Tester next, boolean full) {
+                new Throwable().printStackTrace();
+                next.test(init, full);
+            }
+        }
+
+        /*
+         * NOP node.
+         */
+        public static class Identity extends Tester {
+            public void test(AffineTransform init, Tester next, boolean full) {
+                if (verbose) System.out.println("*Identity = "+init);
+                next.test(init, full);
+            }
+        }
+
+        /*
+         * Affine rotation node.
+         */
+        public static class Rotate extends Tester {
+            public void test(AffineTransform init, Tester next, boolean full) {
+                int inc = full ? 10 : 45;
+                for (int i = -720; i <= 720; i += inc) {
+                    AffineTransform at2 = new AffineTransform(init);
+                    at2.rotate(Math.toRadians(i));
+                    if (verbose) System.out.println("*Rotate("+i+") = "+at2);
+                    next.test(at2, full);
+                }
+            }
+        }
+
+        public static final double SMALL_VALUE = .0001;
+        public static final double LARGE_VALUE = 10000;
+
+        /*
+         * Affine scale node.
+         */
+        public static class Scale extends Tester {
+            public double fullvals[] = {
+                // Noninvertibles
+                0.0, 0.0,
+                0.0, 1.0,
+                1.0, 0.0,
+
+                // Invertibles
+                SMALL_VALUE, SMALL_VALUE,
+                SMALL_VALUE, 1.0,
+                1.0, SMALL_VALUE,
+
+                SMALL_VALUE, LARGE_VALUE,
+                LARGE_VALUE, SMALL_VALUE,
+
+                LARGE_VALUE, LARGE_VALUE,
+                LARGE_VALUE, 1.0,
+                1.0, LARGE_VALUE,
+
+                0.5, 0.5,
+                1.0, 1.0,
+                2.0, 2.0,
+                Math.PI, Math.E,
+            };
+            public double abbrevvals[] = {
+                0.0, 0.0,
+                1.0, 1.0,
+                2.0, 3.0,
+            };
+
+            public void test(AffineTransform init, Tester next, boolean full) {
+                double scales[] = (full ? fullvals : abbrevvals);
+                for (int i = 0; i < scales.length; i += 2) {
+                    AffineTransform at2 = new AffineTransform(init);
+                    at2.scale(scales[i], scales[i+1]);
+                    if (verbose) System.out.println("*Scale("+scales[i]+", "+
+                                                    scales[i+1]+") = "+at2);
+                    next.test(at2, full);
+                }
+            }
+        }
+
+        /*
+         * Affine shear node.
+         */
+        public static class Shear extends Tester {
+            public double fullvals[] = {
+                0.0, 0.0,
+                0.0, 1.0,
+                1.0, 0.0,
+
+                // Noninvertible
+                1.0, 1.0,
+
+                SMALL_VALUE, SMALL_VALUE,
+                SMALL_VALUE, LARGE_VALUE,
+                LARGE_VALUE, SMALL_VALUE,
+                LARGE_VALUE, LARGE_VALUE,
+
+                Math.PI, Math.E,
+            };
+            public double abbrevvals[] = {
+                0.0, 0.0,
+                0.0, 1.0,
+                1.0, 0.0,
+
+                // Noninvertible
+                1.0, 1.0,
+            };
+
+            public void test(AffineTransform init, Tester next, boolean full) {
+                double shears[] = (full ? fullvals : abbrevvals);
+                for (int i = 0; i < shears.length; i += 2) {
+                    AffineTransform at2 = new AffineTransform(init);
+                    at2.shear(shears[i], shears[i+1]);
+                    if (verbose) System.out.println("*Shear("+shears[i]+", "+
+                                                    shears[i+1]+") = "+at2);
+                    next.test(at2, full);
+                }
+            }
+        }
+
+        /*
+         * Affine translate node.
+         */
+        public static class Translate extends Tester {
+            public double fullvals[] = {
+                0.0, 0.0,
+                0.0, 1.0,
+                1.0, 0.0,
+
+                SMALL_VALUE, SMALL_VALUE,
+                SMALL_VALUE, LARGE_VALUE,
+                LARGE_VALUE, SMALL_VALUE,
+                LARGE_VALUE, LARGE_VALUE,
+
+                Math.PI, Math.E,
+            };
+            public double abbrevvals[] = {
+                0.0, 0.0,
+                0.0, 1.0,
+                1.0, 0.0,
+                Math.PI, Math.E,
+            };
+
+            public void test(AffineTransform init, Tester next, boolean full) {
+                double translates[] = (full ? fullvals : abbrevvals);
+                for (int i = 0; i < translates.length; i += 2) {
+                    AffineTransform at2 = new AffineTransform(init);
+                    at2.translate(translates[i], translates[i+1]);
+                    if (verbose) System.out.println("*Translate("+
+                                                    translates[i]+", "+
+                                                    translates[i+1]+") = "+at2);
+                    next.test(at2, full);
+                }
+            }
+        }
+    }
+
+    public static void report(AffineTransform orig,
+                              AffineTransform at1, AffineTransform at2,
+                              String message)
+    {
+        System.out.println(orig+", type = "+orig.getType());
+        System.out.println(at1+", type = "+at1.getType());
+        System.out.println(at2+", type = "+at2.getType());
+        System.out.println("ScaleX values differ by "+
+                           ulps(at1.getScaleX(),
+                                at2.getScaleX())+" ulps");
+        System.out.println("ScaleY values differ by "+
+                           ulps(at1.getScaleY(),
+                                at2.getScaleY())+" ulps");
+        System.out.println("ShearX values differ by "+
+                           ulps(at1.getShearX(),
+                                at2.getShearX())+" ulps");
+        System.out.println("ShearY values differ by "+
+                           ulps(at1.getShearY(),
+                                at2.getShearY())+" ulps");
+        System.out.println("TranslateX values differ by "+
+                           ulps(at1.getTranslateX(),
+                                at2.getTranslateX())+" ulps");
+        System.out.println("TranslateY values differ by "+
+                           ulps(at1.getTranslateY(),
+                                at2.getTranslateY())+" ulps");
+        throw new RuntimeException(message);
+    }
+
+    public static boolean compare(AffineTransform at1, AffineTransform at2) {
+        maxulps = Math.max(maxulps, ulps(at1.getScaleX(), at2.getScaleX()));
+        maxulps = Math.max(maxulps, ulps(at1.getScaleY(), at2.getScaleY()));
+        maxulps = Math.max(maxulps, ulps(at1.getShearX(), at2.getShearX()));
+        maxulps = Math.max(maxulps, ulps(at1.getShearY(), at2.getShearY()));
+        maxtxulps = Math.max(maxtxulps,
+                             ulps(at1.getTranslateX(), at2.getTranslateX()));
+        maxtxulps = Math.max(maxtxulps,
+                             ulps(at1.getTranslateY(), at2.getTranslateY()));
+        return (getModifiedType(at1) == getModifiedType(at2) &&
+                (compare(at1.getScaleX(), at2.getScaleX(), MAX_ULPS)) &&
+                (compare(at1.getScaleY(), at2.getScaleY(), MAX_ULPS)) &&
+                (compare(at1.getShearX(), at2.getShearX(), MAX_ULPS)) &&
+                (compare(at1.getShearY(), at2.getShearY(), MAX_ULPS)) &&
+                (compare(at1.getTranslateX(),
+                         at2.getTranslateX(), MAX_TX_ULPS)) &&
+                (compare(at1.getTranslateY(),
+                         at2.getTranslateY(), MAX_TX_ULPS)));
+    }
+
+    public static final int ANY_SCALE_MASK =
+        (AffineTransform.TYPE_UNIFORM_SCALE |
+         AffineTransform.TYPE_GENERAL_SCALE);
+    public static int getModifiedType(AffineTransform at) {
+        int type = at.getType();
+        // Some of the vector methods can introduce a tiny uniform scale
+        // at some angles...
+        if ((type & ANY_SCALE_MASK) != 0) {
+            maxulps = Math.max(maxulps, ulps(at.getDeterminant(), 1.0));
+            if (ulps(at.getDeterminant(), 1.0) <= MAX_ULPS) {
+                // Really tiny - we will ignore it
+                type &= ~ ANY_SCALE_MASK;
+            }
+        }
+        return type;
+    }
+
+    public static boolean compare(double val1, double val2, double maxulps) {
+        if (Math.abs(val1 - val2) < 1E-15) return true;
+        return (ulps(val1, val2) <= maxulps);
+    }
+
+    public static double ulps(double val1, double val2) {
+        double diff = Math.abs(val1 - val2);
+        double ulpmax = Math.min(Math.ulp(val1), Math.ulp(val2));
+        return (diff / ulpmax);
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/java/awt/geom/AffineTransform/TestRotateMethods.java	Thu Nov 13 09:39:22 2014 -0800
@@ -0,0 +1,352 @@
+/*
+ * Copyright (c) 2004, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/**
+ * @test
+ * @bug 4980035
+ * @summary Unit test for new methods:
+ *
+ *          AffineTransform.getRotateInstance(double x, double y);
+ *          AffineTransform.setToRotation(double x, double y);
+ *          AffineTransform.rotate(double x, double y);
+ *
+ *          AffineTransform.getQuadrantRotateInstance(int numquads);
+ *          AffineTransform.setToQuadrantRotation(int numquads);
+ *          AffineTransform.quadrantRotate(int numquads);
+ *
+ * @author flar
+ * @run main TestRotateMethods
+ */
+
+import java.awt.geom.AffineTransform;
+import java.awt.geom.Point2D;
+
+public class TestRotateMethods {
+    /* The maximum errors allowed, measured in double precision "ulps"
+     * Note that for most fields, the tests are extremely accurate - to
+     * within 3 ulps of the smaller value in the comparison
+     * For the translation components, the tests are still very accurate,
+     * but the absolute number of ulps can be noticeably higher when we
+     * use one of the rotate methods that takes an anchor point.
+     * Since a double precision value has 56 bits of precision, even
+     * 1024 ulps is extremely small as a ratio of the value.
+     */
+    public static final double MAX_ULPS = 3.0;
+    public static final double MAX_ANCHOR_TX_ULPS = 1024.0;
+    public static double MAX_TX_ULPS = MAX_ULPS;
+
+    // Vectors for quadrant rotations
+    public static final double quadxvec[] = {  1.0,  0.0, -1.0,  0.0 };
+    public static final double quadyvec[] = {  0.0,  1.0,  0.0, -1.0 };
+
+    // Run tests once for each type of method:
+    //     tx = AffineTransform.get<Rotate>Instance()
+    //     tx.set<Rotate>()
+    //     tx.<rotate>()
+    public static enum Mode { GET, SET, MOD };
+
+    // Used to accumulate and report largest differences encountered by tests
+    public static double maxulps = 0.0;
+    public static double maxtxulps = 0.0;
+
+    // Sample anchor points for testing.
+    public static Point2D zeropt = new Point2D.Double(0, 0);
+    public static Point2D testtxpts[] = {
+        new Point2D.Double(       5,      5),
+        new Point2D.Double(      20,    -10),
+        new Point2D.Double(-Math.PI, Math.E),
+    };
+
+    public static void main(String argv[]) {
+        test(Mode.GET);
+        test(Mode.SET);
+        test(Mode.MOD);
+
+        System.out.println("Max scale and shear difference: "+maxulps+" ulps");
+        System.out.println("Max translate difference: "+maxtxulps+" ulps");
+    }
+
+    public static void test(Mode mode) {
+        MAX_TX_ULPS = MAX_ULPS; // Stricter tx testing with no anchor point
+        test(mode, 0.5, null);
+        test(mode, 1.0, null);
+        test(mode, 3.0, null);
+
+        // Anchor points make the tx values less reliable
+        MAX_TX_ULPS = MAX_ANCHOR_TX_ULPS;
+        for (int i = 0; i < testtxpts.length; i++) {
+            test(mode, 1.0, testtxpts[i]);
+        }
+        MAX_TX_ULPS = MAX_ULPS; // Restore to default
+    }
+
+    public static void verify(AffineTransform at1, AffineTransform at2,
+                              Mode mode, double vectorscale, Point2D txpt,
+                              String message, double num, String units)
+    {
+        if (!compare(at1, at2)) {
+            System.out.println("mode == "+mode);
+            System.out.println("vectorscale == "+vectorscale);
+            System.out.println("txpt == "+txpt);
+            System.out.println(at1+", type = "+at1.getType());
+            System.out.println(at2+", type = "+at2.getType());
+            System.out.println("ScaleX values differ by "+
+                               ulps(at1.getScaleX(), at2.getScaleX())+" ulps");
+            System.out.println("ScaleY values differ by "+
+                               ulps(at1.getScaleY(), at2.getScaleY())+" ulps");
+            System.out.println("ShearX values differ by "+
+                               ulps(at1.getShearX(), at2.getShearX())+" ulps");
+            System.out.println("ShearY values differ by "+
+                               ulps(at1.getShearY(), at2.getShearY())+" ulps");
+            System.out.println("TranslateX values differ by "+
+                               ulps(at1.getTranslateX(),
+                                    at2.getTranslateX())+" ulps");
+            System.out.println("TranslateY values differ by "+
+                               ulps(at1.getTranslateY(),
+                                    at2.getTranslateY())+" ulps");
+            throw new RuntimeException(message + num + units);
+        }
+    }
+
+    public static void test(Mode mode, double vectorscale, Point2D txpt) {
+        AffineTransform at1, at2, at3;
+
+        for (int deg = -720; deg <= 720; deg++) {
+            if ((deg % 90) == 0) continue;
+            double radians = Math.toRadians(deg);
+            double vecy = Math.sin(radians) * vectorscale;
+            double vecx = Math.cos(radians) * vectorscale;
+
+            at1 = makeAT(mode, txpt, radians);
+            at2 = makeAT(mode, txpt, vecx, vecy);
+            verify(at1, at2, mode, vectorscale, txpt,
+                   "vector and radians do not match for ", deg, " degrees");
+
+            if (txpt == null) {
+                // Make sure output was same as a with a 0,0 anchor point
+                if (vectorscale == 1.0) {
+                    // Only need to test radians method for one scale factor
+                    at3 = makeAT(mode, zeropt, radians);
+                    verify(at1, at3, mode, vectorscale, zeropt,
+                           "radians not invariant with 0,0 translate at ",
+                           deg, " degrees");
+                }
+                // But test vector methods with all scale factors
+                at3 = makeAT(mode, zeropt, vecx, vecy);
+                verify(at2, at3, mode, vectorscale, zeropt,
+                       "vector not invariant with 0,0 translate at ",
+                       deg, " degrees");
+            }
+        }
+
+        for (int quad = -8; quad <= 8; quad++) {
+            double degrees = quad * 90.0;
+            double radians = Math.toRadians(degrees);
+            double vecx = quadxvec[quad & 3] * vectorscale;
+            double vecy = quadyvec[quad & 3] * vectorscale;
+
+            at1 = makeAT(mode, txpt, radians);
+            at2 = makeAT(mode, txpt, vecx, vecy);
+            verify(at1, at2, mode, vectorscale, txpt,
+                   "quadrant vector and radians do not match for ",
+                   degrees, " degrees");
+            at2 = makeQuadAT(mode, txpt, quad);
+            verify(at1, at2, mode, vectorscale, txpt,
+                   "quadrant and radians do not match for ",
+                   quad, " quadrants");
+            if (txpt == null) {
+                at3 = makeQuadAT(mode, zeropt, quad);
+                verify(at2, at3, mode, vectorscale, zeropt,
+                       "quadrant not invariant with 0,0 translate at ",
+                       quad, " quadrants");
+            }
+        }
+    }
+
+    public static AffineTransform makeRandomAT() {
+        AffineTransform at = new AffineTransform();
+        at.scale(Math.random() * -10.0, Math.random() * 100.0);
+        at.rotate(Math.random() * Math.PI);
+        at.shear(Math.random(), Math.random());
+        at.translate(Math.random() * 300.0, Math.random() * -20.0);
+        return at;
+    }
+
+    public static AffineTransform makeAT(Mode mode, Point2D txpt,
+                                         double radians)
+    {
+        AffineTransform at;
+        double tx = (txpt == null) ? 0.0 : txpt.getX();
+        double ty = (txpt == null) ? 0.0 : txpt.getY();
+        switch (mode) {
+        case GET:
+            if (txpt != null) {
+                at = AffineTransform.getRotateInstance(radians, tx, ty);
+            } else {
+                at = AffineTransform.getRotateInstance(radians);
+            }
+            break;
+        case SET:
+            at = makeRandomAT();
+            if (txpt != null) {
+                at.setToRotation(radians, tx, ty);
+            } else {
+                at.setToRotation(radians);
+            }
+            break;
+        case MOD:
+            at = makeRandomAT();
+            at.setToIdentity();
+            if (txpt != null) {
+                at.rotate(radians, tx, ty);
+            } else {
+                at.rotate(radians);
+            }
+            break;
+        default:
+            throw new InternalError("unrecognized mode: "+mode);
+        }
+
+        return at;
+    }
+
+    public static AffineTransform makeAT(Mode mode, Point2D txpt,
+                                         double vx, double vy)
+    {
+        AffineTransform at;
+        double tx = (txpt == null) ? 0.0 : txpt.getX();
+        double ty = (txpt == null) ? 0.0 : txpt.getY();
+        switch (mode) {
+        case GET:
+            if (txpt != null) {
+                at = AffineTransform.getRotateInstance(vx, vy, tx, ty);
+            } else {
+                at = AffineTransform.getRotateInstance(vx, vy);
+            }
+            break;
+        case SET:
+            at = makeRandomAT();
+            if (txpt != null) {
+                at.setToRotation(vx, vy, tx, ty);
+            } else {
+                at.setToRotation(vx, vy);
+            }
+            break;
+        case MOD:
+            at = makeRandomAT();
+            at.setToIdentity();
+            if (txpt != null) {
+                at.rotate(vx, vy, tx, ty);
+            } else {
+                at.rotate(vx, vy);
+            }
+            break;
+        default:
+            throw new InternalError("unrecognized mode: "+mode);
+        }
+
+        return at;
+    }
+
+    public static AffineTransform makeQuadAT(Mode mode, Point2D txpt,
+                                             int quads)
+    {
+        AffineTransform at;
+        double tx = (txpt == null) ? 0.0 : txpt.getX();
+        double ty = (txpt == null) ? 0.0 : txpt.getY();
+        switch (mode) {
+        case GET:
+            if (txpt != null) {
+                at = AffineTransform.getQuadrantRotateInstance(quads, tx, ty);
+            } else {
+                at = AffineTransform.getQuadrantRotateInstance(quads);
+            }
+            break;
+        case SET:
+            at = makeRandomAT();
+            if (txpt != null) {
+                at.setToQuadrantRotation(quads, tx, ty);
+            } else {
+                at.setToQuadrantRotation(quads);
+            }
+            break;
+        case MOD:
+            at = makeRandomAT();
+            at.setToIdentity();
+            if (txpt != null) {
+                at.quadrantRotate(quads, tx, ty);
+            } else {
+                at.quadrantRotate(quads);
+            }
+            break;
+        default:
+            throw new InternalError("unrecognized mode: "+mode);
+        }
+
+        return at;
+    }
+
+    public static boolean compare(AffineTransform at1, AffineTransform at2) {
+        maxulps = Math.max(maxulps, ulps(at1.getScaleX(), at2.getScaleX()));
+        maxulps = Math.max(maxulps, ulps(at1.getScaleY(), at2.getScaleY()));
+        maxulps = Math.max(maxulps, ulps(at1.getShearX(), at2.getShearX()));
+        maxulps = Math.max(maxulps, ulps(at1.getShearY(), at2.getShearY()));
+        maxtxulps = Math.max(maxtxulps,
+                             ulps(at1.getTranslateX(), at2.getTranslateX()));
+        maxtxulps = Math.max(maxtxulps,
+                             ulps(at1.getTranslateY(), at2.getTranslateY()));
+        return (getModifiedType(at1) == getModifiedType(at2) &&
+                (compare(at1.getScaleX(), at2.getScaleX(), MAX_ULPS)) &&
+                (compare(at1.getScaleY(), at2.getScaleY(), MAX_ULPS)) &&
+                (compare(at1.getShearX(), at2.getShearX(), MAX_ULPS)) &&
+                (compare(at1.getShearY(), at2.getShearY(), MAX_ULPS)) &&
+                (compare(at1.getTranslateX(),
+                         at2.getTranslateX(), MAX_TX_ULPS)) &&
+                (compare(at1.getTranslateY(),
+                         at2.getTranslateY(), MAX_TX_ULPS)));
+    }
+
+    public static int getModifiedType(AffineTransform at) {
+        int type = at.getType();
+        // Some of the vector methods can introduce a tiny uniform scale
+        // at some angles...
+        if ((type & AffineTransform.TYPE_UNIFORM_SCALE) != 0) {
+            maxulps = Math.max(maxulps, ulps(at.getDeterminant(), 1.0));
+            if (ulps(at.getDeterminant(), 1.0) <= MAX_ULPS) {
+                // Really tiny - we will ignore it
+                type &= (~AffineTransform.TYPE_UNIFORM_SCALE);
+            }
+        }
+        return type;
+    }
+
+    public static boolean compare(double val1, double val2, double maxulps) {
+        return (ulps(val1, val2) <= maxulps);
+    }
+
+    public static double ulps(double val1, double val2) {
+        double diff = Math.abs(val1 - val2);
+        double ulpmax = Math.min(Math.ulp(val1), Math.ulp(val2));
+        return (diff / ulpmax);
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/java/awt/geom/AffineTransform/TestSerialization.java	Thu Nov 13 09:39:22 2014 -0800
@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) 2005, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/**
+ * @test
+ * @bug 6213608
+ * @summary Test that AffineTransform can deserialize appropriate versions.
+ * @author flar
+ * @run main TestSerialization
+ */
+
+import java.io.FileInputStream;
+import java.io.ObjectInputStream;
+import java.io.ByteArrayInputStream;
+import java.io.FileOutputStream;
+import java.io.ObjectOutputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InvalidClassException;
+import java.awt.geom.AffineTransform;
+
+public class TestSerialization {
+    public static void main(String argv[]) {
+        if (argv.length > 0) {
+            System.out.println("Saving from: "+
+                               System.getProperty("java.version"));
+            writeSer(argv[0]);
+            return;
+        }
+        System.out.println("Testing on: "+System.getProperty("java.version"));
+        testReadWrite();
+        readSer("serial.1.2", true);
+    }
+
+    public static AffineTransform testATs[] = {
+        new AffineTransform(),
+        AffineTransform.getScaleInstance(2.5, -3.0),
+        AffineTransform.getRotateInstance(Math.PI / 4.0),
+        AffineTransform.getShearInstance(1.0, -3.0),
+        AffineTransform.getTranslateInstance(25.0, 12.5),
+        makeComplexAT(),
+    };
+
+    public static AffineTransform makeComplexAT() {
+        AffineTransform at = new AffineTransform();
+        at.scale(2.5, -3.0);
+        at.rotate(Math.PI / 4.0);
+        at.shear(1.0, -3.0);
+        at.translate(25.0, 12.5);
+        return at;
+    };
+
+    public static void testReadWrite() {
+        try {
+            ByteArrayOutputStream baos = new ByteArrayOutputStream();
+            ObjectOutputStream oos = new ObjectOutputStream(baos);
+            testWrite(oos);
+            oos.flush();
+            oos.close();
+            byte buf[] = baos.toByteArray();
+            ByteArrayInputStream bais = new ByteArrayInputStream(buf);
+            ObjectInputStream ois = new ObjectInputStream(bais);
+            testRead(ois, true);
+        } catch (InvalidClassException ice) {
+            throw new RuntimeException("Object read failed from loopback");
+        } catch (IOException e) {
+            e.printStackTrace();
+            throw new RuntimeException("IOException testing loopback");
+        }
+    }
+
+    public static String resolve(String relfilename) {
+        String dir = System.getProperty("test.src");
+        if (dir == null) {
+            return relfilename;
+        } else {
+            return dir+"/"+relfilename;
+        }
+    }
+
+    public static void readSer(String filename, boolean shouldsucceed) {
+        try {
+            FileInputStream fis = new FileInputStream(resolve(filename));
+            ObjectInputStream ois = new ObjectInputStream(fis);
+            testRead(ois, shouldsucceed);
+        } catch (InvalidClassException ice) {
+            throw new RuntimeException("Object read failed from: "+filename);
+        } catch (IOException e) {
+            e.printStackTrace();
+            throw new RuntimeException("IOException reading: "+filename);
+        }
+    }
+
+    public static void testRead(ObjectInputStream ois, boolean shouldsucceed)
+        throws IOException
+    {
+        for (int i = 0; i < testATs.length; i++) {
+            AffineTransform at;
+            try {
+                at = (AffineTransform) ois.readObject();
+                if (!shouldsucceed) {
+                    throw new RuntimeException("readObj did not fail");
+                }
+            } catch (ClassNotFoundException e) {
+                // Should never happen, but must catch declared exceptions...
+                throw new RuntimeException("AffineTransform not found!");
+            } catch (InvalidClassException e) {
+                if (shouldsucceed) {
+                    throw e;
+                }
+                continue;
+            }
+            if (!testATs[i].equals(at)) {
+                throw new RuntimeException("wrong AT read from stream");
+            }
+        }
+    }
+
+    public static void writeSer(String filename) {
+        try {
+            FileOutputStream fos = new FileOutputStream(filename);
+            ObjectOutputStream oos = new ObjectOutputStream(fos);
+            testWrite(oos);
+            oos.flush();
+            oos.close();
+        } catch (IOException e) {
+            e.printStackTrace();
+            throw new RuntimeException("IOException writing: "+filename);
+        }
+    }
+
+    public static void testWrite(ObjectOutputStream oos)
+        throws IOException
+    {
+        for (int i = 0; i < testATs.length; i++) {
+            oos.writeObject(testATs[i]);
+        }
+    }
+}
Binary file test/java/awt/geom/AffineTransform/serial.1.2 has changed
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/java/awt/image/DrawImage/DrawImageCoordsTest.java	Thu Nov 13 09:39:22 2014 -0800
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 8028539
+ * @summary Test that drawing a scaled image terminates.
+ * @run main/othervm/timeout=60 DrawImageCoordsTest
+*/
+
+import java.awt.Color;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.geom.AffineTransform;
+import java.awt.image.BufferedImage;
+
+public class DrawImageCoordsTest {
+
+    public static void main(String[] args) {
+
+        /* Create an image to draw, filled in solid red. */
+        BufferedImage srcImg =
+             new BufferedImage(200, 200, BufferedImage.TYPE_INT_RGB);
+        Graphics srcG = srcImg.createGraphics();
+        srcG.setColor(Color.red);
+        int w = srcImg.getWidth(null);
+        int h = srcImg.getHeight(null);
+        srcG.fillRect(0, 0, w, h);
+
+        /* Create a destination image */
+        BufferedImage dstImage =
+           new BufferedImage(200, 200, BufferedImage.TYPE_INT_RGB);
+        Graphics2D dstG = dstImage.createGraphics();
+        /* draw image under a scaling transform that overflows int */
+        AffineTransform tx = new AffineTransform(0.5, 0, 0, 0.5,
+                                                  0, 5.8658460197478485E9);
+        dstG.setTransform(tx);
+        dstG.drawImage(srcImg, 0, 0, null );
+        /* draw image under the same overflowing transform, cancelling
+         * out the 0.5 scale on the graphics
+         */
+        dstG.drawImage(srcImg, 0, 0, 2*w, 2*h, null);
+        if (Color.red.getRGB() == dstImage.getRGB(w/2, h/2)) {
+             throw new RuntimeException("Unexpected color: clipping failed.");
+        }
+        System.out.println("Test Thread Completed");
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/java/awt/image/DrawImage/IncorrectAlphaConversionBicubic.java	Thu Nov 13 09:39:22 2014 -0800
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+import java.awt.AlphaComposite;
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.awt.GraphicsConfiguration;
+import java.awt.GraphicsDevice;
+import java.awt.GraphicsEnvironment;
+import java.awt.RenderingHints;
+import java.awt.image.BufferedImage;
+import java.awt.image.DataBuffer;
+import java.awt.image.DataBufferByte;
+import java.awt.image.DataBufferInt;
+import java.awt.image.DataBufferShort;
+import java.awt.image.VolatileImage;
+
+import static java.awt.Transparency.TRANSLUCENT;
+
+/**
+ * @test
+ * @bug 8062164
+ * @summary We should get correct alpha, when we draw to/from VolatileImage and
+ *          bicubic interpolation is enabled
+ * @author Sergey Bylokhov
+ */
+public final class IncorrectAlphaConversionBicubic {
+
+    private static final Color RGB = new Color(200, 255, 7, 123);
+    private static final int SIZE = 100;
+
+    public static void main(final String[] args) {
+        final GraphicsEnvironment ge =
+                GraphicsEnvironment.getLocalGraphicsEnvironment();
+        final GraphicsDevice gd = ge.getDefaultScreenDevice();
+        final GraphicsConfiguration gc = gd.getDefaultConfiguration();
+        final VolatileImage vi =
+                gc.createCompatibleVolatileImage(SIZE, SIZE, TRANSLUCENT);
+        final BufferedImage bi = makeUnmanagedBI(gc, TRANSLUCENT);
+        final int expected = bi.getRGB(2, 2);
+
+        int attempt = 0;
+        BufferedImage snapshot;
+        while (true) {
+            if (++attempt > 10) {
+                throw new RuntimeException("Too many attempts: " + attempt);
+            }
+            vi.validate(gc);
+            final Graphics2D g2d = vi.createGraphics();
+            g2d.setComposite(AlphaComposite.Src);
+            g2d.scale(2, 2);
+            g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
+                                 RenderingHints.VALUE_INTERPOLATION_BICUBIC);
+            g2d.drawImage(bi, 0, 0, null);
+            g2d.dispose();
+
+            snapshot = vi.getSnapshot();
+            if (vi.contentsLost()) {
+                continue;
+            }
+            break;
+        }
+        final int actual = snapshot.getRGB(2, 2);
+        if (actual != expected) {
+            System.err.println("Actual: " + Integer.toHexString(actual));
+            System.err.println("Expected: " + Integer.toHexString(expected));
+            throw new RuntimeException("Test failed");
+        }
+    }
+
+    private static BufferedImage makeUnmanagedBI(GraphicsConfiguration gc,
+                                                 int type) {
+        BufferedImage img = gc.createCompatibleImage(SIZE, SIZE, type);
+        Graphics2D g2d = img.createGraphics();
+        g2d.setColor(RGB);
+        g2d.fillRect(0, 0, SIZE, SIZE);
+        g2d.dispose();
+        final DataBuffer db = img.getRaster().getDataBuffer();
+        if (db instanceof DataBufferInt) {
+            ((DataBufferInt) db).getData();
+        } else if (db instanceof DataBufferShort) {
+            ((DataBufferShort) db).getData();
+        } else if (db instanceof DataBufferByte) {
+            ((DataBufferByte) db).getData();
+        } else {
+            try {
+                img.setAccelerationPriority(0.0f);
+            } catch (final Throwable ignored) {
+            }
+        }
+        return img;
+    }
+}
--- a/test/java/awt/image/DrawImage/UnmanagedDrawImagePerformance.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/test/java/awt/image/DrawImage/UnmanagedDrawImagePerformance.java	Thu Nov 13 09:39:22 2014 -0800
@@ -41,7 +41,7 @@
 
 /*
  * @test
- * @bug 8029253
+ * @bug 8029253 8059941
  * @summary Unmanaged images should be drawn fast.
  * @author Sergey Bylokhov
  */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/java/lang/reflect/Generics/ThreadSafety.java	Thu Nov 13 09:39:22 2014 -0800
@@ -0,0 +1,129 @@
+/*
+ * Copyright 2014 Google Inc.  All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/**
+ * @test
+ * @bug 8062771 8016236
+ * @summary Test publication of Class objects via a data race
+ * @run testng ThreadSafety
+ */
+
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.Collections;
+import java.util.concurrent.BrokenBarrierException;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CyclicBarrier;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeoutException;
+import static java.util.concurrent.TimeUnit.SECONDS;
+import static org.testng.Assert.*;
+import org.testng.annotations.Test;
+
+/**
+ * A test resulting from an attempt to repro this failure (in guice):
+ *
+ * java.lang.NullPointerException
+ *   at sun.reflect.generics.visitor.Reifier.visitClassTypeSignature(Reifier.java:125)
+ *   at sun.reflect.generics.tree.ClassTypeSignature.accept(ClassTypeSignature.java:49)
+ *   at sun.reflect.generics.repository.ClassRepository.getSuperclass(ClassRepository.java:84)
+ *   at java.lang.Class.getGenericSuperclass(Class.java:692)
+ *   at com.google.inject.TypeLiteral.getSuperclassTypeParameter(TypeLiteral.java:99)
+ *   at com.google.inject.TypeLiteral.<init>(TypeLiteral.java:79)
+ *
+ * However, as one would expect with thread safety problems in reflection, these
+ * are very hard to reproduce.  This very test has never been observed to fail,
+ * but a similar test has been observed to fail about once in 2000 executions
+ * (about once every 6 CPU-hours), in jdk7 only.  It appears to be fixed in jdk8+ by:
+ *
+ * 8016236: Class.getGenericInterfaces performance improvement.
+ * (by making Class.genericInfo volatile)
+ */
+public class ThreadSafety {
+    public static class EmptyClass {
+        public static class EmptyGenericSuperclass<T> {}
+        public static class EmptyGenericSubclass<T> extends EmptyGenericSuperclass<T> {}
+    }
+
+    /** published via data race */
+    private Class<?> racyClass = Object.class;
+
+    private URL[] urls = ((URLClassLoader) ThreadSafety.class.getClassLoader()).getURLs();
+
+    private Class<?> createNewEmptyGenericSubclassClass() throws Exception {
+        URLClassLoader ucl = new URLClassLoader(urls, null);
+        return Class.forName("ThreadSafety$EmptyClass$EmptyGenericSubclass", true, ucl);
+    }
+
+    @Test
+    public void testRacy_getGenericSuperclass() throws Exception {
+        final int nThreads = 10;
+        final int iterations = 30;
+        final int timeout = 10;
+        final CyclicBarrier newCycle = new CyclicBarrier(nThreads);
+        final Callable<Void> task = new Callable<Void>() {
+            public Void call() throws Exception {
+                for (int i = 0; i < iterations; i++) {
+                    final int threadId;
+                    try {
+                        threadId = newCycle.await(timeout, SECONDS);
+                    } catch (BrokenBarrierException e) {
+                        return null;
+                    }
+                    for (int j = 0; j < iterations; j++) {
+                        // one thread publishes the class object via a data
+                        // race, for the other threads to consume.
+                        if (threadId == 0) {
+                            racyClass = createNewEmptyGenericSubclassClass();
+                        } else {
+                            racyClass.getGenericSuperclass();
+                        }
+                    }
+                }
+                return null;
+            }};
+
+        final ExecutorService pool = Executors.newFixedThreadPool(nThreads);
+        try {
+            for (Future<Void> future :
+                     pool.invokeAll(Collections.nCopies(nThreads, task))) {
+                try {
+                    future.get(iterations * timeout, SECONDS);
+                } catch (ExecutionException e) {
+                    // ignore "collateral damage"
+                    if (!(e.getCause() instanceof BrokenBarrierException)
+                        &&
+                        !(e.getCause() instanceof TimeoutException)) {
+                        throw e;
+                    }
+                }
+            }
+        } finally {
+            pool.shutdownNow();
+            assertTrue(pool.awaitTermination(2 * timeout, SECONDS));
+        }
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/java/lang/reflect/Parameter/InnerClassToString.java	Thu Nov 13 09:39:22 2014 -0800
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 8055063
+ * @summary javac should generate method parameters correctly.
+ * @clean InnerClassToString
+ * @compile -parameters InnerClassToString.java
+ * @run main InnerClassToString
+ * @clean InnerClassToString
+ * @compile InnerClassToString.java
+ * @run main InnerClassToString
+ */
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Parameter;
+import java.util.Set;
+
+// Test copied and expanded from webbug group report.
+public class InnerClassToString {
+    private static final Class<?>[] genericParamClasses = new Class<?>[] {
+        InnerClassToString.class, Set.class
+    };
+
+    private static final Class<?>[] nongenericParamClasses = new Class<?>[] {
+        InnerClassToString.class, String.class
+    };
+
+    private int errors = 0;
+
+    private void test(Constructor<MyEntity> constructor,
+                     Class<?>[] paramClasses) {
+        final Parameter[] params = constructor.getParameters();
+
+        for (int i = 0; i < params.length; i++) {
+            final Parameter parameter = params[i];
+            System.out.println(parameter.toString());
+
+            if (!parameter.getType().equals(paramClasses[i])) {
+                errors++;
+                System.err.println("Expected type " + paramClasses[i] +
+                                   " but got " + parameter.getType());
+            }
+
+            System.out.println(parameter.getParameterizedType());
+            System.out.println(parameter.getAnnotatedType());
+        }
+
+    }
+
+    private void run() throws Exception {
+        final Constructor<MyEntity> genericConstructor =
+            MyEntity.class.getConstructor(InnerClassToString.class, Set.class);
+
+        test(genericConstructor, genericParamClasses);
+
+        final Constructor<MyEntity> nongenericConstructor =
+            MyEntity.class.getConstructor(InnerClassToString.class, String.class);
+
+        test(nongenericConstructor, nongenericParamClasses);
+
+        if (errors != 0)
+            throw new RuntimeException(errors + " errors in test");
+    }
+
+    public static void main(String[] args) throws Exception {
+        new InnerClassToString().run();
+    }
+
+    public class MyEntity {
+        public MyEntity(Set<?> names) {}
+        public MyEntity(String names) {}
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/javax/sql/testng/test/rowset/BaseRowSetTests.java	Thu Nov 13 09:39:22 2014 -0800
@@ -0,0 +1,1318 @@
+/*
+ * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package test.rowset;
+
+import java.io.InputStream;
+import java.io.Reader;
+import java.io.StringBufferInputStream;
+import java.io.StringReader;
+import java.math.BigDecimal;
+import java.sql.Array;
+import java.sql.Blob;
+import java.sql.Clob;
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Date;
+import java.sql.Ref;
+import java.sql.RowId;
+import java.sql.SQLFeatureNotSupportedException;
+import java.sql.Time;
+import java.sql.Timestamp;
+import java.sql.Types;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.util.Calendar;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.sql.rowset.serial.SerialArray;
+import javax.sql.rowset.serial.SerialBlob;
+import javax.sql.rowset.serial.SerialClob;
+import javax.sql.rowset.serial.SerialRef;
+import static org.testng.Assert.*;
+import org.testng.annotations.BeforeMethod;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+import util.BaseTest;
+import util.StubArray;
+import util.StubBaseRowSet;
+import util.StubBlob;
+import util.StubClob;
+import util.StubNClob;
+import util.StubRef;
+import util.StubRowId;
+import util.StubSQLXML;
+import util.TestRowSetListener;
+
+public class BaseRowSetTests extends BaseTest {
+
+    private StubBaseRowSet brs;
+    private StubBaseRowSet brs1;
+    private final String query = "SELECT * FROM SUPERHEROS";
+    private final String url = "jdbc:derby://localhost:1527/myDB";
+    private final String dsName = "jdbc/myDB";
+    private final String user = "Bruce Wayne";
+    private final String password = "The Dark Knight";
+    private final Date aDate = Date.valueOf(LocalDate.now());
+    private final Time aTime = Time.valueOf(LocalTime.now());
+    private final Timestamp ts = Timestamp.valueOf(LocalDateTime.now());
+    private final Calendar cal = Calendar.getInstance();
+    private final byte[] bytes = new byte[10];
+    private RowId aRowid;
+    private Ref aRef;
+    private Blob aBlob;
+    private Clob aClob;
+    private Array aArray;
+    private InputStream is;
+    private Reader rdr;
+    private Map<String, Class<?>> map = new HashMap<>();
+
+    public BaseRowSetTests() {
+        brs1 = new StubBaseRowSet();
+        is = new StringBufferInputStream(query);
+        rdr = new StringReader(query);
+        aRowid = new StubRowId();
+        try {
+            aBlob = new SerialBlob(new StubBlob());
+            aClob = new SerialClob(new StubClob());
+            aRef = new SerialRef(new StubRef("INTEGER", query));
+            aArray = new SerialArray(new StubArray("INTEGER", new Object[1]));
+            map.put("SUPERHERO", Class.forName("util.SuperHero"));
+        } catch (SQLException | ClassNotFoundException ex) {
+            Logger.getLogger(BaseRowSetTests.class.getName()).log(Level.SEVERE, null, ex);
+        }
+    }
+
+    @BeforeMethod
+    @Override
+    public void setUpMethod() throws Exception {
+        brs = new StubBaseRowSet();
+    }
+
+    /*
+     * Validate that getCommand() returns null by default
+     */
+    @Test
+    public void test() {
+        assertTrue(brs.getCommand() == null);
+    }
+
+    /*
+     * Validate that getCommand() returns command specified to setCommand
+     */
+    @Test
+    public void test01() throws Exception {
+        brs.setCommand(query);
+        assertTrue(brs.getCommand().equals(query));
+    }
+
+    /*
+     * Validate that getCurrency() returns the correct default value
+     */
+    @Test
+    public void test02() throws Exception {
+        assertTrue(brs.getConcurrency() == ResultSet.CONCUR_UPDATABLE);
+    }
+
+    /*
+     * Validate that getCurrency() returns the correct value
+     * after a call to setConcurrency())
+     */
+    @Test(dataProvider = "concurTypes")
+    public void test03(int concurType) throws Exception {
+        brs.setConcurrency(concurType);
+        assertTrue(brs.getConcurrency() == concurType);
+    }
+
+    /*
+     * Validate that getCurrency() throws a SQLException for an invalid value
+     */
+    @Test(expectedExceptions = SQLException.class)
+    public void test04() throws Exception {
+        brs.setConcurrency(ResultSet.CLOSE_CURSORS_AT_COMMIT);
+    }
+
+    /*
+     * Validate that getDataSourceName() returns null by default
+     */
+    @Test
+    public void test05() throws Exception {
+        assertTrue(brs.getDataSourceName() == null);
+    }
+
+    /*
+     * Validate that getDataSourceName() returns the value specified
+     * by setDataSourceName() and getUrl() returns null
+     */
+    @Test
+    public void test06() throws Exception {
+        brs.setUrl(url);
+        brs.setDataSourceName(dsName);
+        assertTrue(brs.getDataSourceName().equals(dsName));
+        assertTrue(brs.getUrl() == null);
+    }
+
+    /*
+     * Validate that setDataSourceName() throws a SQLException for an empty
+     * String specified for the data source name
+     */
+    @Test(expectedExceptions = SQLException.class)
+    public void test07() throws Exception {
+        String dsname = "";
+        brs.setDataSourceName(dsname);
+    }
+
+    /*
+     * Validate that getEscapeProcessing() returns false by default
+     */
+    @Test
+    public void test08() throws Exception {
+        assertFalse(brs.getEscapeProcessing());
+    }
+
+    /*
+     * Validate that getEscapeProcessing() returns value set by
+     * setEscapeProcessing()
+     */
+    @Test(dataProvider = "trueFalse")
+    public void test09(boolean val) throws Exception {
+        brs.setEscapeProcessing(val);
+        assertTrue(brs.getEscapeProcessing() == val);
+    }
+
+    /*
+     * Validate that getFetchDirection() returns the correct default value
+     */
+    @Test
+    public void test10() throws Exception {
+        assertTrue(brs.getFetchDirection() == ResultSet.FETCH_FORWARD);
+    }
+
+    /*
+     * Validate that getFetchDirection() returns the value set by
+     * setFetchDirection()
+     */
+    @Test(dataProvider = "fetchDirection")
+    public void test11(int direction) throws Exception {
+        brs.setFetchDirection(direction);
+        assertTrue(brs.getFetchDirection() == direction);
+    }
+
+    /*
+     * Validate that setConcurrency() throws a SQLException for an invalid value
+     */
+    @Test(expectedExceptions = SQLException.class)
+    public void test12() throws Exception {
+        brs.setConcurrency(ResultSet.CLOSE_CURSORS_AT_COMMIT);
+    }
+
+    /*
+     * Validate that setFetchSize() throws a SQLException for an invalid value
+     */
+    @Test(expectedExceptions = SQLException.class)
+    public void test13() throws Exception {
+        brs.setFetchSize(-1);
+    }
+
+    /*
+     * Validate that setFetchSize() throws a SQLException for a
+     * value greater than getMaxRows()
+     */
+    @Test(expectedExceptions = SQLException.class)
+    public void test14() throws Exception {
+        brs.setMaxRows(5);
+        brs.setFetchSize(brs.getMaxRows() + 1);
+    }
+
+    /*
+     * Validate that getFetchSize() returns the correct value after
+     * setFetchSize() has been called
+     */
+    @Test
+    public void test15() throws Exception {
+        int maxRows = 150;
+        brs.setFetchSize(0);
+        assertTrue(brs.getFetchSize() == 0);
+        brs.setFetchSize(100);
+        assertTrue(brs.getFetchSize() == 100);
+        brs.setMaxRows(maxRows);
+        brs.setFetchSize(maxRows);
+        assertTrue(brs.getFetchSize() == maxRows);
+    }
+
+    /*
+     * Validate that setMaxFieldSize() throws a SQLException for an invalid value
+     */
+    @Test(expectedExceptions = SQLException.class)
+    public void test16() throws Exception {
+        brs.setMaxFieldSize(-1);
+    }
+
+    /*
+     * Validate that getMaxFieldSize() returns the value set by
+     * setMaxFieldSize()
+     */
+    @Test
+    public void test17() throws Exception {
+        brs.setMaxFieldSize(0);
+        assertTrue(brs.getMaxFieldSize() == 0);
+        brs.setMaxFieldSize(100);
+        assertTrue(brs.getMaxFieldSize() == 100);
+        brs.setMaxFieldSize(50);
+        assertTrue(brs.getMaxFieldSize() == 50);
+    }
+
+    /*
+     * Validate that isReadOnly() returns value set by
+     * setReadOnly()
+     */
+    @Test(dataProvider = "trueFalse")
+    public void test18(boolean val) throws Exception {
+        brs.setReadOnly(val);
+        assertTrue(brs.isReadOnly() == val);
+    }
+
+    /*
+     * Validate that getTransactionIsolation() returns value set by
+     * setTransactionIsolation()
+     */
+    @Test(dataProvider = "isolationTypes")
+    public void test19(int val) throws Exception {
+        brs.setTransactionIsolation(val);
+        assertTrue(brs.getTransactionIsolation() == val);
+    }
+
+    /*
+     * Validate that getType() returns value set by setType()
+     */
+    @Test(dataProvider = "scrollTypes")
+    public void test20(int val) throws Exception {
+        brs.setType(val);
+        assertTrue(brs.getType() == val);
+    }
+
+    /*
+     * Validate that getEscapeProcessing() returns value set by
+     * setEscapeProcessing()
+     */
+    @Test(dataProvider = "trueFalse")
+    public void test21(boolean val) throws Exception {
+        brs.setShowDeleted(val);
+        assertTrue(brs.getShowDeleted() == val);
+    }
+
+    /*
+     * Validate that getTypeMap() returns same value set by
+     * setTypeMap()
+     */
+    @Test()
+    public void test22() throws Exception {
+        brs.setTypeMap(map);
+        assertTrue(brs.getTypeMap().equals(map));
+    }
+
+    /*
+     * Validate that getUsername() returns same value set by
+     * setUsername()
+     */
+    @Test()
+    public void test23() throws Exception {
+        brs.setUsername(user);
+        assertTrue(brs.getUsername().equals(user));
+    }
+
+    /*
+     * Validate that getPassword() returns same password set by
+     * setPassword()
+     */
+    @Test()
+    public void test24() throws Exception {
+        brs.setPassword(password);
+        assertTrue(brs.getPassword().equals(password));
+    }
+
+    /*
+     * Validate that getQueryTimeout() returns same value set by
+     * setQueryTimeout() and that 0 is a valid timeout value
+     */
+    @Test()
+    public void test25() throws Exception {
+        int timeout = 0;
+        brs.setQueryTimeout(timeout);
+        assertTrue(brs.getQueryTimeout() == timeout);
+    }
+
+    /*
+     * Validate that getQueryTimeout() returns same value set by
+     * setQueryTimeout() and that 0 is a valid timeout value
+     */
+    @Test()
+    public void test26() throws Exception {
+        int timeout = 10000;
+        brs.setQueryTimeout(timeout);
+        assertTrue(brs.getQueryTimeout() == timeout);
+    }
+
+    /*
+     * Validate that setQueryTimeout() throws a SQLException for a timeout
+     * value < 0
+     */
+    @Test(expectedExceptions = SQLException.class)
+    public void test27() throws Exception {
+        brs.setQueryTimeout(-1);
+    }
+
+    /*
+     * Create a RowSetListener and validate that notifyRowSetChanged is called
+     */
+    @Test()
+    public void test28() throws Exception {
+        TestRowSetListener rsl = new TestRowSetListener();
+        brs.addRowSetListener(rsl);
+        brs.notifyRowSetChanged();
+        assertTrue(rsl.isNotified(TestRowSetListener.ROWSET_CHANGED));
+    }
+
+    /*
+     * Create a RowSetListener and validate that notifyRowChanged is called
+     */
+    @Test()
+    public void test29() throws Exception {
+        TestRowSetListener rsl = new TestRowSetListener();
+        brs.addRowSetListener(rsl);
+        brs.notifyRowChanged();
+        assertTrue(rsl.isNotified(TestRowSetListener.ROW_CHANGED));
+    }
+
+    /*
+     * Create a RowSetListener and validate that notifyCursorMoved is called
+     */
+    @Test()
+    public void test30() throws Exception {
+        TestRowSetListener rsl = new TestRowSetListener();
+        brs.addRowSetListener(rsl);
+        brs.notifyCursorMoved();
+        assertTrue(rsl.isNotified(TestRowSetListener.CURSOR_MOVED));
+    }
+
+    /*
+     * Create a RowSetListener and validate that notifyRowSetChanged,
+     * notifyRowChanged() and notifyCursorMoved are called
+     */
+    @Test()
+    public void test31() throws Exception {
+        TestRowSetListener rsl = new TestRowSetListener();
+        brs.addRowSetListener(rsl);
+        brs.notifyRowSetChanged();
+        brs.notifyRowChanged();
+        brs.notifyCursorMoved();
+        assertTrue(rsl.isNotified(
+                TestRowSetListener.CURSOR_MOVED | TestRowSetListener.ROWSET_CHANGED
+                | TestRowSetListener.ROW_CHANGED));
+    }
+
+    /*
+     * Create multiple RowSetListeners and validate that notifyRowSetChanged
+     * is called on all listeners
+     */
+    @Test()
+    public void test32() throws Exception {
+        TestRowSetListener rsl = new TestRowSetListener();
+        TestRowSetListener rsl2 = new TestRowSetListener();
+        brs.addRowSetListener(rsl);
+        brs.addRowSetListener(rsl2);
+        brs.notifyRowSetChanged();
+        assertTrue(rsl.isNotified(TestRowSetListener.ROWSET_CHANGED));
+        assertTrue(rsl2.isNotified(TestRowSetListener.ROWSET_CHANGED));
+    }
+
+    /*
+     * Create multiple RowSetListeners and validate that notifyRowChanged
+     * is called on all listeners
+     */
+    @Test()
+    public void test33() throws Exception {
+        TestRowSetListener rsl = new TestRowSetListener();
+        TestRowSetListener rsl2 = new TestRowSetListener();
+        brs.addRowSetListener(rsl);
+        brs.addRowSetListener(rsl2);
+        brs.notifyRowChanged();
+        assertTrue(rsl.isNotified(TestRowSetListener.ROW_CHANGED));
+        assertTrue(rsl2.isNotified(TestRowSetListener.ROW_CHANGED));
+    }
+
+    /*
+     * Create multiple RowSetListeners and validate that notifyCursorMoved
+     * is called on all listeners
+     */
+    @Test()
+    public void test34() throws Exception {
+        TestRowSetListener rsl = new TestRowSetListener();
+        TestRowSetListener rsl2 = new TestRowSetListener();
+        brs.addRowSetListener(rsl);
+        brs.addRowSetListener(rsl2);
+        brs.notifyCursorMoved();
+        assertTrue(rsl.isNotified(TestRowSetListener.CURSOR_MOVED));
+        assertTrue(rsl2.isNotified(TestRowSetListener.CURSOR_MOVED));
+    }
+
+    /*
+     * Create multiple RowSetListeners and validate that notifyRowSetChanged,
+     * notifyRowChanged() and notifyCursorMoved are called on all listeners
+     */
+    @Test()
+    public void test35() throws Exception {
+        TestRowSetListener rsl = new TestRowSetListener();
+        TestRowSetListener rsl2 = new TestRowSetListener();
+        brs.addRowSetListener(rsl);
+        brs.addRowSetListener(rsl2);
+        brs.notifyRowSetChanged();
+        brs.notifyRowChanged();
+        brs.notifyCursorMoved();
+        assertTrue(rsl.isNotified(
+                TestRowSetListener.CURSOR_MOVED | TestRowSetListener.ROWSET_CHANGED
+                | TestRowSetListener.ROW_CHANGED));
+        assertTrue(rsl2.isNotified(
+                TestRowSetListener.CURSOR_MOVED | TestRowSetListener.ROWSET_CHANGED
+                | TestRowSetListener.ROW_CHANGED));
+    }
+
+    /*
+     * Create a RowSetListener and validate that notifyRowSetChanged is called,
+     * remove the listener, invoke notifyRowSetChanged again and verify the
+     * listner is not called
+     */
+    @Test()
+    public void test36() throws Exception {
+        TestRowSetListener rsl = new TestRowSetListener();
+        brs.addRowSetListener(rsl);
+        brs.notifyRowSetChanged();
+        assertTrue(rsl.isNotified(TestRowSetListener.ROWSET_CHANGED));
+        // Clear the flag indicating the listener has been called
+        rsl.resetFlag();
+        brs.removeRowSetListener(rsl);
+        brs.notifyRowSetChanged();
+        assertFalse(rsl.isNotified(TestRowSetListener.ROWSET_CHANGED));
+    }
+
+    /*
+     * Validate addRowSetListener does not throw an Exception when null is
+     * passed as the parameter
+     */
+    @Test()
+    public void test37() throws Exception {
+        brs.addRowSetListener(null);
+    }
+
+    /*
+     * Validate removeRowSetListener does not throw an Exception when null is
+     * passed as the parameter
+     */
+    @Test()
+    public void test38() throws Exception {
+        brs.removeRowSetListener(null);
+    }
+
+    /*
+     * Set two parameters and then validate clearParameters() will clear them
+     */
+    @Test()
+    public void test39() throws Exception {
+        brs.setInt(1, 1);
+        brs.setString(2, query);
+        assertTrue(brs.getParams().length == 2);
+        brs.clearParameters();
+        assertTrue(brs.getParams().length == 0);
+    }
+
+    /*
+     * Set the base parameters and validate that the value set is
+     * the correct type and value
+     */
+    @Test(dataProvider = "testBaseParameters")
+    public void test40(int pos, Object o) throws Exception {
+        assertTrue(getParam(pos, o).getClass().isInstance(o));
+        assertTrue(o.equals(getParam(pos, o)));
+    }
+
+    /*
+     * Set the complex parameters and validate that the value set is
+     * the correct type
+     */
+    @Test(dataProvider = "testAdvancedParameters")
+    public void test41(int pos, Object o) throws Exception {
+        assertTrue(getParam(pos, o).getClass().isInstance(o));
+    }
+
+    /*
+     * Validate setNull specifying the supported type values
+     */
+    @Test(dataProvider = "jdbcTypes")
+    public void test42(Integer type) throws Exception {
+        brs.setNull(1, type);
+        assertTrue(checkNullParam(1, type, null));
+    }
+
+    /*
+     * Validate setNull specifying the supported type values and that
+     * typeName is set internally
+     */
+    @Test(dataProvider = "jdbcTypes")
+    public void test43(Integer type) throws Exception {
+        brs.setNull(1, type, "SUPERHERO");
+        assertTrue(checkNullParam(1, type, "SUPERHERO"));
+    }
+
+    /*
+     *  Validate that setDate sets the specified Calendar internally
+     */
+    @Test()
+    public void test44() throws Exception {
+        brs.setDate(1, aDate, cal);
+        assertTrue(checkCalendarParam(1, cal));
+    }
+
+    /*
+     *  Validate that setTime sets the specified Calendar internally
+     */
+    @Test()
+    public void test45() throws Exception {
+        brs.setTime(1, aTime, cal);
+        assertTrue(checkCalendarParam(1, cal));
+    }
+
+    /*
+     *  Validate that setTimestamp sets the specified Calendar internally
+     */
+    @Test()
+    public void test46() throws Exception {
+        brs.setTimestamp(1, ts, cal);
+        assertTrue(checkCalendarParam(1, cal));
+    }
+
+    /*
+     * Validate that getURL() returns same value set by
+     * setURL()
+     */
+    @Test()
+    public void test47() throws Exception {
+        brs.setUrl(url);
+        assertTrue(brs.getUrl().equals(url));
+    }
+
+    /*
+     * Validate that initParams() initializes the parameters
+     */
+    @Test()
+    public void test48() throws Exception {
+        brs.setInt(1, 1);
+        brs.initParams();
+        assertTrue(brs.getParams().length == 0);
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test100() throws Exception {
+        brs1.setAsciiStream(1, is);
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test101() throws Exception {
+        brs1.setAsciiStream("one", is);
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test102() throws Exception {
+        brs1.setAsciiStream("one", is, query.length());
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test103() throws Exception {
+        brs1.setBinaryStream(1, is);
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test104() throws Exception {
+        brs1.setBinaryStream("one", is);
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test105() throws Exception {
+        brs1.setBinaryStream("one", is, query.length());
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test106() throws Exception {
+        brs1.setBigDecimal("one", BigDecimal.ONE);
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test107() throws Exception {
+        brs1.setBlob(1, is);
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test108() throws Exception {
+        brs1.setBlob("one", is);
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test109() throws Exception {
+        brs1.setBlob("one", is, query.length());
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test110() throws Exception {
+        brs1.setBlob("one", aBlob);
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test111() throws Exception {
+        brs1.setBoolean("one", true);
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test112() throws Exception {
+        byte b = 1;
+        brs1.setByte("one", b);
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test113() throws Exception {
+        byte b = 1;
+        brs1.setBytes("one", bytes);
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test114() throws Exception {
+        brs1.setCharacterStream("one", rdr, query.length());
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test115() throws Exception {
+        brs1.setCharacterStream("one", rdr);
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test116() throws Exception {
+        brs1.setCharacterStream(1, rdr);
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test117() throws Exception {
+        brs1.setClob(1, rdr);
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test118() throws Exception {
+        brs1.setClob("one", rdr);
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test119() throws Exception {
+        brs1.setClob("one", rdr, query.length());
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test120() throws Exception {
+        brs1.setClob("one", aClob);
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test121() throws Exception {
+        brs1.setDate("one", aDate);
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test122() throws Exception {
+        brs1.setDate("one", aDate, cal);
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test123() throws Exception {
+        brs1.setTime("one", aTime);
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test124() throws Exception {
+        brs1.setTime("one", aTime, cal);
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test125() throws Exception {
+        brs1.setTimestamp("one", ts);
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test126() throws Exception {
+        brs1.setTimestamp("one", ts, cal);
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test127() throws Exception {
+        brs1.setDouble("one", 2.0d);
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test128() throws Exception {
+        brs1.setFloat("one", 2.0f);
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test129() throws Exception {
+        brs1.setInt("one", 21);
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test130() throws Exception {
+        brs1.setLong("one", 21l);
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test131() throws Exception {
+        brs1.setNCharacterStream("one", rdr, query.length());
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test132() throws Exception {
+        brs1.setNCharacterStream("one", rdr);
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test133() throws Exception {
+        brs1.setNCharacterStream(1, rdr);
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test134() throws Exception {
+        brs1.setNCharacterStream(1, rdr, query.length());
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test135() throws Exception {
+        brs1.setClob("one", rdr);
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test136() throws Exception {
+        brs1.setClob("one", rdr, query.length());
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test137() throws Exception {
+        brs1.setNClob("one", new StubNClob());
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test138() throws Exception {
+        brs1.setNClob(1, rdr);
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test139() throws Exception {
+        brs1.setNClob(1, rdr, query.length());
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test140() throws Exception {
+        brs1.setNClob(1, new StubNClob());
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test141() throws Exception {
+        brs1.setNString(1, query);
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test142() throws Exception {
+        brs1.setNull("one", Types.INTEGER);
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test143() throws Exception {
+        brs1.setNull("one", Types.INTEGER, "my.type");
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test144() throws Exception {
+        brs1.setObject("one", query, Types.VARCHAR);
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test145() throws Exception {
+        brs1.setObject("one", query, Types.VARCHAR, 0);
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test146() throws Exception {
+        brs1.setObject("one", query);
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test147() throws Exception {
+        brs1.setRowId("one", aRowid);
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test148() throws Exception {
+        brs1.setSQLXML("one", new StubSQLXML());
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test149() throws Exception {
+        brs1.setSQLXML(1, new StubSQLXML());
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test150() throws Exception {
+        brs1.setNString(1, query);
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test151() throws Exception {
+        brs1.setNString("one", query);
+    }
+
+    /*
+     * This method is currently not implemented in BaseRowSet and will
+     * throw a SQLFeatureNotSupportedException
+     */
+    @Test(expectedExceptions = SQLFeatureNotSupportedException.class)
+    public void test152() throws Exception {
+        short val = 21;
+        brs1.setShort("one", val);
+    }
+
+    /*
+     * DataProvider used to specify the value to set and check for
+     * methods using transaction isolation types
+     */
+    @DataProvider(name = "isolationTypes")
+    private Object[][] isolationTypes() {
+        return new Object[][]{
+            {Connection.TRANSACTION_NONE},
+            {Connection.TRANSACTION_READ_COMMITTED},
+            {Connection.TRANSACTION_READ_UNCOMMITTED},
+            {Connection.TRANSACTION_REPEATABLE_READ},
+            {Connection.TRANSACTION_SERIALIZABLE}
+        };
+    }
+
+    /*
+     * DataProvider used to specify the value to set and check for the
+     * methods for fetch direction
+     */
+    @DataProvider(name = "fetchDirection")
+    private Object[][] fetchDirection() {
+        return new Object[][]{
+            {ResultSet.FETCH_FORWARD},
+            {ResultSet.FETCH_REVERSE},
+            {ResultSet.FETCH_UNKNOWN}
+        };
+    }
+
+    /*
+     * DataProvider used to specify the value to set and check for the
+     * methods for Concurrency
+     */
+    @DataProvider(name = "concurTypes")
+    private Object[][] concurTypes() {
+        return new Object[][]{
+            {ResultSet.CONCUR_READ_ONLY},
+            {ResultSet.CONCUR_UPDATABLE}
+        };
+    }
+
+    /*
+     * DataProvider used to specify the value to set and check for the
+     * methods for Cursor Scroll Type
+     */
+    @DataProvider(name = "scrollTypes")
+    private Object[][] scrollTypes() {
+        return new Object[][]{
+            {ResultSet.TYPE_FORWARD_ONLY},
+            {ResultSet.TYPE_SCROLL_INSENSITIVE},
+            {ResultSet.TYPE_SCROLL_SENSITIVE}
+        };
+    }
+
+    /*
+     * DataProvider used to set parameters for basic types that are supported
+     */
+    @DataProvider(name = "testBaseParameters")
+    private Object[][] testBaseParameters() throws SQLException {
+        Integer aInt = 1;
+        Long aLong = Long.MAX_VALUE;
+        Short aShort = Short.MIN_VALUE;
+        BigDecimal bd = BigDecimal.ONE;
+        Double aDouble = Double.MAX_VALUE;
+        Boolean aBoolean = true;
+        Float aFloat = 1.5f;
+        Byte aByte = 1;
+
+        brs1.clearParameters();
+        brs1.setInt(1, aInt);
+        brs1.setString(2, query);
+        brs1.setLong(3, aLong);
+        brs1.setBoolean(4, aBoolean);
+        brs1.setShort(5, aShort);
+        brs1.setDouble(6, aDouble);
+        brs1.setBigDecimal(7, bd);
+        brs1.setFloat(8, aFloat);
+        brs1.setByte(9, aByte);
+        brs1.setDate(10, aDate);
+        brs1.setTime(11, aTime);
+        brs1.setTimestamp(12, ts);
+        brs1.setDate(13, aDate, cal);
+        brs1.setTime(14, aTime, cal);
+        brs1.setTimestamp(15, ts);
+        brs1.setObject(16, query);
+        brs1.setObject(17, query, Types.CHAR);
+        brs1.setObject(18, query, Types.CHAR, 0);
+
+        return new Object[][]{
+            {1, aInt},
+            {2, query},
+            {3, aLong},
+            {4, aBoolean},
+            {5, aShort},
+            {6, aDouble},
+            {7, bd},
+            {8, aFloat},
+            {9, aByte},
+            {10, aDate},
+            {11, aTime},
+            {12, ts},
+            {13, aDate},
+            {14, aTime},
+            {15, ts},
+            {16, query},
+            {17, query},
+            {18, query}
+
+        };
+    }
+
+    /*
+     * DataProvider used to set advanced parameters for types that are supported
+     */
+    @DataProvider(name = "testAdvancedParameters")
+    private Object[][] testAdvancedParameters() throws SQLException {
+
+        brs1.clearParameters();
+        brs1.setBytes(1, bytes);
+        brs1.setAsciiStream(2, is, query.length());
+        brs1.setRef(3, aRef);
+        brs1.setArray(4, aArray);
+        brs1.setBlob(5, aBlob);
+        brs1.setClob(6, aClob);
+        brs1.setBinaryStream(7, is, query.length());
+        brs1.setUnicodeStream(8, is, query.length());
+        brs1.setCharacterStream(9, rdr, query.length());
+
+        return new Object[][]{
+            {1, bytes},
+            {2, is},
+            {3, aRef},
+            {4, aArray},
+            {5, aBlob},
+            {6, aClob},
+            {7, is},
+            {8, is},
+            {9, rdr}
+        };
+    }
+
+    /*
+     *  Method that returns the specified parameter instance that was set via setXXX
+     *  Note non-basic types are stored as an Object[] where the 1st element
+     *  is the object instnace
+     */
+    @SuppressWarnings("unchecked")
+    private <T> T getParam(int pos, T o) throws SQLException {
+        Object[] params = brs1.getParams();
+        if (params[pos - 1] instanceof Object[]) {
+            Object[] param = (Object[]) params[pos - 1];
+            return (T) param[0];
+        } else {
+            return (T) params[pos - 1];
+        }
+    }
+
+    /*
+     * Utility method to validate parameters when the param is an Object[]
+     */
+    private boolean checkParam(int pos, int type, Object val) throws SQLException {
+        boolean result = false;
+        Object[] params = brs.getParams();
+        if (params[pos - 1] instanceof Object[]) {
+            Object[] param = (Object[]) params[pos - 1];
+
+            if (param[0] == null) {
+                // setNull was used
+                if (param.length == 2 && (Integer) param[1] == type) {
+                    result = true;
+                } else {
+                    if (param.length == 3 && (Integer) param[1] == type
+                            && val.equals(param[2])) {
+                        result = true;
+                    }
+                }
+
+            } else if (param[0] instanceof java.util.Date) {
+                // setDate/Time/Timestamp with a Calendar object
+                if (param[1] instanceof Calendar && val.equals(param[1])) {
+                    result = true;
+                }
+            }
+        }
+        return result;
+    }
+
+    /*
+     * Wrapper method for validating that a null was set and the appropriate
+     * type and typeName if applicable
+     */
+    private boolean checkNullParam(int pos, int type, String typeName) throws SQLException {
+        return checkParam(pos, type, typeName);
+    }
+
+    /*
+     *  Wrapper method for validating that a Calander was set
+     */
+    private boolean checkCalendarParam(int pos, Calendar cal) throws SQLException {
+        // 2nd param is ignored when instanceof java.util.Date
+        return checkParam(pos, Types.DATE, cal);
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/javax/sql/testng/test/rowset/serial/SQLInputImplTests.java	Thu Nov 13 09:39:22 2014 -0800
@@ -0,0 +1,211 @@
+/*
+ * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package test.rowset.serial;
+
+import java.net.URL;
+import java.sql.Array;
+import java.sql.Blob;
+import java.sql.Clob;
+import java.sql.Ref;
+import java.sql.SQLException;
+import java.sql.Struct;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import javax.sql.rowset.serial.SQLInputImpl;
+import static org.testng.Assert.*;
+import org.testng.annotations.BeforeMethod;
+import org.testng.annotations.Test;
+import util.BaseTest;
+import util.StubArray;
+import util.StubBlob;
+import util.StubClob;
+import util.StubRef;
+import util.StubStruct;
+import util.SuperHero;
+import util.TestSQLDataImpl;
+
+public class SQLInputImplTests extends BaseTest {
+
+    // Copy of the array of data type values
+    private Object[] typeValues;
+    private TestSQLDataImpl impl;
+    private Map<String, Class<?>> map ;
+    private SuperHero hero;
+    private final String sqlType = "SUPERHERO";
+
+    @BeforeMethod
+    @Override
+    public void setUpMethod() throws Exception {
+        map = new HashMap<>();
+        impl = new TestSQLDataImpl("TestSQLData");
+        typeValues = Arrays.copyOf(TestSQLDataImpl.attributes,
+                TestSQLDataImpl.attributes.length);
+        hero = new SuperHero(sqlType, "Bruce", "Wayne",
+                1939, "Batman");
+    }
+
+    /*
+     * Validate that a SQLException is thrown if the attribute value is
+     * null
+     */
+    @Test(expectedExceptions = SQLException.class)
+    public void test() throws Exception {
+        SQLInputImpl x = new SQLInputImpl(null, map);
+    }
+
+    /*
+     * Validate that a SQLException is thrown if the map value is
+     * null
+     */
+    @Test(expectedExceptions = SQLException.class)
+    public void test02() throws Exception {
+        SQLInputImpl x = new SQLInputImpl(typeValues, null);
+    }
+
+    /*
+     * Read in the various datatypes via readSQL (which will exercise the
+     * various readXXX methods and validate that results are as expected
+     */
+    @Test()
+    public void test03() throws Exception {
+        impl.readSQL(new SQLInputImpl(typeValues, map), "misc");
+        assertTrue(Arrays.equals(impl.toArray(), typeValues));
+        // Null out a field and make sure the arrays do not match
+        typeValues[2] = null;
+        assertFalse(Arrays.equals(impl.toArray(), typeValues));
+    }
+
+    /*
+     * Validate that wasNull indicates if a null was read in
+     */
+    @Test()
+    public void test04() throws Exception {
+        Object[] values = {"Hello", null, 1};
+        SQLInputImpl sqli = new SQLInputImpl(values, map);
+        String s = sqli.readString();
+        assertFalse(sqli.wasNull());
+        s = sqli.readString();
+        assertTrue(sqli.wasNull());
+        int i = sqli.readInt();
+        assertFalse(sqli.wasNull());
+    }
+
+    /*
+     * Validate that readObject returns the correct value
+     */
+    @Test()
+    public void test05() throws Exception {
+        Object[] values = {hero};
+        SQLInputImpl sqli = new SQLInputImpl(values, map);
+        Object o = sqli.readObject();
+        assertTrue(hero.equals(o));
+
+    }
+
+    /*
+     * Validate a Array can be read
+     */
+    @Test(enabled = true)
+    public void test06() throws Exception {
+        Object[] coffees = new Object[]{"Espresso", "Colombian", "French Roast",
+            "Cappuccino"};
+        Array a = new StubArray("VARCHAR", coffees);
+        Object[] values = {a};
+        SQLInputImpl sqli = new SQLInputImpl(values, map);
+        Array a2 = sqli.readArray();
+        assertTrue(Arrays.equals((Object[]) a2.getArray(), (Object[]) a.getArray()));
+        assertTrue(a.getBaseTypeName().equals(a2.getBaseTypeName()));
+    }
+
+    /*
+     * Validate a Blob can be read
+     */
+    @Test(enabled = true)
+    public void test07() throws Exception {
+        Blob b = new StubBlob();
+        Object[] values = {b};
+        SQLInputImpl sqli = new SQLInputImpl(values, map);
+        Blob b2 = sqli.readBlob();
+        assertTrue(Arrays.equals(
+                b.getBytes(1, (int) b.length()),
+                b2.getBytes(1, (int) b2.length())));
+    }
+
+    /*
+     * Validate a Clob can be read
+     */
+    @Test(enabled = true)
+    public void test08() throws Exception {
+        Clob c = new StubClob();
+        Object[] values = {c};
+        SQLInputImpl sqli = new SQLInputImpl(values, map);
+        Clob c2 = sqli.readClob();
+        assertTrue(c.getSubString(1,
+                (int) c.length()).equals(c2.getSubString(1, (int) c2.length())));
+    }
+
+    /*
+     * Validate a Ref can be read
+     */
+    @Test(enabled = true)
+    public void test09() throws Exception {
+        Ref ref = new StubRef(sqlType, hero);
+        Object[] values = {ref};
+        SQLInputImpl sqli = new SQLInputImpl(values, map);
+        Ref ref2 = sqli.readRef();
+        assertTrue(ref.getObject().equals(ref2.getObject()));
+        assertTrue(ref.getBaseTypeName().equals(ref2.getBaseTypeName()));
+    }
+
+    /*
+     * Validate a URL can be read
+     */
+    @Test(enabled = true)
+    public void test10() throws Exception {
+        URL u = new URL("http://www.oracle.com/");;
+        Object[] values = {u};
+        SQLInputImpl sqli = new SQLInputImpl(values, map);
+        URL u2 = sqli.readURL();
+        assertTrue(u2.equals(u));
+        assertTrue(u2.sameFile(u));
+    }
+
+    /*
+     * Validate that readObject returns the correct value when a Struct is
+     * next on the stream
+     */
+    @Test()
+    public void test11() throws Exception {
+        Object[] attributes = new Object[]{"Bruce", "Wayne", 1939,
+            "Batman"};
+        map.put(sqlType, Class.forName("util.SuperHero"));
+        Struct struct = new StubStruct(sqlType, attributes);
+        Object[] values = {struct};
+        SQLInputImpl sqli = new SQLInputImpl(values, map);
+        Object o = sqli.readObject();
+
+        assertTrue(hero.equals(o));
+
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/javax/sql/testng/test/rowset/serial/SQLOutputImplTests.java	Thu Nov 13 09:39:22 2014 -0800
@@ -0,0 +1,199 @@
+/*
+ * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package test.rowset.serial;
+
+import java.net.URL;
+import java.sql.Array;
+import java.sql.Blob;
+import java.sql.Clob;
+import java.sql.Ref;
+import java.sql.SQLException;
+import java.sql.Struct;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Vector;
+import javax.sql.rowset.serial.SQLInputImpl;
+import javax.sql.rowset.serial.SQLOutputImpl;
+import javax.sql.rowset.serial.SerialArray;
+import javax.sql.rowset.serial.SerialBlob;
+import javax.sql.rowset.serial.SerialClob;
+import javax.sql.rowset.serial.SerialDatalink;
+import javax.sql.rowset.serial.SerialRef;
+import javax.sql.rowset.serial.SerialStruct;
+import static org.testng.Assert.*;
+import org.testng.annotations.BeforeMethod;
+import org.testng.annotations.Test;
+import util.BaseTest;
+import util.StubArray;
+import util.StubBlob;
+import util.StubClob;
+import util.StubRef;
+import util.StubStruct;
+import util.SuperHero;
+import util.TestSQLDataImpl;
+
+public class SQLOutputImplTests extends BaseTest {
+
+    // Copy of the array of data type values
+    private Object[] typeValues;
+    private TestSQLDataImpl impl;
+    private Map<String, Class<?>> map = new HashMap<>();
+    private Vector results;
+    private final String sqlType = "SUPERHERO";
+    private SuperHero hero;
+    private SQLOutputImpl outImpl;
+
+    @BeforeMethod
+    @Override
+    public void setUpMethod() throws Exception {
+        results = new Vector();
+        impl = new TestSQLDataImpl("TestSQLData");
+        typeValues = Arrays.copyOf(TestSQLDataImpl.attributes,
+                TestSQLDataImpl.attributes.length);
+        hero = new SuperHero(sqlType, "Bruce", "Wayne", 1939, "Batman");
+        outImpl = new SQLOutputImpl(results, map);
+    }
+
+    /*
+     * Validate that a SQLException is thrown if the attribute value is
+     * null
+     */
+    @Test(expectedExceptions = SQLException.class)
+    public void test() throws Exception {
+        SQLOutputImpl x = new SQLOutputImpl(null, map);
+    }
+
+    /*
+     * Validate that a SQLException is thrown if the map value is
+     * null
+     */
+    @Test(expectedExceptions = SQLException.class)
+    public void test02() throws Exception {
+        SQLOutputImpl x = new SQLOutputImpl(results, null);
+    }
+
+    /*
+     * Read in the various datatypes via readSQL (which will exercise the
+     * various readXXX methods and validate that results are as expected
+     */
+    @Test()
+    public void test03() throws Exception {
+        impl.readSQL(new SQLInputImpl(typeValues, map), "misc");
+        impl.writeSQL(outImpl);
+        assertTrue(Arrays.equals(results.toArray(), typeValues));
+        // Null out a field and make sure the arrays do not match
+        typeValues[2] = null;
+        assertFalse(Arrays.equals(results.toArray(), typeValues));
+    }
+
+    /*
+     * Validate a Array can be written and returned
+     */
+    @Test(enabled = true)
+    public void test04() throws Exception {
+        Object[] coffees = new Object[]{"Espresso", "Colombian", "French Roast",
+            "Cappuccino"};
+        Array a = new StubArray("VARCHAR", coffees);
+        outImpl.writeArray(a);
+        SerialArray sa = (SerialArray) results.get(0);
+        assertTrue(Arrays.equals(coffees, (Object[]) sa.getArray()));
+        assertTrue(a.getBaseTypeName().equals(sa.getBaseTypeName()));
+    }
+
+    /*
+     * Validate a Blob can be written and returned
+     */
+    @Test(enabled = true)
+    public void test05() throws Exception {
+        Blob b = new StubBlob();
+        outImpl.writeBlob(b);
+        SerialBlob sb = (SerialBlob) results.get(0);
+        assertTrue(Arrays.equals(
+                b.getBytes(1, (int) b.length()),
+                sb.getBytes(1, (int) sb.length())));
+    }
+
+    /*
+     * Validate a Clob can be written and returned
+     */
+    @Test(enabled = true)
+    public void test06() throws Exception {
+        Clob c = new StubClob();
+        outImpl.writeClob(c);
+        SerialClob sc = (SerialClob) results.get(0);
+        assertTrue(c.getSubString(1,
+                (int) c.length()).equals(sc.getSubString(1, (int) sc.length())));
+    }
+
+    /*
+     * Validate a Ref can be written and returned
+     */
+    @Test(enabled = true)
+    public void test07() throws Exception {
+        Ref ref = new StubRef(sqlType, hero);
+        outImpl.writeRef(ref);
+        SerialRef sr = (SerialRef) results.get(0);
+        assertTrue(hero.equals(sr.getObject()));
+    }
+
+    /*
+     * Validate a Struct can be written and returned
+     */
+    @Test(enabled = true)
+    public void test08() throws Exception {
+        Object[] attributes = new Object[]{"Bruce", "Wayne", 1939,
+            "Batman"};
+        Struct s = new StubStruct(sqlType, attributes);
+        outImpl.writeStruct(s);
+        SerialStruct ss = (SerialStruct) results.get(0);
+        assertTrue(Arrays.equals(attributes, (Object[]) ss.getAttributes()));
+        assertTrue(sqlType.equals(ss.getSQLTypeName()));
+    }
+
+    /*
+     * Validate a DataLink can be written and returned
+     */
+    @Test(enabled = true)
+    public void test09() throws Exception {
+        URL u = new URL("http://www.oracle.com/");
+        outImpl.writeURL(u);
+        SerialDatalink sdl = (SerialDatalink) results.get(0);
+        URL u2 = sdl.getDatalink();
+        assertTrue(u2.equals(u));
+        assertTrue(u2.sameFile(u));
+    }
+
+    /*
+     * Validate an Object implementing SQLData can be written and returned
+     */
+    @Test(enabled = true)
+    public void test10() throws Exception {
+        Object[] attributes = new Object[]{"Bruce", "Wayne", 1939,
+            "Batman"};
+        outImpl.writeObject(hero);
+        SerialStruct ss = (SerialStruct) results.get(0);
+        assertTrue(Arrays.equals(attributes, (Object[]) ss.getAttributes()));
+        assertTrue(sqlType.equals(ss.getSQLTypeName()));
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/javax/sql/testng/util/StubBaseRowSet.java	Thu Nov 13 09:39:22 2014 -0800
@@ -0,0 +1,1001 @@
+/*
+ * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package util;
+
+import java.io.InputStream;
+import java.io.Reader;
+import java.math.BigDecimal;
+import java.sql.Array;
+import java.sql.Blob;
+import java.sql.Clob;
+import java.sql.Date;
+import java.sql.NClob;
+import java.sql.Ref;
+import java.sql.ResultSetMetaData;
+import java.sql.RowId;
+import java.sql.SQLException;
+import java.sql.SQLWarning;
+import java.sql.SQLXML;
+import java.sql.Statement;
+import java.sql.Time;
+import java.sql.Timestamp;
+import java.util.Calendar;
+import java.util.Map;
+import javax.sql.RowSet;
+import javax.sql.rowset.BaseRowSet;
+
+public class StubBaseRowSet extends BaseRowSet implements RowSet {
+
+    public StubBaseRowSet() {
+        super();
+        // Must call initParams() as part of initialization
+        super.initParams();
+    }
+
+    public void notifyCursorMoved() throws SQLException {
+        super.notifyCursorMoved();
+    }
+
+    public void notifyRowChanged() throws SQLException {
+        super.notifyRowChanged();
+    }
+
+    public void notifyRowSetChanged() throws SQLException {
+        super.notifyRowSetChanged();
+    }
+
+    public void initParams() {
+        super.initParams();
+    }
+
+    // Methods required by RowSet interace, not used
+    @Override
+    public void execute() throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public boolean next() throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void close() throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public boolean wasNull() throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public String getString(int columnIndex) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public boolean getBoolean(int columnIndex) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public byte getByte(int columnIndex) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public short getShort(int columnIndex) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public int getInt(int columnIndex) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public long getLong(int columnIndex) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public float getFloat(int columnIndex) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public double getDouble(int columnIndex) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public byte[] getBytes(int columnIndex) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public Date getDate(int columnIndex) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public Time getTime(int columnIndex) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public Timestamp getTimestamp(int columnIndex) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public InputStream getAsciiStream(int columnIndex) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public InputStream getUnicodeStream(int columnIndex) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public InputStream getBinaryStream(int columnIndex) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public String getString(String columnLabel) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public boolean getBoolean(String columnLabel) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public byte getByte(String columnLabel) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public short getShort(String columnLabel) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public int getInt(String columnLabel) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public long getLong(String columnLabel) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public float getFloat(String columnLabel) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public double getDouble(String columnLabel) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public BigDecimal getBigDecimal(String columnLabel, int scale) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public byte[] getBytes(String columnLabel) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public Date getDate(String columnLabel) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public Time getTime(String columnLabel) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public Timestamp getTimestamp(String columnLabel) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public InputStream getAsciiStream(String columnLabel) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public InputStream getUnicodeStream(String columnLabel) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public InputStream getBinaryStream(String columnLabel) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public SQLWarning getWarnings() throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void clearWarnings() throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public String getCursorName() throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public ResultSetMetaData getMetaData() throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public Object getObject(int columnIndex) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public Object getObject(String columnLabel) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public int findColumn(String columnLabel) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public Reader getCharacterStream(int columnIndex) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public Reader getCharacterStream(String columnLabel) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public BigDecimal getBigDecimal(int columnIndex) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public BigDecimal getBigDecimal(String columnLabel) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public boolean isBeforeFirst() throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public boolean isAfterLast() throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public boolean isFirst() throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public boolean isLast() throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void beforeFirst() throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void afterLast() throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public boolean first() throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public boolean last() throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public int getRow() throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public boolean absolute(int row) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public boolean relative(int rows) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public boolean previous() throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public boolean rowUpdated() throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public boolean rowInserted() throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public boolean rowDeleted() throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateNull(int columnIndex) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateBoolean(int columnIndex, boolean x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateByte(int columnIndex, byte x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateShort(int columnIndex, short x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateInt(int columnIndex, int x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateLong(int columnIndex, long x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateFloat(int columnIndex, float x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateDouble(int columnIndex, double x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateString(int columnIndex, String x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateBytes(int columnIndex, byte[] x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateDate(int columnIndex, Date x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateTime(int columnIndex, Time x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateTimestamp(int columnIndex, Timestamp x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateAsciiStream(int columnIndex, InputStream x, int length) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateBinaryStream(int columnIndex, InputStream x, int length) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateCharacterStream(int columnIndex, Reader x, int length) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateObject(int columnIndex, Object x, int scaleOrLength) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateObject(int columnIndex, Object x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateNull(String columnLabel) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateBoolean(String columnLabel, boolean x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateByte(String columnLabel, byte x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateShort(String columnLabel, short x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateInt(String columnLabel, int x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateLong(String columnLabel, long x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateFloat(String columnLabel, float x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateDouble(String columnLabel, double x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateBigDecimal(String columnLabel, BigDecimal x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateString(String columnLabel, String x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateBytes(String columnLabel, byte[] x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateDate(String columnLabel, Date x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateTime(String columnLabel, Time x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateTimestamp(String columnLabel, Timestamp x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateAsciiStream(String columnLabel, InputStream x, int length) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateBinaryStream(String columnLabel, InputStream x, int length) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateCharacterStream(String columnLabel, Reader reader, int length) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateObject(String columnLabel, Object x, int scaleOrLength) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateObject(String columnLabel, Object x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void insertRow() throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateRow() throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void deleteRow() throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void refreshRow() throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void cancelRowUpdates() throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void moveToInsertRow() throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void moveToCurrentRow() throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public Statement getStatement() throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public Object getObject(int columnIndex, Map<String, Class<?>> map) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public Ref getRef(int columnIndex) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public Blob getBlob(int columnIndex) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public Clob getClob(int columnIndex) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public Array getArray(int columnIndex) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public Object getObject(String columnLabel, Map<String, Class<?>> map) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public Ref getRef(String columnLabel) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public Blob getBlob(String columnLabel) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public Clob getClob(String columnLabel) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public Array getArray(String columnLabel) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public Date getDate(int columnIndex, Calendar cal) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public Date getDate(String columnLabel, Calendar cal) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public Time getTime(int columnIndex, Calendar cal) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public Time getTime(String columnLabel, Calendar cal) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public Timestamp getTimestamp(int columnIndex, Calendar cal) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public Timestamp getTimestamp(String columnLabel, Calendar cal) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public java.net.URL getURL(int columnIndex) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public java.net.URL getURL(String columnLabel) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateRef(int columnIndex, Ref x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateRef(String columnLabel, Ref x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateBlob(int columnIndex, Blob x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateBlob(String columnLabel, Blob x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateClob(int columnIndex, Clob x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateClob(String columnLabel, Clob x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateArray(int columnIndex, Array x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateArray(String columnLabel, Array x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public RowId getRowId(int columnIndex) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public RowId getRowId(String columnLabel) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateRowId(int columnIndex, RowId x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateRowId(String columnLabel, RowId x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public int getHoldability() throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public boolean isClosed() throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateNString(int columnIndex, String nString) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateNString(String columnLabel, String nString) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateNClob(int columnIndex, NClob nClob) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateNClob(String columnLabel, NClob nClob) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public NClob getNClob(int columnIndex) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public NClob getNClob(String columnLabel) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public SQLXML getSQLXML(int columnIndex) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public SQLXML getSQLXML(String columnLabel) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateSQLXML(int columnIndex, SQLXML xmlObject) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateSQLXML(String columnLabel, SQLXML xmlObject) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public String getNString(int columnIndex) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public String getNString(String columnLabel) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public Reader getNCharacterStream(int columnIndex) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public Reader getNCharacterStream(String columnLabel) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateNCharacterStream(int columnIndex, Reader x, long length) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateNCharacterStream(String columnLabel, Reader reader, long length) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateAsciiStream(int columnIndex, InputStream x, long length) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateBinaryStream(int columnIndex, InputStream x, long length) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateCharacterStream(int columnIndex, Reader x, long length) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateAsciiStream(String columnLabel, InputStream x, long length) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateBinaryStream(String columnLabel, InputStream x, long length) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateCharacterStream(String columnLabel, Reader reader, long length) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateBlob(int columnIndex, InputStream inputStream, long length) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateBlob(String columnLabel, InputStream inputStream, long length) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateClob(int columnIndex, Reader reader, long length) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateClob(String columnLabel, Reader reader, long length) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateNClob(int columnIndex, Reader reader, long length) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateNClob(String columnLabel, Reader reader, long length) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateNCharacterStream(int columnIndex, Reader x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateNCharacterStream(String columnLabel, Reader reader) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateAsciiStream(int columnIndex, InputStream x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateBinaryStream(int columnIndex, InputStream x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateCharacterStream(int columnIndex, Reader x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateAsciiStream(String columnLabel, InputStream x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateBinaryStream(String columnLabel, InputStream x) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateCharacterStream(String columnLabel, Reader reader) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateBlob(int columnIndex, InputStream inputStream) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateBlob(String columnLabel, InputStream inputStream) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateClob(int columnIndex, Reader reader) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateClob(String columnLabel, Reader reader) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateNClob(int columnIndex, Reader reader) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void updateNClob(String columnLabel, Reader reader) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public <T> T getObject(int columnIndex, Class<T> type) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public <T> T getObject(String columnLabel, Class<T> type) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public <T> T unwrap(Class<T> iface) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public boolean isWrapperFor(Class<?> iface) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/javax/sql/testng/util/StubNClob.java	Thu Nov 13 09:39:22 2014 -0800
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package util;
+
+import java.sql.NClob;
+
+public class StubNClob extends StubClob  implements NClob {
+
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/javax/sql/testng/util/StubRowId.java	Thu Nov 13 09:39:22 2014 -0800
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package util;
+
+import java.sql.RowId;
+
+public class StubRowId implements RowId {
+
+    @Override
+    public byte[] getBytes() {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/javax/sql/testng/util/StubSQLXML.java	Thu Nov 13 09:39:22 2014 -0800
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package util;
+
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.Reader;
+import java.io.Writer;
+import java.sql.SQLException;
+import java.sql.SQLXML;
+import javax.xml.transform.Result;
+import javax.xml.transform.Source;
+
+public class StubSQLXML implements SQLXML{
+
+    @Override
+    public void free() throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public InputStream getBinaryStream() throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public OutputStream setBinaryStream() throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public Reader getCharacterStream() throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public Writer setCharacterStream() throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public String getString() throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public void setString(String value) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public <T extends Source> T getSource(Class<T> sourceClass) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    @Override
+    public <T extends Result> T setResult(Class<T> resultClass) throws SQLException {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+}
--- a/test/javax/sql/testng/util/SuperHero.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/test/javax/sql/testng/util/SuperHero.java	Thu Nov 13 09:39:22 2014 -0800
@@ -32,10 +32,14 @@
 
     private String first;
     private String last;
-    private final String type;
+    private String type = "SUPERHERO";
     private Integer firstYear;
     private String secretIdentity;
 
+    public SuperHero() {
+
+    }
+
     public SuperHero(String sqlType, String fname, String lname, Integer year,
             String identity) {
         first = fname;
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/javax/sql/testng/util/TestRowSetListener.java	Thu Nov 13 09:39:22 2014 -0800
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package util;
+
+import javax.sql.RowSetEvent;
+import javax.sql.RowSetListener;
+
+public class TestRowSetListener implements RowSetListener {
+
+    // Flags to indicate which listener events should have been notified
+    public final static int ROWSET_CHANGED = 1;
+    public final static int ROW_CHANGED = 2;
+    public final static int CURSOR_MOVED = 4;
+    private int flag;
+
+    @Override
+    public void rowSetChanged(RowSetEvent event) {
+        flag |= ROWSET_CHANGED;
+    }
+
+    @Override
+    public void rowChanged(RowSetEvent event) {
+        flag |= ROW_CHANGED;
+    }
+
+    @Override
+    public void cursorMoved(RowSetEvent event) {
+        flag |= CURSOR_MOVED;
+    }
+
+    /*
+     * Clear the flag indicating which events we were notified for
+     */
+    public void resetFlag() {
+        flag = 0;
+    }
+
+    /*
+     *  Method used to validate that the correct event was notified
+     */
+    public boolean isNotified( int val) {
+        return flag == val;
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/javax/sql/testng/util/TestSQLDataImpl.java	Thu Nov 13 09:39:22 2014 -0800
@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package util;
+
+import java.math.BigDecimal;
+import java.sql.Date;
+import java.sql.SQLData;
+import java.sql.SQLException;
+import java.sql.SQLInput;
+import java.sql.SQLOutput;
+import java.sql.Time;
+import java.sql.Timestamp;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.util.Arrays;
+
+public class TestSQLDataImpl implements SQLData {
+
+    private final int stringPos = 0;
+    private final int datePos = 1;
+    private final int timePos = 2;
+    private final int timestampPos = 3;
+    private final int intPos = 4;
+    private final int longPos = 5;
+    private final int shortPos = 6;
+    private final int bigDecimalPos = 7;
+    private final int doublePos = 8;
+    private final int booleanPos = 9;
+    private final int floatPos = 10;
+    private final int bytePos = 11;
+    private final int bytesPos = 12;
+    private final int MAX_TYPES = bytesPos + 1;
+    private final Object[] types = new Object[MAX_TYPES];
+
+    private final static byte[] b = {1, 2, 3};
+
+    // attributes entries must line up with the ordering of the reading and
+    // writing of the fields in readSQL and writeSQL
+    public final static Object[] attributes = {"The Dark Knight",
+        Date.valueOf(LocalDate.now()), Time.valueOf(LocalTime.now()),
+        Timestamp.valueOf(LocalDateTime.now()), Integer.MAX_VALUE,
+        Long.MAX_VALUE, Short.MIN_VALUE, BigDecimal.ONE,
+        Double.MAX_VALUE, true, 1.5f, Byte.MAX_VALUE, b};
+
+    private String sqlType;
+
+    public TestSQLDataImpl(String type) {
+        sqlType = type;
+    }
+
+    @Override
+    public String getSQLTypeName() throws SQLException {
+        return sqlType;
+    }
+
+    @Override
+    public void readSQL(SQLInput stream, String typeName) throws SQLException {
+
+        sqlType = typeName;
+        types[stringPos] = stream.readString();
+        types[datePos] = stream.readDate();
+        types[timePos] = stream.readTime();
+        types[timestampPos] = stream.readTimestamp();
+        types[intPos] = stream.readInt();
+        types[longPos] = stream.readLong();
+        types[shortPos] = stream.readShort();
+        types[bigDecimalPos] = stream.readBigDecimal();
+        types[doublePos] = stream.readDouble();
+        types[booleanPos] = stream.readBoolean();
+        types[floatPos] = stream.readFloat();
+        types[bytePos] = stream.readByte();
+        types[bytesPos] = stream.readBytes();
+    }
+
+    @Override
+    public void writeSQL(SQLOutput stream) throws SQLException {
+
+        stream.writeString((String) types[stringPos]);
+        stream.writeDate((Date) types[datePos]);
+        stream.writeTime((Time) types[timePos]);
+        stream.writeTimestamp((Timestamp) types[timestampPos]);
+        stream.writeInt((Integer) types[intPos]);
+        stream.writeLong((Long) types[longPos]);
+        stream.writeShort((Short) types[shortPos]);
+        stream.writeBigDecimal((BigDecimal) types[bigDecimalPos]);
+        stream.writeDouble((Double) types[doublePos]);
+        stream.writeBoolean((Boolean) types[booleanPos]);
+        stream.writeFloat((Float) types[floatPos]);
+        stream.writeByte((Byte) types[bytePos]);
+        stream.writeBytes((byte[]) types[bytesPos]);
+    }
+
+    public Object[] toArray() {
+
+        Object[] result = Arrays.copyOf(types, types.length);
+        return result;
+    }
+
+    @Override
+    public String toString() {
+        return "[" + sqlType + " " + types + "]";
+    }
+
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/javax/swing/JComboBox/8057893/bug8057893.java	Thu Nov 13 09:39:22 2014 -0800
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+import java.awt.EventQueue;
+import java.awt.Robot;
+import java.awt.Toolkit;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.KeyEvent;
+import javax.swing.JComboBox;
+import javax.swing.JFrame;
+import javax.swing.WindowConstants;
+import sun.awt.SunToolkit;
+
+/**
+ * @test
+ * @bug 8057893
+ * @author Alexander Scherbatiy
+ * @summary JComboBox actionListener never receives "comboBoxEdited"
+ *   from getActionCommand
+ * @run main bug8057893
+ */
+public class bug8057893 {
+
+    private static volatile boolean isComboBoxEdited = false;
+
+    public static void main(String[] args) throws Exception {
+        Robot robot = new Robot();
+        robot.setAutoDelay(50);
+        SunToolkit toolkit = (SunToolkit) Toolkit.getDefaultToolkit();
+
+        EventQueue.invokeAndWait(() -> {
+            JFrame frame = new JFrame();
+            frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
+            JComboBox<String> comboBox = new JComboBox<>(new String[]{"one", "two"});
+            comboBox.setEditable(true);
+            comboBox.addActionListener(new ActionListener() {
+
+                @Override
+                public void actionPerformed(ActionEvent e) {
+                    if ("comboBoxEdited".equals(e.getActionCommand())) {
+                        isComboBoxEdited = true;
+                    }
+                }
+            });
+            frame.add(comboBox);
+            frame.pack();
+            frame.setVisible(true);
+            comboBox.requestFocusInWindow();
+        });
+
+        toolkit.realSync();
+
+        robot.keyPress(KeyEvent.VK_A);
+        robot.keyRelease(KeyEvent.VK_A);
+        robot.keyPress(KeyEvent.VK_ENTER);
+        robot.keyRelease(KeyEvent.VK_ENTER);
+        toolkit.realSync();
+
+        if(!isComboBoxEdited){
+            throw new RuntimeException("ComboBoxEdited event is not fired!");
+        }
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/javax/swing/JTable/4222153/bug4222153.html	Thu Nov 13 09:39:22 2014 -0800
@@ -0,0 +1,31 @@
+<!--
+ Copyright (c) 1999, Oracle and/or its affiliates. All rights reserved.
+ DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+
+ This code is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License version 2 only, as
+ published by the Free Software Foundation.
+
+ This code is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ version 2 for more details (a copy is included in the LICENSE file that
+ accompanied this code).
+
+ You should have received a copy of the GNU General Public License version
+ 2 along with this work; if not, write to the Free Software Foundation,
+ Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+
+ Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ or visit www.oracle.com if you need additional information or have any
+ questions.
+-->
+
+<html>
+<body>
+Click in the upper-left cell and then press TAB two times.
+If table cell selection is not on the left cell of the second row
+then test fails.
+<applet  code="bug4222153.class" width=200 height=200></applet>
+</body>
+</html>
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/javax/swing/JTable/4222153/bug4222153.java	Thu Nov 13 09:39:22 2014 -0800
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+import javax.swing.JApplet;
+import javax.swing.JTable;
+import javax.swing.SwingUtilities;
+import javax.swing.UIManager;
+
+/**
+ * @test
+ * @bug 4222153
+ * @author Konstantin Eremin
+ * @run applet/manual=yesno bug4222153.html
+ */
+public class bug4222153 extends JApplet {
+
+    public void init() {
+        SwingUtilities.invokeLater(() -> {
+            try {
+                UIManager.setLookAndFeel(
+                        "javax.swing.plaf.metal.MetalLookAndFeel");
+            } catch (Exception e) {
+                throw new RuntimeException(e);
+            }
+            getContentPane().add(new JTable(2, 2));
+        });
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/javax/swing/JTable/KeyBoardNavigation/KeyBoardNavigation.html	Thu Nov 13 09:39:22 2014 -0800
@@ -0,0 +1,43 @@
+<!--
+ Copyright (c) 1999, Oracle and/or its affiliates. All rights reserved.
+ DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+
+ This code is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License version 2 only, as
+ published by the Free Software Foundation.
+
+ This code is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ version 2 for more details (a copy is included in the LICENSE file that
+ accompanied this code).
+
+ You should have received a copy of the GNU General Public License version
+ 2 along with this work; if not, write to the Free Software Foundation,
+ Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+
+ Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ or visit www.oracle.com if you need additional information or have any
+ questions.
+-->
+
+<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
+<html>
+  <head>
+    <title>Keyboard Navigation in JTable</title>
+  </head>
+
+  <body>
+    <h1>Keyboard Navigation in JTable</h1>
+    <applet code=KeyBoardNavigation width=500 height=200>
+    </applet>
+
+    <p>
+      Refer to bug report 4112270 for spec of keyboard navigation. Check all combinations of navigational keys in all four modes shift and control verifying each change to the selection against the spec.
+       If it does, press "pass", otherwise press "fail".
+    <hr>
+    <address><a href="mailto:milne@taller">Philip Milne</a></address>
+
+  </body>
+</html>
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/javax/swing/JTable/KeyBoardNavigation/KeyBoardNavigation.java	Thu Nov 13 09:39:22 2014 -0800
@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+import java.awt.Color;
+import java.awt.Container;
+import java.awt.Dimension;
+
+import javax.swing.DefaultCellEditor;
+import javax.swing.JApplet;
+import javax.swing.JComboBox;
+import javax.swing.JLabel;
+import javax.swing.JScrollPane;
+import javax.swing.JTable;
+import javax.swing.SwingUtilities;
+import javax.swing.UIManager;
+import javax.swing.border.BevelBorder;
+import javax.swing.table.AbstractTableModel;
+import javax.swing.table.DefaultTableCellRenderer;
+import javax.swing.table.TableCellRenderer;
+import javax.swing.table.TableColumn;
+import javax.swing.table.TableModel;
+
+
+/**
+ * @test
+ * @bug 4112270
+ * @summary
+ *     Keyboard Navigation in JTable
+ * @author milne
+ * @run applet/manual=yesno KeyBoardNavigation.html
+ */
+public class KeyBoardNavigation extends JApplet
+{
+    static void initTest(Container contentPane)
+    {
+        // Take the dummy data from SwingSet.
+        final String[] names = {"First Name", "Last Name", "Favorite Color",
+                "Favorite Number", "Vegetarian"};
+        final Object[][] data = {
+                {"Mark", "Andrews", "Red", new Integer(2), new Boolean(true)},
+                {"Tom", "Ball", "Blue", new Integer(99), new Boolean(false)},
+                {"Alan", "Chung", "Green", new Integer(838), new Boolean(false)},
+                {"Jeff", "Dinkins", "Turquois", new Integer(8), new Boolean(true)},
+                {"Amy", "Fowler", "Yellow", new Integer(3), new Boolean(false)},
+                {"Brian", "Gerhold", "Green", new Integer(0), new Boolean(false)},
+                {"James", "Gosling", "Pink", new Integer(21), new Boolean(false)},
+                {"David", "Karlton", "Red", new Integer(1), new Boolean(false)},
+                {"Dave", "Kloba", "Yellow", new Integer(14), new Boolean(false)},
+                {"Peter", "Korn", "Purple", new Integer(12), new Boolean(false)},
+                {"Phil", "Milne", "Purple", new Integer(3), new Boolean(false)},
+                {"Dave", "Moore", "Green", new Integer(88), new Boolean(false)},
+                {"Hans", "Muller", "Maroon", new Integer(5), new Boolean(false)},
+                {"Rick", "Levenson", "Blue", new Integer(2), new Boolean(false)},
+                {"Tim", "Prinzing", "Blue", new Integer(22), new Boolean(false)},
+                {"Chester", "Rose", "Black", new Integer(0), new Boolean(false)},
+                {"Ray", "Ryan", "Gray", new Integer(77), new Boolean(false)},
+                {"Georges", "Saab", "Red", new Integer(4), new Boolean(false)},
+                {"Willie", "Walker", "Phthalo Blue", new Integer(4), new Boolean(false)},
+                {"Kathy", "Walrath", "Blue", new Integer(8), new Boolean(false)},
+                {"Arnaud", "Weber", "Green", new Integer(44), new Boolean(false)}
+        };
+
+        // Create a model of the data.
+        TableModel dataModel = new AbstractTableModel() {
+            // These methods always need to be implemented.
+            public int getColumnCount() { return names.length; }
+            public int getRowCount() { return data.length;}
+            public Object getValueAt(int row, int col) {return data[row][col];}
+
+            // The default implementations of these methods in
+            // AbstractTableModel would work, but we can refine them.
+            public String getColumnName(int column) {return names[column];}
+            public Class getColumnClass(int c) {return getValueAt(0, c).getClass();}
+            public boolean isCellEditable(int row, int col) {return true;}
+            public void setValueAt(Object aValue, int row, int column) {
+                System.out.println("Setting value to: " + aValue);
+                data[row][column] = aValue;
+            }
+        };
+
+        // Create the table
+        JTable tableView = new JTable(dataModel);
+        // Turn off auto-resizing so that we can set column sizes programmatically.
+        // In this mode, all columns will get their preferred widths, as set blow.
+        tableView.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
+
+        // Create a combo box to show that you can use one in a table.
+        JComboBox comboBox = new JComboBox();
+        comboBox.addItem("Red");
+        comboBox.addItem("Orange");
+        comboBox.addItem("Yellow");
+        comboBox.addItem("Green");
+        comboBox.addItem("Blue");
+        comboBox.addItem("Indigo");
+        comboBox.addItem("Violet");
+
+        TableColumn colorColumn = tableView.getColumn("Favorite Color");
+        // Use the combo box as the editor in the "Favorite Color" column.
+        colorColumn.setCellEditor(new DefaultCellEditor(comboBox));
+
+        // Set a pink background and tooltip for the Color column renderer.
+        DefaultTableCellRenderer colorColumnRenderer = new DefaultTableCellRenderer();
+        colorColumnRenderer.setBackground(Color.pink);
+        colorColumnRenderer.setToolTipText("Click for combo box");
+        colorColumn.setCellRenderer(colorColumnRenderer);
+
+        // Set a tooltip for the header of the colors column.
+        TableCellRenderer headerRenderer = colorColumn.getHeaderRenderer();
+        if (headerRenderer instanceof DefaultTableCellRenderer)
+            ((DefaultTableCellRenderer)headerRenderer).setToolTipText("Hi Mom!");
+
+        // Set the width of the "Vegetarian" column.
+        TableColumn vegetarianColumn = tableView.getColumn("Vegetarian");
+        vegetarianColumn.setPreferredWidth(100);
+
+        // Show the values in the "Favorite Number" column in different colors.
+        TableColumn numbersColumn = tableView.getColumn("Favorite Number");
+        DefaultTableCellRenderer numberColumnRenderer = new DefaultTableCellRenderer() {
+            public void setValue(Object value) {
+                int cellValue = (value instanceof Number) ? ((Number)value).intValue() : 0;
+                setForeground((cellValue > 30) ? Color.black : Color.red);
+                setText((value == null) ? "" : value.toString());
+            }
+        };
+        numberColumnRenderer.setHorizontalAlignment(JLabel.RIGHT);
+        numbersColumn.setCellRenderer(numberColumnRenderer);
+        numbersColumn.setPreferredWidth(110);
+
+        // Finish setting up the table.
+        JScrollPane scrollpane = new JScrollPane(tableView);
+        scrollpane.setBorder(new BevelBorder(BevelBorder.LOWERED));
+        scrollpane.setPreferredSize(new Dimension(430, 200));
+
+        contentPane.add(scrollpane);
+    }
+
+
+    public void init() {
+        SwingUtilities.invokeLater(() -> {
+            try {
+                UIManager.setLookAndFeel(
+                        "javax.swing.plaf.metal.MetalLookAndFeel");
+            } catch (Exception e) {
+                throw new RuntimeException(e);
+            }
+
+            initTest(getContentPane());
+        });
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/javax/swing/JTable/TAB/TAB.html	Thu Nov 13 09:39:22 2014 -0800
@@ -0,0 +1,43 @@
+<!--
+ Copyright (c) 1999, Oracle and/or its affiliates. All rights reserved.
+ DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+
+ This code is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License version 2 only, as
+ published by the Free Software Foundation.
+
+ This code is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ version 2 for more details (a copy is included in the LICENSE file that
+ accompanied this code).
+
+ You should have received a copy of the GNU General Public License version
+ 2 along with this work; if not, write to the Free Software Foundation,
+ Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+
+ Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ or visit www.oracle.com if you need additional information or have any
+ questions.
+-->
+
+<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
+<html>
+  <head>
+    <title>Tabbing test</title>
+  </head>
+
+  <body>
+    <h1>Tabbing test</h1>
+    <applet code=TAB width=500 height=200>
+    </applet>
+
+    <p>
+      Select a cell by double clicking it, press tab. Check that the focus moves to the next cell. 
+       If it does, press "pass", otherwise press "fail".
+    <hr>
+    <address><a href="mailto:milne@taller">Philip Milne</a></address>
+
+  </body>
+</html>
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/javax/swing/JTable/TAB/TAB.java	Thu Nov 13 09:39:22 2014 -0800
@@ -0,0 +1,169 @@
+/*
+ * Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+import java.awt.Color;
+import java.awt.Container;
+import java.awt.Dimension;
+
+import javax.swing.DefaultCellEditor;
+import javax.swing.JApplet;
+import javax.swing.JComboBox;
+import javax.swing.JLabel;
+import javax.swing.JScrollPane;
+import javax.swing.JTable;
+import javax.swing.SwingUtilities;
+import javax.swing.UIManager;
+import javax.swing.border.BevelBorder;
+import javax.swing.table.AbstractTableModel;
+import javax.swing.table.DefaultTableCellRenderer;
+import javax.swing.table.TableCellRenderer;
+import javax.swing.table.TableColumn;
+import javax.swing.table.TableModel;
+
+/**
+ * @test
+ * @bug 4128521
+ * @summary
+ *     Tabbing test
+ * @author milne
+ * @run applet/manual=yesno TAB.html
+ */
+public class TAB extends JApplet
+{
+    static void initTest(Container contentPane)
+    {
+        // Take the dummy data from SwingSet.
+        final String[] names = {"First Name", "Last Name", "Favorite Color",
+                "Favorite Number", "Vegetarian"};
+        final Object[][] data = {
+                {"Mark", "Andrews", "Red", new Integer(2), new Boolean(true)},
+                {"Tom", "Ball", "Blue", new Integer(99), new Boolean(false)},
+                {"Alan", "Chung", "Green", new Integer(838), new Boolean(false)},
+                {"Jeff", "Dinkins", "Turquois", new Integer(8), new Boolean(true)},
+                {"Amy", "Fowler", "Yellow", new Integer(3), new Boolean(false)},
+                {"Brian", "Gerhold", "Green", new Integer(0), new Boolean(false)},
+                {"James", "Gosling", "Pink", new Integer(21), new Boolean(false)},
+                {"David", "Karlton", "Red", new Integer(1), new Boolean(false)},
+                {"Dave", "Kloba", "Yellow", new Integer(14), new Boolean(false)},
+                {"Peter", "Korn", "Purple", new Integer(12), new Boolean(false)},
+                {"Phil", "Milne", "Purple", new Integer(3), new Boolean(false)},
+                {"Dave", "Moore", "Green", new Integer(88), new Boolean(false)},
+                {"Hans", "Muller", "Maroon", new Integer(5), new Boolean(false)},
+                {"Rick", "Levenson", "Blue", new Integer(2), new Boolean(false)},
+                {"Tim", "Prinzing", "Blue", new Integer(22), new Boolean(false)},
+                {"Chester", "Rose", "Black", new Integer(0), new Boolean(false)},
+                {"Ray", "Ryan", "Gray", new Integer(77), new Boolean(false)},
+                {"Georges", "Saab", "Red", new Integer(4), new Boolean(false)},
+                {"Willie", "Walker", "Phthalo Blue", new Integer(4), new Boolean(false)},
+                {"Kathy", "Walrath", "Blue", new Integer(8), new Boolean(false)},
+                {"Arnaud", "Weber", "Green", new Integer(44), new Boolean(false)}
+        };
+
+        // Create a model of the data.
+        TableModel dataModel = new AbstractTableModel() {
+            // These methods always need to be implemented.
+            public int getColumnCount() { return names.length; }
+            public int getRowCount() { return data.length;}
+            public Object getValueAt(int row, int col) {return data[row][col];}
+
+            // The default implementations of these methods in
+            // AbstractTableModel would work, but we can refine them.
+            public String getColumnName(int column) {return names[column];}
+            public Class getColumnClass(int c) {return getValueAt(0, c).getClass();}
+            public boolean isCellEditable(int row, int col) {return true;}
+            public void setValueAt(Object aValue, int row, int column) {
+                System.out.println("Setting value to: " + aValue);
+                data[row][column] = aValue;
+            }
+        };
+
+        // Create the table
+        JTable tableView = new JTable(dataModel);
+        // Turn off auto-resizing so that we can set column sizes programmatically.
+        // In this mode, all columns will get their preferred widths, as set blow.
+        tableView.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
+
+        // Create a combo box to show that you can use one in a table.
+        JComboBox comboBox = new JComboBox();
+        comboBox.addItem("Red");
+        comboBox.addItem("Orange");
+        comboBox.addItem("Yellow");
+        comboBox.addItem("Green");
+        comboBox.addItem("Blue");
+        comboBox.addItem("Indigo");
+        comboBox.addItem("Violet");
+
+        TableColumn colorColumn = tableView.getColumn("Favorite Color");
+        // Use the combo box as the editor in the "Favorite Color" column.
+        colorColumn.setCellEditor(new DefaultCellEditor(comboBox));
+
+        // Set a pink background and tooltip for the Color column renderer.
+        DefaultTableCellRenderer colorColumnRenderer = new DefaultTableCellRenderer();
+        colorColumnRenderer.setBackground(Color.pink);
+        colorColumnRenderer.setToolTipText("Click for combo box");
+        colorColumn.setCellRenderer(colorColumnRenderer);
+
+        // Set a tooltip for the header of the colors column.
+        TableCellRenderer headerRenderer = colorColumn.getHeaderRenderer();
+        if (headerRenderer instanceof DefaultTableCellRenderer)
+            ((DefaultTableCellRenderer)headerRenderer).setToolTipText("Hi Mom!");
+
+        // Set the width of the "Vegetarian" column.
+        TableColumn vegetarianColumn = tableView.getColumn("Vegetarian");
+        vegetarianColumn.setPreferredWidth(100);
+
+        // Show the values in the "Favorite Number" column in different colors.
+        TableColumn numbersColumn = tableView.getColumn("Favorite Number");
+        DefaultTableCellRenderer numberColumnRenderer = new DefaultTableCellRenderer() {
+            public void setValue(Object value) {
+                int cellValue = (value instanceof Number) ? ((Number)value).intValue() : 0;
+                setForeground((cellValue > 30) ? Color.black : Color.red);
+                setText((value == null) ? "" : value.toString());
+            }
+        };
+        numberColumnRenderer.setHorizontalAlignment(JLabel.RIGHT);
+        numbersColumn.setCellRenderer(numberColumnRenderer);
+        numbersColumn.setPreferredWidth(110);
+
+        // Finish setting up the table.
+        JScrollPane scrollpane = new JScrollPane(tableView);
+        scrollpane.setBorder(new BevelBorder(BevelBorder.LOWERED));
+        scrollpane.setPreferredSize(new Dimension(430, 200));
+
+        contentPane.add(scrollpane);
+    }
+
+
+    public void init() {
+        SwingUtilities.invokeLater(() -> {
+            try {
+                UIManager.setLookAndFeel(
+                        "javax.swing.plaf.metal.MetalLookAndFeel");
+            } catch (Exception e) {
+                throw new RuntimeException(e);
+            }
+
+            initTest(getContentPane());
+        });
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/javax/xml/jaxp/testng/parse/XMLEntityScannerLoad.java	Thu Nov 13 09:39:22 2014 -0800
@@ -0,0 +1,52 @@
+package parse;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+
+import static org.testng.Assert.assertEquals;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+import org.w3c.dom.Document;
+import org.xml.sax.SAXException;
+
+/**
+ * JDK-8059327: XML parser returns corrupt attribute value
+ * https://bugs.openjdk.java.net/browse/JDK-8059327
+ *
+ * Also:
+ * JDK-8061550: XMLEntityScanner can corrupt corrupt content during parsing
+ * https://bugs.openjdk.java.net/browse/JDK-8061550
+ *
+ * @Summary: verify that the character cache in XMLEntityScanner is reset properly
+ */
+
+public class XMLEntityScannerLoad {
+
+    @Test(dataProvider = "xmls")
+    public void test(String xml) throws SAXException, IOException, ParserConfigurationException {
+        Document d = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(new ChunkInputStream(xml));
+        String value = d.getDocumentElement().getAttribute("a1");
+        assertEquals(value, "w");
+    }
+
+    static class ChunkInputStream extends ByteArrayInputStream {
+        ChunkInputStream(String xml) {
+            super(xml.getBytes());
+        }
+
+        @Override
+        public synchronized int read(byte[] b, int off, int len) {
+            return super.read(b, off, 7);
+        }
+    }
+
+    @DataProvider(name = "xmls")
+    private Object[][] xmls() {
+        return new Object[][] {
+            {"<?xml version=\"1.0\"?><element a1=\"w\" a2=\"&quot;&quot;\"/>"},
+            {"<?xml version=\"1.1\"?><element a1=\"w\" a2=\"&quot;&quot;\"/>"}
+        };
+    }
+}
--- a/test/lib/testlibrary/ExtendedRobot.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/test/lib/testlibrary/ExtendedRobot.java	Thu Nov 13 09:39:22 2014 -0800
@@ -23,9 +23,6 @@
  * questions.
  */
 
-import sun.awt.ExtendedKeyCodes;
-import sun.awt.SunToolkit;
-
 import java.awt.AWTException;
 import java.awt.Robot;
 import java.awt.GraphicsDevice;
@@ -33,6 +30,7 @@
 import java.awt.Point;
 import java.awt.MouseInfo;
 import java.awt.event.InputEvent;
+import java.awt.event.KeyEvent;
 
 /**
  * ExtendedRobot is a subclass of {@link java.awt.Robot}. It provides some convenience methods that are
@@ -178,8 +176,7 @@
      *          dispatching thread
      */
     public synchronized void waitForIdle(int delayValue) {
-        SunToolkit.flushPendingEvents();
-        ((SunToolkit) Toolkit.getDefaultToolkit()).realSync();
+        super.waitForIdle();
         delay(delayValue);
     }
 
@@ -382,7 +379,7 @@
      * @see     java.awt.event.KeyEvent
      */
     public void type(char c) {
-        type(ExtendedKeyCodes.getExtendedKeyCodeForChar(c));
+        type(KeyEvent.getExtendedKeyCodeForChar(c));
     }
 
     /**
--- a/test/sun/jvmstat/monitor/MonitoredVm/CR6672135.java	Wed Nov 12 20:32:25 2014 -0800
+++ b/test/sun/jvmstat/monitor/MonitoredVm/CR6672135.java	Thu Nov 13 09:39:22 2014 -0800
@@ -34,6 +34,7 @@
  * @bug 6672135
  * @summary setInterval() for local MonitoredHost and local MonitoredVm
  * @author Tomas Hurka
+ * @run main/othervm -XX:+UsePerfData CR6672135
  */
 public class CR6672135 {
 
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/sun/security/pkcs11/Cipher/JNICheck.java	Thu Nov 13 09:39:22 2014 -0800
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 8063700
+ * @run main/othervm -Xcheck:jni JNICheck
+ */
+
+import javax.crypto.Cipher;
+import javax.crypto.SealedObject;
+import javax.crypto.SecretKey;
+import javax.crypto.KeyGenerator;
+import java.security.NoSuchProviderException;
+
+public class JNICheck {
+
+    /* This test is similar to the JCK test that found 8063700. */
+    static class SealedObjectTest {
+        Cipher c;
+
+        SealedObjectTest() throws Exception {
+            try {
+                c = Cipher.getInstance("AES", "SunPKCS11-Solaris");
+            } catch (NoSuchProviderException nspe) {
+                System.out.println("No SunPKCS11-Solaris provider.  Test skipped");
+                return;
+            }
+
+            String s = "Test string";
+            SealedObject so;
+            SecretKey key = KeyGenerator.getInstance("AES").generateKey();
+
+            c.init(Cipher.ENCRYPT_MODE, key);
+            so = new SealedObject(s, c);
+
+            so.getObject(key, "SunPKCS11-Solaris");
+        }
+    }
+
+    public static void main(String args[]) throws Exception {
+        new SealedObjectTest();
+    }
+}
--- a/test/sun/security/tools/keytool/ListKeychainStore.sh	Wed Nov 12 20:32:25 2014 -0800
+++ b/test/sun/security/tools/keytool/ListKeychainStore.sh	Thu Nov 13 09:39:22 2014 -0800
@@ -22,7 +22,7 @@
 #
 
 # @test
-# @bug 7133495 8041740 8062264
+# @bug 7133495 8041740 8062264 8046777
 # @summary [macosx] KeyChain KeyStore implementation retrieves only one private key entry
 
 if [ "${TESTJAVA}" = "" ] ; then
@@ -117,6 +117,26 @@
 fi
 echo "Imported keypairs from PKCS12 keystore into the keychain"
 
+# Generate a 2048-bit RSA keypair and import into the temporary keychain
+# (its private key is configured with non-default key usage settings)
+
+certtool c k=$TEMPORARY_KC <<EOF
+test
+r
+2048
+y
+b
+s
+y
+A
+US
+A
+A
+
+
+y
+EOF
+
 # Adjust the keychain search order
 
 echo "\"$TEMPORARY_KC\"" > $TEMPORARY_LIST
@@ -127,10 +147,11 @@
 security list-keychains
 
 # Recount the number of private key entries in the Keychain keystores
+# (3 private keys imported from PKCS12, 1 private key generated by 'certtool')
 
 RECOUNT=`$KEYTOOL -list | grep PrivateKeyEntry | wc -l`
 echo "Found $RECOUNT private key entries in the Keychain keystore"
-if [ $RECOUNT -lt `expr $COUNT + 3` ]; then
+if [ $RECOUNT -lt `expr $COUNT + 4` ]; then
     echo "Error: expected >$COUNT private key entries in the Keychain keystores"
     RESULT=`$CLEANUP_P12`
     RESULT=`$CLEANUP_KC`
@@ -141,7 +162,7 @@
 # Access controls have already been lowered (see 'security import ... -A' above)
 
 ${TESTJAVA}/bin/javac ${TESTJAVACOPTS} ${TESTTOOLVMOPTS} -d . ${TESTSRC}/ExportPrivateKeyNoPwd.java || exit 6
-echo | ${TESTJAVA}/bin/java ${TESTVMOPTS} ExportPrivateKeyNoPwd x
+${TESTJAVA}/bin/java ${TESTVMOPTS} ExportPrivateKeyNoPwd x
 if [ $? -ne 0 ]; then
     echo "Error exporting private key from the temporary keychain"
     RESULT=`$CLEANUP_P12`