--- 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-03 Pavel Tisnovsky <ptisnovs@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@redhat.com>
 
 	* plugin/tests/LiveConnect/PluginTest.java

--- 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 @@
 	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 += \

--- /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");}
+ }