/*

 * 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.

 */

/*

 * This file is available under and governed by the GNU General Public

 * License version 2 only, as published by the Free Software Foundation.

 * However, the following notice accompanied the original version of this

 * file:

 *

 * Written by Doug Lea and Martin Buchholz with assistance from

 * members of JCP JSR-166 Expert Group and released to the public

 * domain, as explained at

 * http://creativecommons.org/publicdomain/zero/1.0/

 */

/*

 * @test

 * @modules java.base/java.util.concurrent:open

 * @summary Checks that ForkJoinTask thrown exceptions are not leaked.

 * This whitebox test is sensitive to forkjoin implementation details.

 */

import static java.util.concurrent.TimeUnit.MILLISECONDS;

import java.lang.ref.ReferenceQueue;

import java.lang.ref.WeakReference;

import java.util.ArrayList;

import java.util.concurrent.CountDownLatch;

import java.util.concurrent.ForkJoinPool;

import java.util.concurrent.ForkJoinTask;

import java.util.concurrent.RecursiveAction;

import java.util.function.BooleanSupplier;

public class FJExceptionTableLeak {

    static class FailingTaskException extends RuntimeException {}

    static class FailingTask extends RecursiveAction {

        public void compute() { throw new FailingTaskException(); }

    }

    }

        // Clear all other strong refs, making exception table cleanable

        BooleanSupplier exceptionTableIsClean = () -> {

            try {

                lastTask.join();

                throw new AssertionError("should throw");

            } catch (FailingTaskException expected) {}

            if (count == 0)

                throw new AssertionError("expected to find last task");

            return count == 1;

        };

        gcAwait(exceptionTableIsClean);

    }

    // --------------- GC finalization infrastructure ---------------

    /** No guarantees, but effective in practice. */

    static void forceFullGc() {

        long timeoutMillis = 1000L;

        CountDownLatch finalized = new CountDownLatch(1);

        ReferenceQueue<Object> queue = new ReferenceQueue<>();

        WeakReference<Object> ref = new WeakReference<>(

            new Object() { protected void finalize() { finalized.countDown(); }},

            queue);

        try {

            for (int tries = 3; tries--> 0; ) {

                System.gc();

                if (finalized.await(timeoutMillis, MILLISECONDS)

                    && queue.remove(timeoutMillis) != null

                    && ref.get() == null) {

                    System.runFinalization(); // try to pick up stragglers

                    return;

                }

                timeoutMillis *= 4;

            }

        } catch (InterruptedException unexpected) {

            throw new AssertionError("unexpected InterruptedException");

        }

        throw new AssertionError("failed to do a \"full\" gc");

    }

    static void gcAwait(BooleanSupplier s) {

        for (int i = 0; i < 10; i++) {

            if (s.getAsBoolean())

                return;

            forceFullGc();

        }

        throw new AssertionError("failed to satisfy condition");

    }

}