From aaea8f4c7cae7940bc95aa8e080b15e40e7e4194 Mon Sep 17 00:00:00 2001 From: Sergey Malenkov Date: Fri, 21 Feb 2014 15:28:09 +0400 Subject: [PATCH 1/3] 8035310: The line.separator property can be retrieved via public API Reviewed-by: alexsch, serb --- .../classes/javax/swing/plaf/basic/BasicOptionPaneUI.java | 3 +-- jdk/src/share/classes/javax/swing/text/AbstractWriter.java | 5 +---- jdk/src/share/classes/javax/swing/text/DefaultEditorKit.java | 4 +--- jdk/src/share/classes/sun/font/CompositeFont.java | 3 +-- jdk/src/solaris/classes/sun/awt/X11/XAWTFormatter.java | 3 +-- 5 files changed, 5 insertions(+), 13 deletions(-) diff --git a/jdk/src/share/classes/javax/swing/plaf/basic/BasicOptionPaneUI.java b/jdk/src/share/classes/javax/swing/plaf/basic/BasicOptionPaneUI.java index b55f8ab0fbc..c58f4d35f0e 100644 --- a/jdk/src/share/classes/javax/swing/plaf/basic/BasicOptionPaneUI.java +++ b/jdk/src/share/classes/javax/swing/plaf/basic/BasicOptionPaneUI.java @@ -109,8 +109,7 @@ public class BasicOptionPaneUI extends OptionPaneUI { static { - newline = java.security.AccessController.doPrivileged( - new GetPropertyAction("line.separator")); + newline = System.lineSeparator(); if (newline == null) { newline = "\n"; } diff --git a/jdk/src/share/classes/javax/swing/text/AbstractWriter.java b/jdk/src/share/classes/javax/swing/text/AbstractWriter.java index 440ee5bb7cb..c0f3b4f3cc9 100644 --- a/jdk/src/share/classes/javax/swing/text/AbstractWriter.java +++ b/jdk/src/share/classes/javax/swing/text/AbstractWriter.java @@ -141,10 +141,7 @@ public abstract class AbstractWriter { 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 --git a/jdk/src/share/classes/javax/swing/text/DefaultEditorKit.java b/jdk/src/share/classes/javax/swing/text/DefaultEditorKit.java index 55d75fb7364..e5db094a910 100644 --- a/jdk/src/share/classes/javax/swing/text/DefaultEditorKit.java +++ b/jdk/src/share/classes/javax/swing/text/DefaultEditorKit.java @@ -317,9 +317,7 @@ public class DefaultEditorKit extends EditorKit { 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 --git a/jdk/src/share/classes/sun/font/CompositeFont.java b/jdk/src/share/classes/sun/font/CompositeFont.java index 54329695d49..f2defd79771 100644 --- a/jdk/src/share/classes/sun/font/CompositeFont.java +++ b/jdk/src/share/classes/sun/font/CompositeFont.java @@ -447,8 +447,7 @@ public final class CompositeFont extends Font2D { } 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 Date: Fri, 21 Feb 2014 15:34:05 +0400 Subject: [PATCH 2/3] 8034085: Do not prefer indexed properties Reviewed-by: alexsch --- .../classes/java/beans/Introspector.java | 52 ++-- .../java/beans/Introspector/Test4168833.java | 9 +- .../java/beans/Introspector/Test8034085.java | 236 ++++++++++++++++++ 3 files changed, 276 insertions(+), 21 deletions(-) create mode 100644 jdk/test/java/beans/Introspector/Test8034085.java diff --git a/jdk/src/share/classes/java/beans/Introspector.java b/jdk/src/share/classes/java/beans/Introspector.java index ceaef07f1ff..01b24ada112 100644 --- a/jdk/src/share/classes/java/beans/Introspector.java +++ b/jdk/src/share/classes/java/beans/Introspector.java @@ -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 @@ public class Introspector { 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 { - pd = mergePropertyDescriptor(igpd, ispd); + ipd = mergePropertyDescriptor(igpd, ispd); + } + if (pd == null) { + pd = ipd; + } else { + 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 @@ public class Introspector { } 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 @@ public class Introspector { } // 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 --git a/jdk/test/java/beans/Introspector/Test4168833.java b/jdk/test/java/beans/Introspector/Test4168833.java index 26cdb25f935..f3eea2c3714 100644 --- a/jdk/test/java/beans/Introspector/Test4168833.java +++ b/jdk/test/java/beans/Introspector/Test4168833.java @@ -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 @@ import java.beans.PropertyDescriptor; */ 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 --git a/jdk/test/java/beans/Introspector/Test8034085.java b/jdk/test/java/beans/Introspector/Test8034085.java new file mode 100644 index 00000000000..25745a92316 --- /dev/null +++ b/jdk/test/java/beans/Introspector/Test8034085.java @@ -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) { + } + } +} From 4207a72caf3bfd6e0f75e5f7f0f1ac2ab403f0e2 Mon Sep 17 00:00:00 2001 From: Anton Litvinov Date: Fri, 21 Feb 2014 18:04:38 +0400 Subject: [PATCH 3/3] 8032078: [macosx] CPlatformWindow.setWindowState throws RuntimeException, if windowState=ICONIFIED|MAXIMIZED_BOTH Reviewed-by: pchelko, serb --- .../sun/lwawt/macosx/CPlatformWindow.java | 13 ++- .../ExceptionOnSetExtendedStateTest.java | 103 ++++++++++++++++++ 2 files changed, 114 insertions(+), 2 deletions(-) create mode 100644 jdk/test/java/awt/Frame/ExceptionOnSetExtendedStateTest/ExceptionOnSetExtendedStateTest.java diff --git a/jdk/src/macosx/classes/sun/lwawt/macosx/CPlatformWindow.java b/jdk/src/macosx/classes/sun/lwawt/macosx/CPlatformWindow.java index 39744cbef1f..a9de01d0d98 100644 --- a/jdk/src/macosx/classes/sun/lwawt/macosx/CPlatformWindow.java +++ b/jdk/src/macosx/classes/sun/lwawt/macosx/CPlatformWindow.java @@ -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 @@ public class CPlatformWindow extends CFRetainedResource implements PlatformWindo // 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 @@ public class CPlatformWindow extends CFRetainedResource implements PlatformWindo 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 --git a/jdk/test/java/awt/Frame/ExceptionOnSetExtendedStateTest/ExceptionOnSetExtendedStateTest.java b/jdk/test/java/awt/Frame/ExceptionOnSetExtendedStateTest/ExceptionOnSetExtendedStateTest.java new file mode 100644 index 00000000000..b0f3c63b048 --- /dev/null +++ b/jdk/test/java/awt/Frame/ExceptionOnSetExtendedStateTest/ExceptionOnSetExtendedStateTest.java @@ -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); + } + } +}