FULL PRODUCT VERSION :
build 1.6.0_11-b03
running through eclipse

ADDITIONAL OS VERSION INFORMATION :
Windows XP

EXTRA RELEVANT SYSTEM CONFIGURATION :
Running through eclipse

A DESCRIPTION OF THE PROBLEM :
according to the Java Doc
http://download.java.net/jdk7/docs/api/java/lang/management/GarbageCollectorMXBean.html

(I assume 1.6 is the same)
getCollectionCount()

Returns the total number of collections that have occurred. This method returns -1 if the collection count is undefined for this collector.

However I am finding that it must be returning a number of times the garbage collector was called. Since I am using this code to write junit tests that assert memory usage and the memory usage is showing up as greater at .the start of the test than the end of the test.

STEPS TO FOLLOW TO REPRODUCE THE PROBLEM :
down load the i_util, i_util_tests and j2se_util project from cvs.adligo.org
http://cvs.adligo.org/viewvc

(will be unavailable for a few days apparently)

Run the i_util_tests suite and see output like;


start org.adligo.i.log.client.ArrayCollectionTests;testAddRemoveAndClear
mxbean 2 Copy 8 true
mxbean 0 MarkSweepCompact 0 true
Set inital gcs to 3
calling gc suggestion
calling gc suggestion
calling gc suggestion
calling gc suggestion
mxbean 2 Copy 8 true
mxbean 4 MarkSweepCompact 112 true
total memory is 5177344 and free 4643800 returning 533544 in org.adligo.i.log.client.ArrayCollectionTests;testAddRemoveAndClear
mxbean 2 Copy 8 true
mxbean 4 MarkSweepCompact 112 true
calling gc suggestion
mxbean 2 Copy 8 true
mxbean 5 MarkSweepCompact 148 true
total memory is 5177344 and free 4640640 returning 536704 in org.adligo.i.log.client.ArrayCollectionTests;testAddRemoveAndClear
used memory is 3160 (end-start) end 536704, start 533544 in org.adligo.i.log.client.ArrayCollectionTests;testAddRemoveAndClear
mxbean 2 Copy 8 true
mxbean 5 MarkSweepCompact 148 true
calling gc suggestion
mxbean 2 Copy 8 true
mxbean 6 MarkSweepCompact 176 true
total memory is 5177344 and free 4640088 returning 537256 in org.adligo.i.log.client.ArrayCollectionTests;testAddRemoveAndClear
used memory is 3712 (end-start) end 537256, start 533544 in org.adligo.i.log.client.ArrayCollectionTests;testAddRemoveAndClear
start org.adligo.i.log.client.ArrayCollectionTests;testMemory
mxbean 2 Copy 8 true
mxbean 6 MarkSweepCompact 176 true
calling gc suggestion
mxbean 2 Copy 8 true
mxbean 7 MarkSweepCompact 209 true
total memory is 5177344 and free 4639592 returning 537752 in org.adligo.i.log.client.ArrayCollectionTests;testMemory
mxbean 2 Copy 8 true
mxbean 7 MarkSweepCompact 209 true
calling gc suggestion
mxbean 2 Copy 8 true
mxbean 8 MarkSweepCompact 232 true
total memory is 5177344 and free 4643512 returning 533832 in org.adligo.i.log.client.ArrayCollectionTests;testMemory
used memory is -3920 (end-start) end 533832, start 537752 in org.adligo.i.log.client.ArrayCollectionTests;testMemory

Most of this output comes from the following class;

package org.adligo.i.log.client;

import java.lang.management.ManagementFactory;
import java.lang.management.GarbageCollectorMXBean;

import java.util.Iterator;
import java.util.List;

import junit.framework.TestCase;

public class GCTracker {
private static long gcs = 0;
private static Long inital_gcs;
private static boolean log = true;

private Long start;
private Long end;
private String name = "";


public GCTracker(Class clazz, String p_test_name) {
name = clazz.getName() + ";" + p_test_name;
if (log) {
System.out.println("start " + name);
}
start = getMemoryUse();
TestCase.assertTrue("Total memory used sould always be above 0 ", start >= 0);
}


public void assertUse(long threshold) {
end = getMemoryUse();
long used = end - start;
if (log) {
System.out.println("used memory is " + used + " (end-start) end " + end +
", start " + start + " in " + name);
}
TestCase.assertTrue("Total memory used sould always be above 0 ", used >= 0);

TestCase.assertTrue("The ArrayCollection should take up less than " +
threshold + " memeory and it took " + used +
" in "+ name, threshold > used);
}

public long getMemoryUse(){
forceGc();

long totalMemory = Runtime.getRuntime().totalMemory();

long freeMemory = Runtime.getRuntime().freeMemory();
long toRet = (totalMemory - freeMemory);
if (log) {
System.out.println("total memory is " + totalMemory + " and free "
+ freeMemory + " returning " + toRet + " in " + name);
}
return toRet;
 }


/**
* this calls the garbage collector in a synchronus way so that
* it waits to return until the garbage collector has actully completed
*
* this assumes your using regular jvm settings
* what ever those are
*
* what i mean to say is no special garbage collection arguments
*
*/
public static synchronized void forceGc() {
long total_gcs = getTotalGcs();
if (inital_gcs == null) {
inital_gcs = total_gcs + 1;
if (log) {
System.out.println("Set inital gcs to " + inital_gcs);
}
}
if (gcs <= inital_gcs) {
while (gcs <= inital_gcs) {
callGc();
}
total_gcs = getTotalGcs();
while (gcs < total_gcs) {
try {
Thread.sleep(20);
System.out.println("waiting for garbage collector to run for memory assertions " +
total_gcs);
} catch (Exception x) {
x.printStackTrace();
}
total_gcs = getTotalGcs();
}
} else {
callGc();
total_gcs = getTotalGcs();

while (gcs < total_gcs) {
try {
Thread.sleep(20);
System.out.println("waiting for garbage collector to run for memory assertions " +
total_gcs);
} catch (Exception x) {
x.printStackTrace();
}
total_gcs = getTotalGcs();
}
}
}


private static void callGc() {
if (log) {
System.out.println("calling gc suggestion");
}
Runtime.getRuntime().gc();
Runtime.getRuntime().runFinalization();
gcs++;
}


public static long getTotalGcs() {
List<GarbageCollectorMXBean> gcs = ManagementFactory.getGarbageCollectorMXBeans();
Iterator<GarbageCollectorMXBean> it = gcs.iterator();
long maxCollections = 0;

while (it.hasNext()) {
GarbageCollectorMXBean bean = it.next();
if (log) {
System.out.println("mxbean " + bean.getCollectionCount() +
" " + bean.getName() + " " + bean.getCollectionTime() + " " +
bean.isValid());
}
long current = bean.getCollectionCount();
if (maxCollections < current) {
maxCollections = current;
}
}
return maxCollections;
}

public static boolean isLog() {
return log;
}


public static void setLog(boolean log) {
GCTracker.log = log;
}


}


This code should force a syncronus call to garbage collection so that garbage collection completes before the memory is compaired. The starting memory should always be less than the ending memory since the usage of this class is something like;

public void testMemory() {
GCTracker memTracker = new GCTracker(ArrayCollectionTests.class,
"testMemory");
ArrayCollection collection = new ArrayCollection();
collection = null;
//size of memTracker object...
memTracker.assertUse(20);

}


EXPECTED VERSUS ACTUAL BEHAVIOR :
EXPECTED -
The assertion about memory usage being greater or equal to zero should always be true, and so should never cause a unit test failure.
ACTUAL -
The junit assertion shows negative memory usage which is not possible.

ERROR MESSAGES/STACK TRACES THAT OCCUR :
See steps to reproduce.

REPRODUCIBILITY :
This bug can be reproduced often.

---------- BEGIN SOURCE ----------
Please see steps to reproduce use the GCTracker class in any test case.
---------- END SOURCE ----------