/hg/icedtea6: Fix for Sun bug: 6829636: test case correction
ptisnovs at icedtea.classpath.org
ptisnovs at icedtea.classpath.org
Wed Feb 3 04:31:22 PST 2010
changeset 55c898e59858 in /hg/icedtea6
details: http://icedtea.classpath.org/hg/icedtea6?cmd=changeset;node=55c898e59858
author: ptisnovs
date: Wed Feb 03 13:30:49 2010 +0100
Fix for Sun bug: 6829636: test case correction
test/java/util/logging/loggingdeadlock2.java
diffstat:
3 files changed, 258 insertions(+), 1 deletion(-)
ChangeLog | 7
Makefile.am | 3
patches/icedtea-6829636-loggingdeadlock2.patch | 249 ++++++++++++++++++++++++
diffs (280 lines):
diff -r f8d8f6b0a1fd -r 55c898e59858 ChangeLog
--- a/ChangeLog Tue Feb 02 16:21:26 2010 -0500
+++ b/ChangeLog Wed Feb 03 13:30:49 2010 +0100
@@ -1,3 +1,10 @@ 2010-02-02 Deepak Bhole <dbhole at redhat.
+2010-02-03 Pavel Tisnovsky <ptisnovs at redhat.com>
+
+ * Makefile.am: Add new patch.
+ * patches/icedtea-6829636-loggingdeadlock2.patch
+ Fix for Sun bug: 6829636: test case correction
+ test/java/util/logging/loggingdeadlock2.java
+
2010-02-02 Deepak Bhole <dbhole at redhat.com>
* plugin/tests/LiveConnect/PluginTest.java
diff -r f8d8f6b0a1fd -r 55c898e59858 Makefile.am
--- a/Makefile.am Tue Feb 02 16:21:26 2010 -0500
+++ b/Makefile.am Wed Feb 03 13:30:49 2010 +0100
@@ -313,7 +313,8 @@ ICEDTEA_PATCHES = \
patches/icedtea-6920143-using-with-mouse.patch \
patches/icedtea-6920172-location-relative-to-test.patch \
patches/icedtea-6920172-turkish.patch \
- patches/icedtea-6912628-turkcert.patch
+ patches/icedtea-6912628-turkcert.patch \
+ patches/icedtea-6829636-loggingdeadlock2.patch
if WITH_RHINO
ICEDTEA_PATCHES += \
diff -r f8d8f6b0a1fd -r 55c898e59858 patches/icedtea-6829636-loggingdeadlock2.patch
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/patches/icedtea-6829636-loggingdeadlock2.patch Wed Feb 03 13:30:49 2010 +0100
@@ -0,0 +1,249 @@
+6829636: test/java/util/logging/LoggingDeadlock2.java is flaky
+Fixes created by mchung and martin
+
+--- openjdk.orig/jdk/test/java/util/logging/LoggingDeadlock2.java Fri Jan 30 16:27:33 2009 -0800
++++ openjdk/jdk/test/java/util/logging/LoggingDeadlock2.java Fri Dec 04 23:11:11 2009 +0000
+@@ -23,10 +23,10 @@
+
+ /*
+ * @test
+- * @bug 6467152
++ * @bug 6467152 6716076 6829503
+ *
+ * @summary deadlock occurs in LogManager initialization and JVM termination
+- * @author Serguei Spitsyn / Hittachi
++ * @author Serguei Spitsyn / Hittachi / Martin Buchholz
+ *
+ * @build LoggingDeadlock2
+ * @run main/timeout=15 LoggingDeadlock2
+@@ -47,43 +47,195 @@
+ * This is a regression test for this bug.
+ */
+
++import java.util.Arrays;
++import java.util.List;
++import java.util.Random;
++import java.util.concurrent.CyclicBarrier;
++import java.util.concurrent.atomic.AtomicInteger;
+ import java.util.logging.LogManager;
+-
+-public class LoggingDeadlock2 implements Runnable {
+- static final java.io.PrintStream out = System.out;
+- static Object lock = new Object();
+- static int c = 0;
+- public static void main(String arg[]) {
+- out.println("\nThis test checks that there is no deadlock.");
+- out.println("If not crashed or timed-out then it is passed.");
++import java.io.File;
++import java.io.InputStream;
++import java.io.InputStreamReader;
++import java.io.Reader;
++
++public class LoggingDeadlock2 {
++
++ public static void realMain(String arg[]) throws Throwable {
+ try {
+- new Thread(new LoggingDeadlock2()).start();
+- synchronized(lock) {
+- c++;
+- if (c == 2) lock.notify();
+- else lock.wait();
++ System.out.println(javaChildArgs);
++ ProcessBuilder pb = new ProcessBuilder(javaChildArgs);
++ ProcessResults r = run(pb.start());
++ equal(r.exitValue(), 99);
++ equal(r.out(), "");
++ equal(r.err(), "");
++ } catch (Throwable t) { unexpected(t); }
++ }
++
++ public static class JavaChild {
++ public static void main(String args[]) throws Throwable {
++ final CyclicBarrier startingGate = new CyclicBarrier(2);
++ final Throwable[] thrown = new Throwable[1];
++
++ // Some random variation, to help tickle races.
++ final Random rnd = new Random();
++ final boolean dojoin = rnd.nextBoolean();
++ final int JITTER = 1024;
++ final int iters1 = rnd.nextInt(JITTER);
++ final int iters2 = JITTER - iters1;
++ final AtomicInteger counter = new AtomicInteger(0);
++
++ Thread exiter = new Thread() {
++ public void run() {
++ try {
++ startingGate.await();
++ for (int i = 0; i < iters1; i++)
++ counter.getAndIncrement();
++ System.exit(99);
++ } catch (Throwable t) {
++ t.printStackTrace();
++ System.exit(86);
++ }
++ }};
++ exiter.start();
++
++ startingGate.await();
++ for (int i = 0; i < iters2; i++)
++ counter.getAndIncrement();
++ // This may or may not result in a first call to
++ // Runtime.addShutdownHook after shutdown has already
++ // commenced.
++ LogManager log = LogManager.getLogManager();
++
++ if (dojoin) {
++ exiter.join();
++ if (thrown[0] != null)
++ throw new Error(thrown[0]);
++ check(counter.get() == JITTER);
+ }
+- LogManager log = LogManager.getLogManager();
+- out.println("Test passed");
+- }
+- catch(Exception e) {
+- e.printStackTrace();
+- out.println("Test FAILED"); // Not expected
+- }
+- }
+-
+- public void run() {
++ }
++ }
++
++ //----------------------------------------------------------------
++ // The rest of this test is copied from ProcessBuilder/Basic.java
++ //----------------------------------------------------------------
++ private static final String javaExe =
++ System.getProperty("java.home") +
++ File.separator + "bin" + File.separator + "java";
++
++ private static final String classpath =
++ System.getProperty("java.class.path");
++
++ private static final List<String> javaChildArgs =
++ Arrays.asList(new String[]
++ { javaExe, "-classpath", classpath,
++ "LoggingDeadlock2$JavaChild"});
++
++ private static class ProcessResults {
++ private final String out;
++ private final String err;
++ private final int exitValue;
++ private final Throwable throwable;
++
++ public ProcessResults(String out,
++ String err,
++ int exitValue,
++ Throwable throwable) {
++ this.out = out;
++ this.err = err;
++ this.exitValue = exitValue;
++ this.throwable = throwable;
++ }
++
++ public String out() { return out; }
++ public String err() { return err; }
++ public int exitValue() { return exitValue; }
++ public Throwable throwable() { return throwable; }
++
++ public String toString() {
++ StringBuilder sb = new StringBuilder();
++ sb.append("<STDOUT>\n" + out() + "</STDOUT>\n")
++ .append("<STDERR>\n" + err() + "</STDERR>\n")
++ .append("exitValue = " + exitValue + "\n");
++ if (throwable != null)
++ sb.append(throwable.getStackTrace());
++ return sb.toString();
++ }
++ }
++
++ private static class StreamAccumulator extends Thread {
++ private final InputStream is;
++ private final StringBuilder sb = new StringBuilder();
++ private Throwable throwable = null;
++
++ public String result () throws Throwable {
++ if (throwable != null)
++ throw throwable;
++ return sb.toString();
++ }
++
++ StreamAccumulator (InputStream is) {
++ this.is = is;
++ }
++
++ public void run() {
++ try {
++ Reader r = new InputStreamReader(is);
++ char[] buf = new char[4096];
++ int n;
++ while ((n = r.read(buf)) > 0) {
++ sb.append(buf,0,n);
++ }
++ } catch (Throwable t) {
++ throwable = t;
++ } finally {
++ try { is.close(); }
++ catch (Throwable t) { throwable = t; }
++ }
++ }
++ }
++
++ private static ProcessResults run(Process p) {
++ Throwable throwable = null;
++ int exitValue = -1;
++ String out = "";
++ String err = "";
++
++ StreamAccumulator outAccumulator =
++ new StreamAccumulator(p.getInputStream());
++ StreamAccumulator errAccumulator =
++ new StreamAccumulator(p.getErrorStream());
++
+ try {
+- synchronized(lock) {
+- c++;
+- if (c == 2) lock.notify();
+- else lock.wait();
+- }
+- System.exit(1);
+- }
+- catch(Exception e) {
+- e.printStackTrace();
+- out.println("Test FAILED"); // Not expected
+- }
+- }
++ outAccumulator.start();
++ errAccumulator.start();
++
++ exitValue = p.waitFor();
++
++ outAccumulator.join();
++ errAccumulator.join();
++
++ out = outAccumulator.result();
++ err = errAccumulator.result();
++ } catch (Throwable t) {
++ throwable = t;
++ }
++
++ return new ProcessResults(out, err, exitValue, throwable);
++ }
++
++ //--------------------- Infrastructure ---------------------------
++ static volatile int passed = 0, failed = 0;
++ static void pass() {passed++;}
++ static void fail() {failed++; Thread.dumpStack();}
++ static void fail(String msg) {System.out.println(msg); fail();}
++ static void unexpected(Throwable t) {failed++; t.printStackTrace();}
++ static void check(boolean cond) {if (cond) pass(); else fail();}
++ static void check(boolean cond, String m) {if (cond) pass(); else fail(m);}
++ static void equal(Object x, Object y) {
++ if (x == null ? y == null : x.equals(y)) pass();
++ else fail(x + " not equal to " + y);}
++ public static void main(String[] args) throws Throwable {
++ try {realMain(args);} catch (Throwable t) {unexpected(t);}
++ System.out.printf("%nPassed = %d, failed = %d%n%n", passed, failed);
++ if (failed > 0) throw new AssertionError("Some tests failed");}
+ }
More information about the distro-pkg-dev
mailing list