diff --git a/src/share/classes/java/awt/SequencedEvent.java b/src/share/classes/java/awt/SequencedEvent.java index 81fc116e56e7a6280ba6940bf70c3f30e7151295..f4fbc81c8f30b4e92d2fb033faef5aa40341a59a 100644 --- a/src/share/classes/java/awt/SequencedEvent.java +++ b/src/share/classes/java/awt/SequencedEvent.java @@ -104,11 +104,7 @@ class SequencedEvent extends AWTEvent implements ActiveEvent { if (EventQueue.isDispatchThread()) { EventDispatchThread edt = (EventDispatchThread) Thread.currentThread(); - edt.pumpEvents(SentEvent.ID, new Conditional() { - public boolean evaluate() { - return !SequencedEvent.this.isFirstOrDisposed(); - } - }); + edt.pumpEvents(ID, () -> !SequencedEvent.this.isFirstOrDisposed()); } else { while(!isFirstOrDisposed()) { synchronized (SequencedEvent.class) { diff --git a/test/TEST.groups b/test/TEST.groups index 8452ce52c52cd1633d574a741c7b3b5724ecde71..8afd9dd26c0ba68f086949b4051558d277bdbb5d 100644 --- a/test/TEST.groups +++ b/test/TEST.groups @@ -393,6 +393,7 @@ needs_jre = \ javax/management/mxbean/LeakTest.java \ javax/management/mxbean/MXBeanTest.java \ javax/management/mxbean/PropertyNamesTest.java \ + javax/xml/bind/marshal/8036981/Test.java \ javax/xml/bind/marshal/8134111/UnmarshalTest.java \ javax/xml/ws/8043129 \ jdk/lambda/vm/InterfaceAccessFlagsTest.java \ diff --git a/test/java/awt/event/SequencedEvent/SequencedEventTest.java b/test/java/awt/event/SequencedEvent/SequencedEventTest.java new file mode 100644 index 0000000000000000000000000000000000000000..cddc8e0d50197699200ccf0256bb3fd142cd2fac --- /dev/null +++ b/test/java/awt/event/SequencedEvent/SequencedEventTest.java @@ -0,0 +1,171 @@ +/* + * Copyright (c) 2018, 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 8152974 + * @summary AWT hang occurrs when sequenced events arrive out of sequence + * @run main SequencedEventTest + */ +import sun.awt.AppContext; +import sun.awt.SunToolkit; + +import java.awt.Robot; +import java.awt.Point; +import java.awt.Dimension; +import java.awt.FlowLayout; +import java.awt.AWTEvent; +import java.awt.Toolkit; +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; +import java.awt.event.InputEvent; +import java.lang.reflect.Constructor; +import java.util.concurrent.CountDownLatch; + +import javax.swing.JFrame; +import javax.swing.JButton; +import javax.swing.SwingUtilities; +import javax.swing.JTextArea; + +public class SequencedEventTest extends JFrame implements ActionListener { + private JButton spamMeButton; + private static Robot robot; + private static SequencedEventTest window; + private static AppContext context; + + public static void main(String[] args) throws Exception { + SwingUtilities.invokeAndWait(() -> { + window = new SequencedEventTest(); + window.setVisible(true); + }); + + robot = new Robot(); + robot.waitForIdle(); + + Point pt = window.spamMeButton.getLocationOnScreen(); + Dimension d = window.spamMeButton.getSize(); + + robot.mouseMove(pt.x + d.width / 2, pt.y + d.height / 2); + robot.waitForIdle(); + robot.mousePress(InputEvent.BUTTON1_DOWN_MASK); + robot.mouseRelease(InputEvent.BUTTON1_DOWN_MASK); + /* + *Cannot have robot.waitForIdle() here since it will block the test forever, + * in the case of failure and the test will timeout. + */ + + try { + /* + * Wait for 2 seconds, and then see if all the sequenced events are dispatched. + */ + Thread.sleep(2000); + AWTEvent ev = Toolkit.getDefaultToolkit().getSystemEventQueue(). + peekEvent(java.awt.event.FocusEvent.FOCUS_LAST + 1); + + if (ev != null) + throw new RuntimeException("Test case failed!"); + } catch (InterruptedException e) { + throw new RuntimeException("Test case failed." + e.getMessage()); + } + + /* + * In the case of failure, the cleanup job cannot be executed, since it + * will block the test. + */ + System.out.println("Test case succeeded."); + context.dispose(); + SwingUtilities.invokeAndWait(() -> window.dispose()); + } + + public SequencedEventTest() { + super("Test Window"); + + setLayout(new FlowLayout()); + JTextArea textBlock = new JTextArea("Lorem ipsum dolor sit amet..."); + add(textBlock); + + spamMeButton = new JButton("Press me!"); + spamMeButton.addActionListener(this); + add(spamMeButton); + setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); + pack(); + } + + @Override + public void actionPerformed(ActionEvent e) { + if(e.getSource() == spamMeButton) { + AWTEvent eventOne = getSequencedEvent(); + AWTEvent eventFour = getSequencedEvent(); + ThreadGroup tg = new ThreadGroup("TestThreadGroup" ); + CountDownLatch latch = new CountDownLatch(1); + Thread t = new Thread(tg, () -> { + context = SunToolkit.createNewAppContext(); + AWTEvent eventTwo = getSequencedEvent(); + AWTEvent eventThree = getSequencedEvent(); + + Toolkit.getDefaultToolkit().getSystemEventQueue().postEvent(eventThree); + Toolkit.getDefaultToolkit().getSystemEventQueue().postEvent(new ActionEvent(this, 0, null)); + Toolkit.getDefaultToolkit().getSystemEventQueue().postEvent(new ActionEvent(this, 1, null)); + Toolkit.getDefaultToolkit().getSystemEventQueue().postEvent(eventTwo); + + latch.countDown(); + }); + + t.start(); + try { + latch.await(); + }catch (InterruptedException ex) { + throw new RuntimeException("Test case failed."); + } + + Toolkit.getDefaultToolkit().getSystemEventQueue().postEvent(eventFour); + Toolkit.getDefaultToolkit().getSystemEventQueue().postEvent(new ActionEvent(this, 2, null)); + Toolkit.getDefaultToolkit().getSystemEventQueue().postEvent(new ActionEvent(this, 3, null)); + Toolkit.getDefaultToolkit().getSystemEventQueue().postEvent(eventOne); + + try { + t.join(); + } catch (InterruptedException ex) { + throw new RuntimeException("Test case failed."); + } + } + } + + private AWTEvent getSequencedEvent() + { + AWTEvent wrapMe = new AWTEvent(this, AWTEvent.RESERVED_ID_MAX) {}; + + try { + /* + * SequencedEvent is a package private class, which cannot be instantiated + * by importing. So use reflection to create an instance. + */ + Class seqClass = (Class) Class.forName("java.awt.SequencedEvent"); + Constructor seqConst = seqClass.getConstructor(AWTEvent.class); + seqConst.setAccessible(true);; + return seqConst.newInstance(wrapMe); + } catch (Throwable err) { + throw new RuntimeException("Unable to instantiate SequencedEvent",err); + } + } +} diff --git a/test/java/security/Signature/SignatureLength.java b/test/java/security/Signature/SignatureLength.java index 13c4a6dd938395b915185c4ff244d447c2d12a77..ee6b72b7dbcd0f6de0f534e288007a19f51366de 100644 --- a/test/java/security/Signature/SignatureLength.java +++ b/test/java/security/Signature/SignatureLength.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2018, 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 @@ -21,48 +21,82 @@ * questions. */ -import java.security.*; - /* * @test - * @bug 8161571 + * @bug 8161571 8178370 * @summary Reject signatures presented for verification that contain extra * bytes. + * @modules jdk.crypto.ec * @run main SignatureLength */ + +import java.security.KeyPair; +import java.security.KeyPairGenerator; +import java.security.NoSuchAlgorithmException; +import java.security.Provider; +import java.security.Security; +import java.security.Signature; +import java.security.SignatureException; + public class SignatureLength { public static void main(String[] args) throws Exception { - main0("EC", 256, "SHA256withECDSA", "SunEC"); - main0("RSA", 2048, "SHA256withRSA", "SunRsaSign"); - main0("DSA", 2048, "SHA256withDSA", "SUN"); + for (Provider p0 : Security.getProviders()) { + for (Provider p1 : Security.getProviders()) { + for (Provider p2 : Security.getProviders()) { + // SunMSCAPI signer can only be initialized with + // a key generated with SunMSCAPI + if (!p0.getName().equals("SunMSCAPI") + && p1.getName().equals("SunMSCAPI")) continue; + + // SunMSCAPI generated key can only be signed + // with SunMSCAPI signer + if (p0.getName().equals("SunMSCAPI") + && !p1.getName().equals("SunMSCAPI")) continue; + + // SunMSCAPI and SunPKCS11 verifiers may return false + // instead of throwing SignatureException + boolean mayNotThrow = p2.getName().equals("SunMSCAPI") + || p2.getName().startsWith("SunPKCS11"); - if (System.getProperty("os.name").equals("SunOS")) { - main0("EC", 256, "SHA256withECDSA", null); - main0("RSA", 2048, "SHA256withRSA", null); + main0("EC", 256, "SHA256withECDSA", p0, p1, p2, mayNotThrow); + main0("RSA", 2048, "SHA256withRSA", p0, p1, p2, mayNotThrow); + main0("DSA", 2048, "SHA256withDSA", p0, p1, p2, mayNotThrow); + } + } } } private static void main0(String keyAlgorithm, int keysize, - String signatureAlgorithm, String provider) throws Exception { + String signatureAlgorithm, Provider generatorProvider, + Provider signerProvider, Provider verifierProvider, + boolean mayNotThrow) throws Exception { + + KeyPairGenerator generator; + Signature signer; + Signature verifier; + + try { + generator = KeyPairGenerator.getInstance(keyAlgorithm, + generatorProvider); + signer = Signature.getInstance(signatureAlgorithm, + signerProvider); + verifier = Signature.getInstance(signatureAlgorithm, + verifierProvider); + } catch (NoSuchAlgorithmException nsae) { + // ignore this set of providers + return; + } + byte[] plaintext = "aaa".getBytes("UTF-8"); // Generate - KeyPairGenerator generator = - provider == null ? - (KeyPairGenerator) KeyPairGenerator.getInstance(keyAlgorithm) : - (KeyPairGenerator) KeyPairGenerator.getInstance( - keyAlgorithm, provider); generator.initialize(keysize); System.out.println("Generating " + keyAlgorithm + " keypair using " + generator.getProvider().getName() + " JCE provider"); KeyPair keypair = generator.generateKeyPair(); // Sign - Signature signer = - provider == null ? - Signature.getInstance(signatureAlgorithm) : - Signature.getInstance(signatureAlgorithm, provider); signer.initSign(keypair.getPrivate()); signer.update(plaintext); System.out.println("Signing using " + signer.getProvider().getName() + @@ -80,19 +114,26 @@ public class SignatureLength { badSignature[signature.length + 4] = 0x01; // Verify - Signature verifier = - provider == null ? - Signature.getInstance(signatureAlgorithm) : - Signature.getInstance(signatureAlgorithm, provider); verifier.initVerify(keypair.getPublic()); verifier.update(plaintext); System.out.println("Verifying using " + verifier.getProvider().getName() + " JCE provider"); try { - System.out.println("Valid? " + verifier.verify(badSignature)); - throw new Exception( - "ERROR: expected a SignatureException but none was thrown"); + boolean valid = verifier.verify(badSignature); + System.out.println("Valid? " + valid); + if (mayNotThrow) { + if (valid) { + throw new Exception( + "ERROR: expected a SignatureException but none was thrown" + + " and invalid signature was verified"); + } else { + System.out.println("OK: verification failed as expected"); + } + } else { + throw new Exception( + "ERROR: expected a SignatureException but none was thrown"); + } } catch (SignatureException e) { System.out.println("OK: caught expected exception: " + e); }