/*

 * Copyright (c) 2003, 2004, 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     4959889

 * @summary Basic unit test of memory management testing:

 *          1) setCollectionUsageThreshold() and getCollectionUsageThreshold()

 *          2) test notification emitted for two different memory pools.

 *

 * @author  Mandy Chung

 *

 * @build CollectionUsageThreshold MemoryUtil

 * @run main/timeout=300 CollectionUsageThreshold

 */

import java.lang.management.*;

import java.util.*;

import javax.management.*;

import javax.management.openmbean.CompositeData;

public class CollectionUsageThreshold {

    private static MemoryMXBean mm = ManagementFactory.getMemoryMXBean();

    private static boolean trace = false;

    private static boolean testFailed = false;

    private static final int EXPECTED_NUM_POOLS = 2;

    private static final int NUM_GCS = 3;

    private static final int THRESHOLD = 10;

    private static Checker checker;

    private static int numGCs = 0;

    static class PoolRecord {

        private MemoryPoolMXBean pool;

        private int listenerInvoked = 0;

        private long notifCount = 0;

        PoolRecord(MemoryPoolMXBean p) {

            this.pool = p;

        }

        int getListenerInvokedCount() {

            return listenerInvoked;

        }

        long getNotifCount() {

            return notifCount;

        }

        MemoryPoolMXBean getPool() {

            return pool;

        }

        void addNotification(MemoryNotificationInfo minfo) {

            listenerInvoked++;

            notifCount = minfo.getCount();

        }

    }

    static class SensorListener implements NotificationListener {

        private int numNotifs = 0;

        public void handleNotification(Notification notif, Object handback) {

            String type = notif.getType();

            if (type.equals(MemoryNotificationInfo.MEMORY_THRESHOLD_EXCEEDED) ||

                type.equals(MemoryNotificationInfo.

                    MEMORY_COLLECTION_THRESHOLD_EXCEEDED)) {

                MemoryNotificationInfo minfo = MemoryNotificationInfo.

                    from((CompositeData) notif.getUserData());

                MemoryUtil.printMemoryNotificationInfo(minfo, type);

                PoolRecord pr = (PoolRecord) result.get(minfo.getPoolName());

                if (pr == null) {

                    throw new RuntimeException("Pool " + minfo.getPoolName() +

                        " is not selected");

                }

                if (type != MemoryNotificationInfo.

                        MEMORY_COLLECTION_THRESHOLD_EXCEEDED) {

                    throw new RuntimeException("Pool " + minfo.getPoolName() +

                        " got unexpected notification type: " +

                        type);

                }

                pr.addNotification(minfo);

                synchronized (this) {

                    numNotifs++;

                    if (numNotifs > 0 && (numNotifs % EXPECTED_NUM_POOLS) == 0) {

                        checker.goCheckResult();

                    }

                }

            }

        }

    }

    private static long newThreshold;

    public static void main(String args[]) throws Exception {

        if (args.length > 0 && args[0].equals("trace")) {

            trace = true;

        }

        if (trace) {

            MemoryUtil.printMemoryPools(pools);

            MemoryUtil.printMemoryManagers(managers);

        }

        // Find the Old generation which supports low memory detection

            MemoryUsage u = p.getUsage();

            if (p.isUsageThresholdSupported() && p.isCollectionUsageThresholdSupported()) {

                PoolRecord pr = new PoolRecord(p);

                result.put(p.getName(), pr);

                if (result.size() == EXPECTED_NUM_POOLS) {

                    break;

                }

            }

        }

        if (result.size() != EXPECTED_NUM_POOLS) {

            throw new RuntimeException("Unexpected number of selected pools");

        }

        }

        if (testFailed)

            throw new RuntimeException("TEST FAILED.");

        System.out.println("Test passed.");

    }

    private static void invokeGC() {

        System.out.println("Calling System.gc()");

        numGCs++;

        mm.gc();

        if (trace) {

                System.out.println("Usage after GC for: " + pr.getPool().getName());

                MemoryUtil.printMemoryUsage(pr.getPool().getUsage());

            }

        }

    }

    static class Checker extends Thread {

        private Object lock = new Object();

        private Object go = new Object();

        private boolean checkerReady = false;

        private int waiters = 0;

        private boolean readyToCheck = false;

        Checker(String name) {

            super(name);

        };

        public void run() {

            while (true) {

                synchronized (lock) {

                    checkerReady = true;

                    try {

                        lock.wait();

                    } catch (InterruptedException e) {

                        // ignore

                    }

                    checkResult();

                    checkerReady = false;

                }

            }

        }

        private void checkResult() {

                if (pr.getListenerInvokedCount() != numGCs) {

                    throw new RuntimeException("Listeners invoked count = " +

                         pr.getListenerInvokedCount() + " expected to be " +

                         numGCs);

                }

                if (pr.getNotifCount() != numGCs) {

                    throw new RuntimeException("Notif Count = " +

                         pr.getNotifCount() + " expected to be " +

                         numGCs);

                }

                long count = pr.getPool().getCollectionUsageThresholdCount();

                if (count != numGCs) {

                    throw new RuntimeException("CollectionUsageThresholdCount = " +

                         count + " expected to be " + numGCs);

                }

                if (!pr.getPool().isCollectionUsageThresholdExceeded()) {

                    throw new RuntimeException("isCollectionUsageThresholdExceeded" +

                         " expected to be true");

                }

            }

            synchronized (go) {

                // wait until the main thread is waiting for notification

                while (waiters == 0) {

                    try {

                        go.wait(50);

                    } catch (InterruptedException e) {

                        // ignore

                    }

                }

                System.out.println(Thread.currentThread().getName() +

                    " notifying main thread to continue - result checking finished");

                go.notify();

            }

        }

        public void goCheckResult() {

            System.out.println(Thread.currentThread().getName() +

                " notifying to check result");

            synchronized (lock) {

                while (!checkerReady) {

                    try {

                        lock.wait(50);

                    } catch (InterruptedException e) {

                        // ignore

                    }

                }

                lock.notify();

            }

        }

        public void waitForCheckResult() {

            System.out.println(Thread.currentThread().getName() +

                " waiting for result checking finishes");

            synchronized (go) {

                waiters++;

                try {

                    go.wait();

                } catch (InterruptedException e) {

                    // ignore

                }

                waiters--;

            }

        }

    }

}