# HG changeset patch
# User prr
# Date 1393005829 28800
# Node ID fd976b9703f1ca42262c4b34ac8d30b97e2a0b07
# Parent  dfbe9ff289c649ef6172d75abe8d199db3ed3896# Parent  f5604dd7b2742a9bc690f70a373be1cd3f6d39be
Merge

diff -r dfbe9ff289c6 -r fd976b9703f1 jdk/src/macosx/classes/sun/lwawt/macosx/CPlatformWindow.java
--- a/jdk/src/macosx/classes/sun/lwawt/macosx/CPlatformWindow.java	Thu Feb 20 16:27:08 2014 -0800
+++ b/jdk/src/macosx/classes/sun/lwawt/macosx/CPlatformWindow.java	Fri Feb 21 10:03:49 2014 -0800
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011, 2013, 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
@@ -583,7 +583,12 @@
                     // setVisible could have changed the native maximized state
                     deliverZoom(true);
                 } else {
-                    switch (((Frame)target).getExtendedState()) {
+                    int frameState = ((Frame)target).getExtendedState();
+                    if ((frameState & Frame.ICONIFIED) != 0) {
+                        // Treat all state bit masks with ICONIFIED bit as ICONIFIED state.
+                        frameState = Frame.ICONIFIED;
+                    }
+                    switch (frameState) {
                         case Frame.ICONIFIED:
                             CWrapper.NSWindow.miniaturize(nsWindowPtr);
                             break;
@@ -784,6 +789,10 @@
         if (prevWindowState == windowState) return;
 
         final long nsWindowPtr = getNSWindowPtr();
+        if ((windowState & Frame.ICONIFIED) != 0) {
+            // Treat all state bit masks with ICONIFIED bit as ICONIFIED state.
+            windowState = Frame.ICONIFIED;
+        }
         switch (windowState) {
             case Frame.ICONIFIED:
                 if (prevWindowState == Frame.MAXIMIZED_BOTH) {
diff -r dfbe9ff289c6 -r fd976b9703f1 jdk/src/share/classes/java/beans/Introspector.java
--- a/jdk/src/share/classes/java/beans/Introspector.java	Thu Feb 20 16:27:08 2014 -0800
+++ b/jdk/src/share/classes/java/beans/Introspector.java	Fri Feb 21 10:03:49 2014 -0800
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1996, 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
@@ -729,22 +729,38 @@
             if (igpd != null && ispd != null) {
                 // Complete indexed properties set
                 // Merge any classic property descriptors
-                if (gpd != null) {
-                    PropertyDescriptor tpd = mergePropertyDescriptor(igpd, gpd);
-                    if (tpd instanceof IndexedPropertyDescriptor) {
-                        igpd = (IndexedPropertyDescriptor)tpd;
-                    }
-                }
-                if (spd != null) {
-                    PropertyDescriptor tpd = mergePropertyDescriptor(ispd, spd);
-                    if (tpd instanceof IndexedPropertyDescriptor) {
-                        ispd = (IndexedPropertyDescriptor)tpd;
-                    }
+                if ((gpd == spd) || (gpd == null)) {
+                    pd = spd;
+                } else if (spd == null) {
+                    pd = gpd;
+                } else if (spd instanceof IndexedPropertyDescriptor) {
+                    pd = mergePropertyWithIndexedProperty(gpd, (IndexedPropertyDescriptor) spd);
+                } else if (gpd instanceof IndexedPropertyDescriptor) {
+                    pd = mergePropertyWithIndexedProperty(spd, (IndexedPropertyDescriptor) gpd);
+                } else {
+                    pd = mergePropertyDescriptor(gpd, spd);
                 }
                 if (igpd == ispd) {
-                    pd = igpd;
+                    ipd = igpd;
+                } else {
+                    ipd = mergePropertyDescriptor(igpd, ispd);
+                }
+                if (pd == null) {
+                    pd = ipd;
                 } else {
-                    pd = mergePropertyDescriptor(igpd, ispd);
+                    Class<?> propType = pd.getPropertyType();
+                    Class<?> ipropType = ipd.getIndexedPropertyType();
+                    if (propType.isArray() && propType.getComponentType() == ipropType) {
+                        pd = pd.getClass0().isAssignableFrom(ipd.getClass0())
+                                ? new IndexedPropertyDescriptor(pd, ipd)
+                                : new IndexedPropertyDescriptor(ipd, pd);
+                    } else if (pd.getClass0().isAssignableFrom(ipd.getClass0())) {
+                        pd = pd.getClass0().isAssignableFrom(ipd.getClass0())
+                                ? new PropertyDescriptor(pd, ipd)
+                                : new PropertyDescriptor(ipd, pd);
+                    } else {
+                        pd = ipd;
+                    }
                 }
             } else if (gpd != null && spd != null) {
                 if (igpd != null) {
@@ -848,6 +864,12 @@
             } else {
                 result = new IndexedPropertyDescriptor(ipd, pd);
             }
+        } else if ((ipd.getReadMethod() == null) && (ipd.getWriteMethod() == null)) {
+            if (pd.getClass0().isAssignableFrom(ipd.getClass0())) {
+                result = new PropertyDescriptor(pd, ipd);
+            } else {
+                result = new PropertyDescriptor(ipd, pd);
+            }
         } else {
             // Cannot merge the pd because of type mismatch
             // Return the most specific pd
@@ -899,7 +921,7 @@
     }
 
     // Handle regular ipd merge
-    private PropertyDescriptor mergePropertyDescriptor(IndexedPropertyDescriptor ipd1,
+    private IndexedPropertyDescriptor mergePropertyDescriptor(IndexedPropertyDescriptor ipd1,
                                                        IndexedPropertyDescriptor ipd2) {
         if (ipd1.getClass0().isAssignableFrom(ipd2.getClass0())) {
             return new IndexedPropertyDescriptor(ipd1, ipd2);
diff -r dfbe9ff289c6 -r fd976b9703f1 jdk/src/share/classes/javax/swing/plaf/basic/BasicOptionPaneUI.java
--- a/jdk/src/share/classes/javax/swing/plaf/basic/BasicOptionPaneUI.java	Thu Feb 20 16:27:08 2014 -0800
+++ b/jdk/src/share/classes/javax/swing/plaf/basic/BasicOptionPaneUI.java	Fri Feb 21 10:03:49 2014 -0800
@@ -109,8 +109,7 @@
 
 
     static {
-        newline = java.security.AccessController.doPrivileged(
-                                new GetPropertyAction("line.separator"));
+        newline = System.lineSeparator();
         if (newline == null) {
             newline = "\n";
         }
diff -r dfbe9ff289c6 -r fd976b9703f1 jdk/src/share/classes/javax/swing/text/AbstractWriter.java
--- a/jdk/src/share/classes/javax/swing/text/AbstractWriter.java	Thu Feb 20 16:27:08 2014 -0800
+++ b/jdk/src/share/classes/javax/swing/text/AbstractWriter.java	Fri Feb 21 10:03:49 2014 -0800
@@ -141,10 +141,7 @@
             setLineSeparator((String)docNewline);
         }
         else {
-            String newline = null;
-            try {
-                newline = System.getProperty("line.separator");
-            } catch (SecurityException se) {}
+            String newline = System.lineSeparator();
             if (newline == null) {
                 // Should not get here, but if we do it means we could not
                 // find a newline string, use \n in this case.
diff -r dfbe9ff289c6 -r fd976b9703f1 jdk/src/share/classes/javax/swing/text/DefaultEditorKit.java
--- a/jdk/src/share/classes/javax/swing/text/DefaultEditorKit.java	Thu Feb 20 16:27:08 2014 -0800
+++ b/jdk/src/share/classes/javax/swing/text/DefaultEditorKit.java	Fri Feb 21 10:03:49 2014 -0800
@@ -317,9 +317,7 @@
         int offs = pos;
         Object endOfLineProperty = doc.getProperty(EndOfLineStringProperty);
         if (endOfLineProperty == null) {
-            try {
-                endOfLineProperty = System.getProperty("line.separator");
-            } catch (SecurityException se) { }
+            endOfLineProperty = System.lineSeparator();
         }
         String endOfLine;
         if (endOfLineProperty instanceof String) {
diff -r dfbe9ff289c6 -r fd976b9703f1 jdk/src/share/classes/sun/font/CompositeFont.java
--- a/jdk/src/share/classes/sun/font/CompositeFont.java	Thu Feb 20 16:27:08 2014 -0800
+++ b/jdk/src/share/classes/sun/font/CompositeFont.java	Fri Feb 21 10:03:49 2014 -0800
@@ -447,8 +447,7 @@
     }
 
     public String toString() {
-        String ls = java.security.AccessController.doPrivileged(
-                new sun.security.action.GetPropertyAction("line.separator"));
+        String ls = System.lineSeparator();
         String componentsStr = "";
         for (int i=0; i<numSlots; i++) {
             componentsStr += "    Slot["+i+"]="+getSlotFont(i)+ls;
diff -r dfbe9ff289c6 -r fd976b9703f1 jdk/src/solaris/classes/sun/awt/X11/XAWTFormatter.java
--- a/jdk/src/solaris/classes/sun/awt/X11/XAWTFormatter.java	Thu Feb 20 16:27:08 2014 -0800
+++ b/jdk/src/solaris/classes/sun/awt/X11/XAWTFormatter.java	Fri Feb 21 10:03:49 2014 -0800
@@ -43,8 +43,7 @@
 
     // Line separator string.  This is the value of the line.separator
     // property at the moment that the SimpleFormatter was created.
-    private String lineSeparator = java.security.AccessController.doPrivileged(
-               new sun.security.action.GetPropertyAction("line.separator"));
+    private String lineSeparator = System.lineSeparator();
 
     boolean displayFullRecord = false;
     boolean useANSI = false;
diff -r dfbe9ff289c6 -r fd976b9703f1 jdk/test/java/awt/Frame/ExceptionOnSetExtendedStateTest/ExceptionOnSetExtendedStateTest.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/java/awt/Frame/ExceptionOnSetExtendedStateTest/ExceptionOnSetExtendedStateTest.java	Fri Feb 21 10:03:49 2014 -0800
@@ -0,0 +1,103 @@
+/*
+ * 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 8032078
+   @summary Frame.setExtendedState throws RuntimeException, if
+            windowState=ICONIFIED|MAXIMIZED_BOTH, on OS X
+   @author Anton Litvinov
+*/
+
+import java.awt.*;
+
+import sun.awt.SunToolkit;
+
+public class ExceptionOnSetExtendedStateTest {
+    private static final int[] frameStates = { Frame.NORMAL, Frame.ICONIFIED, Frame.MAXIMIZED_BOTH };
+    private static final SunToolkit toolkit = (SunToolkit)Toolkit.getDefaultToolkit();
+
+    private static boolean validatePlatform() {
+        String osName = System.getProperty("os.name");
+        if (osName == null) {
+            throw new RuntimeException("Name of the current OS could not be retrieved.");
+        }
+        return osName.startsWith("Mac");
+    }
+
+    private static void testStateChange(int oldState, int newState, boolean decoratedFrame) {
+        System.out.println(String.format(
+            "testStateChange: oldState='%d', newState='%d', decoratedFrame='%b'",
+            oldState, newState, decoratedFrame));
+
+        Frame frame = new Frame("ExceptionOnSetExtendedStateTest");
+        frame.setSize(200, 200);
+        frame.setUndecorated(!decoratedFrame);
+        frame.setVisible(true);
+        toolkit.realSync();
+
+        frame.setExtendedState(oldState);
+        sleep(1000);
+        frame.setExtendedState(newState);
+
+        boolean stateWasNotChanged = true;
+        int currentState = 0;
+        for (int i = 0; (i < 3) && stateWasNotChanged; i++) {
+            sleep(1000);
+            currentState = frame.getExtendedState();
+            if ((currentState == newState) ||
+                (((newState & Frame.ICONIFIED) != 0) && ((currentState & Frame.ICONIFIED) != 0))) {
+                stateWasNotChanged = false;
+            }
+        }
+        frame.dispose();
+
+        if (stateWasNotChanged) {
+            throw new RuntimeException(String.format(
+                "Frame state was not changed. currentState='%d'", currentState));
+        }
+    }
+
+    private static void sleep(int millis) {
+        try {
+            Thread.sleep(millis);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static void main(String[] args) {
+        if (!validatePlatform()) {
+            System.out.println("This test is only for OS X.");
+            return;
+        }
+
+        // Verify that changing states of decorated/undecorated frame to/from supported states
+        // and the state bit mask ICONIFIED | MAXIMIZED_BOTH does not raise RuntimeException.
+        for (int i = 0; i < frameStates.length; i++) {
+            testStateChange(frameStates[i], Frame.ICONIFIED | Frame.MAXIMIZED_BOTH, true);
+            testStateChange(frameStates[i], Frame.ICONIFIED | Frame.MAXIMIZED_BOTH, false);
+            testStateChange(Frame.ICONIFIED | Frame.MAXIMIZED_BOTH, frameStates[i], true);
+            testStateChange(Frame.ICONIFIED | Frame.MAXIMIZED_BOTH, frameStates[i], false);
+        }
+    }
+}
diff -r dfbe9ff289c6 -r fd976b9703f1 jdk/test/java/beans/Introspector/Test4168833.java
--- a/jdk/test/java/beans/Introspector/Test4168833.java	Thu Feb 20 16:27:08 2014 -0800
+++ b/jdk/test/java/beans/Introspector/Test4168833.java	Fri Feb 21 10:03:49 2014 -0800
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003, 2007, 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
@@ -23,10 +23,11 @@
 
 /*
  * @test
- * @bug 4168833
+ * @bug 4168833 8034085
  * @summary Tests that Introspector does not create IndexedPropertyDescriptor
  *          from non-indexed PropertyDescriptor
  * @author Mark Davidson
+ * @author Sergey Malenkov
  */
 
 import java.awt.Color;
@@ -42,10 +43,6 @@
  */
 public class Test4168833 {
     public static void main(String[] args) throws Exception {
-        IndexedPropertyDescriptor ipd = BeanUtils.getIndexedPropertyDescriptor(Base.class, "prop");
-        if (!ipd.getIndexedPropertyType().equals(Dimension.class)) {
-            error(ipd, "Base.prop property should a Dimension");
-        }
         // When the Sub class is introspected,
         // the property type should be color.
         // The complete "classic" set of properties
diff -r dfbe9ff289c6 -r fd976b9703f1 jdk/test/java/beans/Introspector/Test8034085.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/java/beans/Introspector/Test8034085.java	Fri Feb 21 10:03:49 2014 -0800
@@ -0,0 +1,236 @@
+/*
+ * 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.Window;
+import java.beans.IndexedPropertyDescriptor;
+import java.beans.PropertyDescriptor;
+
+/*
+ * @test
+ * @bug 8034085
+ * @summary Tests that Introspector ignores indexed getter and setter for incorrect types
+ * @author Sergey Malenkov
+ */
+
+public class Test8034085 {
+    public static final StringBuilder ERROR = new StringBuilder();
+
+    public static void main(String[] args) {
+        test(Window.class, false, true, false, false);
+
+        test(Bean0000.class, false, false, false, false);
+        test(Bean0001.class, false, false, false, true);
+        test(Bean0010.class, false, false, true, false);
+        test(Bean0011.class, false, false, true, true);
+        test(Bean0100.class, false, true, false, false);
+        test(Bean0101.class, false, true, false, false);
+        test(Bean0110.class, false, true, false, false);
+        test(Bean0111.class, false, true, false, false);
+        test(Bean1000.class, true, false, false, false);
+        test(Bean1001.class, true, false, false, false);
+        test(Bean1010.class, true, false, false, false);
+        test(Bean1011.class, true, false, false, false);
+        test(Bean1100.class, true, true, false, false);
+        test(Bean1101.class, true, true, false, false);
+        test(Bean1110.class, true, true, false, false);
+        test(Bean1111.class, true, true, false, false);
+
+        if (0 < ERROR.length()) {
+            throw new Error(ERROR.toString());
+        }
+    }
+
+    private static void test(Class<?> type, boolean read, boolean write, boolean readIndexed, boolean writeIndexed) {
+        PropertyDescriptor pd = BeanUtils.findPropertyDescriptor(type, "size");
+        if (pd != null) {
+            test(type, "read", read, null != pd.getReadMethod());
+            test(type, "write", write, null != pd.getWriteMethod());
+            if (pd instanceof IndexedPropertyDescriptor) {
+                IndexedPropertyDescriptor ipd = (IndexedPropertyDescriptor) pd;
+                test(type, "indexed read", readIndexed, null != ipd.getIndexedReadMethod());
+                test(type, "indexed write", writeIndexed, null != ipd.getIndexedWriteMethod());
+            } else if (readIndexed || writeIndexed) {
+                error(type, "indexed property does not exist");
+            }
+        } else if (read || write || readIndexed || writeIndexed) {
+            error(type, "property does not exist");
+        }
+    }
+
+    private static void test(Class<?> type, String name, boolean expected, boolean actual) {
+        if (expected && !actual) {
+            error(type, name + " method does not exist");
+        } else if (!expected && actual) {
+            error(type, name + " method is not expected");
+        }
+    }
+
+    private static void error(Class<?> type, String message) {
+        ERROR.append("\n\t\t").append(type.getSimpleName()).append(".size: ").append(message);
+    }
+
+    public static class Bean0000 {
+    }
+
+    public static class Bean0001 {
+        public void setSize(int index, int value) {
+        }
+    }
+
+    public static class Bean0010 {
+        public int getSize(int index) {
+            return 0;
+        }
+    }
+
+    public static class Bean0011 {
+        public int getSize(int index) {
+            return 0;
+        }
+
+        public void setSize(int index, int value) {
+        }
+    }
+
+    public static class Bean0100 {
+        public void setSize(int value) {
+        }
+    }
+
+    public static class Bean0101 {
+        public void setSize(int value) {
+        }
+
+        public void setSize(int index, int value) {
+        }
+    }
+
+    public static class Bean0110 {
+        public void setSize(int value) {
+        }
+
+        public int getSize(int index) {
+            return 0;
+        }
+    }
+
+    public static class Bean0111 {
+        public void setSize(int value) {
+        }
+
+        public int getSize(int index) {
+            return 0;
+        }
+
+        public void setSize(int index, int value) {
+        }
+    }
+
+    public static class Bean1000 {
+        public int getSize() {
+            return 0;
+        }
+    }
+
+    public static class Bean1001 {
+        public int getSize() {
+            return 0;
+        }
+
+        public void setSize(int index, int value) {
+        }
+    }
+
+    public static class Bean1010 {
+        public int getSize() {
+            return 0;
+        }
+
+        public int getSize(int index) {
+            return 0;
+        }
+    }
+
+    public static class Bean1011 {
+        public int getSize() {
+            return 0;
+        }
+
+        public int getSize(int index) {
+            return 0;
+        }
+
+        public void setSize(int index, int value) {
+        }
+    }
+
+    public static class Bean1100 {
+        public int getSize() {
+            return 0;
+        }
+
+        public void setSize(int value) {
+        }
+    }
+
+    public static class Bean1101 {
+        public int getSize() {
+            return 0;
+        }
+
+        public void setSize(int value) {
+        }
+
+        public void setSize(int index, int value) {
+        }
+    }
+
+    public static class Bean1110 {
+        public int getSize() {
+            return 0;
+        }
+
+        public void setSize(int value) {
+        }
+
+        public int getSize(int index) {
+            return 0;
+        }
+    }
+
+    public static class Bean1111 {
+        public int getSize() {
+            return 0;
+        }
+
+        public void setSize(int value) {
+        }
+
+        public int getSize(int index) {
+            return 0;
+        }
+
+        public void setSize(int index, int value) {
+        }
+    }
+}