rottest.java

java 与COM组件的连接桥

package com.jacob.com;
import com.jacob.com.ROT;
/**
 * This trys to exercise ROT's garbage collecion
 * 
 * This will eventually be changed to a unit test.
 * <p>
 * May need to run with some command line options (including from inside Eclipse).  
 * If so, then try these
 * <pre>
 *      -Djava.library.path=d:/jacob/release/x86 
 *      -Dcom.jacob.autogc=false 
 *      -Dcom.jacob.debug=false 
 *      -Xcheck:jni
 *  </pre>
 */
public class ROTTest {

    public static void main(String args[]) throws Exception
    {
    	ROTTest testJig = new ROTTest();
    	testJig.testDontFillROTSystemProperty();
    	testJig.testGCBehavior();
    }
    
    /**
     * verify the SystemProperty (classname).PutInROT functions as expected.
     * A value of false means instances of the class are not put in the ROT
     * Any o ther value means they are
     */
    public void testDontFillROTSystemProperty(){
    	debug("testDontFillROTSystemProperty: started");
    	// Make sure the class is loaded before running any of the tests 
    	// class to load and any pre-defined Variants (FALSE and TRUE) to be created immediately
    	VariantViaEvent.class.getName();
    	if (ROT.getThreadObjects(true).entrySet().size() < 1){
    		debug("Failure: ROT should have objects in it as soon as Variant class loaded.");
    	}

    	System.setProperty(VariantViaEvent.class.getName()+ROT.PUT_IN_ROT_SUFFIX,"false");
    	int countPriorToTest = ROT.getThreadObjects(true).entrySet().size();
    	new VariantViaEvent();
    	int countAfterAddWithoutROT = ROT.getThreadObjects(true).entrySet().size();
    	if (countAfterAddWithoutROT != countPriorToTest){
    		debug("Failure: count prior: "+countPriorToTest+
    				" and count after without ROT was: "+countAfterAddWithoutROT);
    	}
    	
    	System.setProperty(VariantViaEvent.class.getName()+ROT.PUT_IN_ROT_SUFFIX,"true");
    	new VariantViaEvent();
    	int countAfterAddWithROT = ROT.getThreadObjects(true).entrySet().size();    	
    	if (countAfterAddWithROT != (countPriorToTest+1)){
    		debug("Failure: count prior: "+countPriorToTest+
    				" and count after with ROT was: "+countAfterAddWithROT);
    	}
    	debug("testDontFillROTSystemProperty: completed");
    }

    /**
     * Needs documentation.  This test looks broken
     *
     */
    public void testGCBehavior(){
        int sizeBeforeBuild = 0;
    	int sizeAfterBuild = 0;
        int sizeBeforeGC = 0;
        int sizeAfterGC = 0;
        int loopSize = 10000;
        int sizeExpectedAfterBuild = 0;

        
        debug("testGCBehavior: started");
        debug("creating 10,000 object sets");
        // cause classes to get loaded and any static instances to be created
        SafeArray.class.getName();
        Variant.class.getName();
        sizeBeforeBuild = ROT.getThreadObjects(false).size();
        sizeExpectedAfterBuild = ((loopSize*3)+sizeBeforeBuild);
        for ( int i = 0 ; i < loopSize; i++){
            SafeArray a1 = new SafeArray(Variant.VariantVariant, 2);
            a1.setVariant(0, new Variant("foo"));
            a1.setVariant(1, new Variant("bar"));
        }
        sizeAfterBuild = ROT.getThreadObjects(false).size();
        if (sizeAfterBuild < sizeExpectedAfterBuild){
            debug("Something got GC'd: "+sizeAfterBuild);
        } else if (sizeAfterBuild > sizeExpectedAfterBuild){
            debug("More: "+sizeAfterBuild+" than expected: "+sizeExpectedAfterBuild);
        } else {
            debug("They're all there");
        }
        // add more to the VM
        debug("Flooding Memory to force GC");
        for ( int i = 0 ; i <= loopSize*2; i++){
            new String("this is just some text to see if we can force gc "+i);
        }
        // storage will hold weak references until the next JacobObject is created
        System.gc();
        sizeBeforeGC = ROT.getThreadObjects(false).size();
        debug("Objects left after flood and gc but before adding a new object that clean's up weak references: "+sizeBeforeGC);
        debug("Creating single object.  This adds one and causes ROT to clean up GC'd");
        new JacobObject();
        sizeAfterGC = ROT.getThreadObjects(false).size();
        debug("Objects left after adding one (caused weak ref objects to be removed): "+sizeAfterGC);
        new JacobObject();
        if (ROT.getThreadObjects(false).size() != sizeAfterGC+1){
            debug("Unexpected number of objects after adding only one more "+ROT.getThreadObjects(false).size());
        } else {
            debug("Found number expected after adding one more " +(sizeAfterGC+1) );
        }
        ROT.clearObjects();
        if (ROT.getThreadObjects(false) == null){
            debug("ROT pool was destroyed as expected after clearObjects called.");
        } else {
            debug("ROT pool for thread still exists when it shouldn't");
        }
        
        //========= part two ================================
        debug("Verifying doesn't blow up with double release");
        for ( int i = 0 ; i <= 10000; i++){
            new JacobObject();
        }
        // force safeRelease call on all objects
        ROT.clearObjects();
        // now force the gc to go collect them, running safeRelease again
        System.gc();
        debug("testGCBehavior: finished");
    }
    
    private static void debug(String message){
        System.out.println(Thread.currentThread().getName()+" "+message);
    }
}