/*
 * Copyright (c) 2010, 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 Test6581734.java
 * @bug 6581734
 * @summary CMS Old Gen's collection usage is zero after GC which is incorrect
 * @run main/othervm -server -Xmx512m -verbose:gc -XX:+UseConcMarkSweepGC Test6581734
 *
 */
import java.util.*;
import java.lang.management.*;

// 6581734 states that memory pool usage via the mbean is wrong
// for CMS (zero, even after a collection).
//
// 6580448 states that the collection count similarly is wrong
// (stays at zero for CMS collections)
// -- closed as dup of 6581734 as the same fix resolves both.


public class Test6581734 {

private String poolName = "CMS";
private String collectorName = "ConcurrentMarkSweep";

public static void main(String [] args) {

	Test6581734 t = null;
        if (args.length==2) {
            t = new Test6581734(args[0], args[1]);
        } else {
            System.out.println("Defaulting to monitor CMS pool and collector.");
            t = new Test6581734();
        }
	t.run();

}

public Test6581734(String pool, String collector) {
    poolName = pool;
    collectorName = collector;
}
public Test6581734() {
}

public void run() {

        // Use some memory, enough that we expect collections should
        // have happened.
        // Must run with options to ensure no stop the world full GC, 
        // but e.g. at least one CMS cycle.

        allocationWork(300*1024*1024);
        System.out.println("Done allocationWork");

        // Verify some non-zero results are stored.

		List<MemoryPoolMXBean> pools = 
		    ManagementFactory.getMemoryPoolMXBeans();
                int poolsFound = 0;
                int poolsWithStats = 0;
		for (int i=0; i<pools.size(); i++) {
		    MemoryPoolMXBean pool = pools.get(i);
		    String name = pool.getName();
                    System.out.println("found pool: " + name);

		    if (name.contains(poolName)) {
		        long usage = pool.getCollectionUsage().getUsed();
			System.out.println(name + ": usage after GC = " + usage);
			poolsFound++;
			if (usage > 0) {
			    poolsWithStats++;
                        }
		    }
		}	
		if (poolsFound == 0) {
		    throw new RuntimeException(
                        "No matching memory pools found: test with -XX:+UseConcMarkSweepGC");
		} 

                List<GarbageCollectorMXBean> collectors =
                    ManagementFactory.getGarbageCollectorMXBeans();
                int collectorsFound = 0;
                int collectorsWithTime= 0;
                for (int i=0; i<collectors.size(); i++) {
                    GarbageCollectorMXBean collector = collectors.get(i);
                    String name = collector.getName();
                    System.out.println("found collector: " + name);
                    if (name.contains(collectorName)) {
                        collectorsFound++;
                        
                        System.out.println(name + ": collection count = " 
                            + collector.getCollectionCount());
                        System.out.println(name + ": collection time  = " 
                            + collector.getCollectionTime());
                        if (collector.getCollectionCount() <= 0) {
                          throw new RuntimeException("collection count <= 0");
                        }
                        if (collector.getCollectionTime() > 0) {
                           collectorsWithTime++;
                        }
                    }
                }
        // verify:
        if (poolsWithStats < poolsFound) {
          throw new RuntimeException("pools found with zero stats");
        } 
        
        if (collectorsWithTime<collectorsFound) {
          throw new RuntimeException("collectors found with zero time");

        }

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


    public void allocationWork(long target) {

        long sizeAllocated = 0;
	List list = new LinkedList();
	long delay = 50;
        long count = 0;

        while (sizeAllocated < target) {
            int size = 1024*1024;

            byte [] alloc = new byte[size];
            if (count % 2 == 0) {
                list.add(alloc);
                sizeAllocated+=size;
                System.out.print(".");
                //System.out.println("allocated = " + sizeAllocated + " target = " + target);
            }

            try { Thread.sleep(delay); } catch (InterruptedException ie) { }
            count++;
        }
    }



}