Return-Path: X-Original-To: apmail-river-commits-archive@www.apache.org Delivered-To: apmail-river-commits-archive@www.apache.org Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by minotaur.apache.org (Postfix) with SMTP id ABE4DD7F7 for ; Tue, 5 Mar 2013 09:23:03 +0000 (UTC) Received: (qmail 29134 invoked by uid 500); 5 Mar 2013 09:23:03 -0000 Delivered-To: apmail-river-commits-archive@river.apache.org Received: (qmail 29075 invoked by uid 500); 5 Mar 2013 09:23:03 -0000 Mailing-List: contact commits-help@river.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@river.apache.org Delivered-To: mailing list commits@river.apache.org Received: (qmail 28881 invoked by uid 99); 5 Mar 2013 09:22:56 -0000 Received: from athena.apache.org (HELO athena.apache.org) (140.211.11.136) by apache.org (qpsmtpd/0.29) with ESMTP; Tue, 05 Mar 2013 09:22:56 +0000 X-ASF-Spam-Status: No, hits=-2000.0 required=5.0 tests=ALL_TRUSTED X-Spam-Check-By: apache.org Received: from [140.211.11.4] (HELO eris.apache.org) (140.211.11.4) by apache.org (qpsmtpd/0.29) with ESMTP; Tue, 05 Mar 2013 09:22:52 +0000 Received: from eris.apache.org (localhost [127.0.0.1]) by eris.apache.org (Postfix) with ESMTP id D9F0B2388A6C; Tue, 5 Mar 2013 09:22:32 +0000 (UTC) Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Subject: svn commit: r1452708 [2/7] - in /river/jtsk/skunk/qa_refactor/trunk/qa/src/com/sun/jini: qa/resources/ test/impl/fiddler/event/ test/share/ test/spec/discoveryservice/ test/spec/discoveryservice/event/ Date: Tue, 05 Mar 2013 09:22:31 -0000 To: commits@river.apache.org From: peter_firmstone@apache.org X-Mailer: svnmailer-1.0.8-patched Message-Id: <20130305092232.D9F0B2388A6C@eris.apache.org> X-Virus-Checked: Checked by ClamAV on apache.org Modified: river/jtsk/skunk/qa_refactor/trunk/qa/src/com/sun/jini/test/spec/discoveryservice/AbstractBaseTest.java URL: http://svn.apache.org/viewvc/river/jtsk/skunk/qa_refactor/trunk/qa/src/com/sun/jini/test/spec/discoveryservice/AbstractBaseTest.java?rev=1452708&r1=1452707&r2=1452708&view=diff ============================================================================== --- river/jtsk/skunk/qa_refactor/trunk/qa/src/com/sun/jini/test/spec/discoveryservice/AbstractBaseTest.java (original) +++ river/jtsk/skunk/qa_refactor/trunk/qa/src/com/sun/jini/test/spec/discoveryservice/AbstractBaseTest.java Tue Mar 5 09:22:30 2013 @@ -86,6 +86,9 @@ import net.jini.security.proxytrust.Serv import com.sun.jini.proxy.BasicProxyTrustVerifier; import com.sun.jini.qa.harness.Test; +import com.sun.jini.test.share.LookupServices; +import java.util.List; +import java.util.concurrent.ConcurrentHashMap; /** * This class is an abstract class that acts as the base class which @@ -110,38 +113,137 @@ import com.sun.jini.qa.harness.Test; */ abstract public class AbstractBaseTest extends QATestEnvironment implements Test { - protected boolean debugFlag = false;//resets timeouts for faster completion - protected boolean displayOn = false;//verbose in waitForDiscovery/Discard + protected volatile boolean debugFlag = false;//resets timeouts for faster completion + protected volatile boolean displayOn = false;//verbose in waitForDiscovery/Discard protected static final int FAST_TIMEOUT = 5; - protected static final int ACTIVE_DISCARDED = 0;//discard - protected static final int COMM_DISCARDED = 1;//terminate - protected static final int NO_INTEREST_DISCARDED = 2;//replace groups - protected static final int PASSIVE_DISCARDED = 3;//stop announcements + public static final int ACTIVE_DISCARDED = 0;//discard + public static final int COMM_DISCARDED = 1;//terminate + public static final int NO_INTEREST_DISCARDED = 2;//replace groups + public static final int PASSIVE_DISCARDED = 3;//stop announcements + + /** + * @return the genMap + */ + public Map getGenMap() { + return lookupServices.getGenMap(); + } + + /** + * @return the registrationMap + */ + public Map getRegistrationMap() { + return lookupServices.getRegistrationMap(); + } + + /** + * @return the announceInterval + */ + public int getAnnounceInterval() { + return lookupServices.getAnnounceInterval(); + } + + /** + * @return the minNAnnouncements + */ + public int getMinNAnnouncements() { + return lookupServices.getMinNAnnouncements(); + } + + /** + * @return the nIntervalsToWait + */ + public int getnIntervalsToWait() { + return lookupServices.getnIntervalsToWait(); + } + + /** + * @return the useGroupAndLocDiscovery0 + */ + public List getUseGroupAndLocDiscovery0() { + return lookupServices.getUseGroupAndLocDiscovery0(); + } + + /** + * @return the useGroupAndLocDiscovery1 + */ + public List getUseGroupAndLocDiscovery1() { + return lookupServices.getUseGroupAndLocDiscovery1(); + } + + /** + * @return the useOnlyGroupDiscovery + */ + public List getUseOnlyGroupDiscovery() { + return lookupServices.getUseOnlyGroupDiscovery(); + } + + /** + * @return the useOnlyLocDiscovery + */ + public List getUseOnlyLocDiscovery() { + return lookupServices.getUseOnlyLocDiscovery(); + } /** Ordered pair containing a ServiceRegistrar and its member groups */ - protected class RegGroupsPair { - ServiceRegistrar reg; - String[] groups; - RegGroupsPair(ServiceRegistrar reg, String[] groups) { + public static class RegGroupsPair { + private final ServiceRegistrar reg; + private final String[] groups; + + public RegGroupsPair(ServiceRegistrar reg, String[] groups) { this.reg = reg; - this.groups = groups; + this.groups = groups !=null ? groups.clone() : null; + } + + /** + * @return the reg + */ + ServiceRegistrar getReg() { + return reg; + } + + /** + * @return the groups + */ + String[] getGroups() { + return groups != null ? groups.clone() : null; } }//end class RegGroupsPair /** Data structure containing groups and/or locator to discover */ - protected class DiscoveryStruct { - String[] groups; // ALL_GROUPS or NO_GROUPS ==> empty "slot" - LookupLocator locator; // null ==> empty "slot" - RegGroupsPair regGroups; - DiscoveryStruct(String[] groups, - LookupLocator locator, - RegGroupsPair regGroups) { - this.groups = groups; + public static class DiscoveryStruct { + private final String[] groups; // ALL_GROUPS or NO_GROUPS ==> empty "slot" + private final LookupLocator locator; // null ==> empty "slot" + private final RegGroupsPair regGroups; + public DiscoveryStruct( String[] groups, + LookupLocator locator, + RegGroupsPair regGroups) { + this.groups = groups != null ? groups.clone() : null; this.locator = locator; this.regGroups = regGroups; } + + /** + * @return the groups + */ + String[] getGroups() { + return groups != null ? groups.clone() : null; + } + + /** + * @return the locator + */ + LookupLocator getLocator() { + return locator; + } + + /** + * @return the regGroups + */ + RegGroupsPair getRegGroups() { + return regGroups; + } }//end class DiscoveryStruct /** Tuple type for collecting and returning registrar information from @@ -151,43 +253,61 @@ abstract public class AbstractBaseTest e * all registrars. */ protected class RegTuple { - public ServiceRegistrar[] regs; - public MarshalledObject[] mRegs; - public Throwable[] exceptions; - public Map groupsMap; + private final ServiceRegistrar[] regs; + private final MarshalledObject[] mRegs; + private final Throwable[] exceptions; + private final Map groupsMap; RegTuple(ServiceRegistrar[] regs, MarshalledObject[] mRegs, Throwable[] exceptions, Map groupsMap) { - this.regs = regs; - this.mRegs = mRegs; - this.exceptions = exceptions; - this.groupsMap = groupsMap; + this.regs = regs.clone(); + this.mRegs = mRegs.clone(); + this.exceptions = exceptions.clone(); + this.groupsMap = new HashMap(groupsMap); + } + + /** + * @return the regs + */ + public ServiceRegistrar[] getRegs() { + return regs.clone(); + } + + /** + * @return the mRegs + */ + public MarshalledObject[] getmRegs() { + return mRegs.clone(); + } + + /** + * @return the exceptions + */ + public Throwable[] getExceptions() { + return exceptions.clone(); + } + + /** + * @return the groupsMap + */ + public Map getGroupsMap() { + return new HashMap(groupsMap); } }//end class RegTuple /** Data structure containing information about each registration */ - protected class RegistrationInfo { - public String[] groupsToDiscover; - public LookupLocator[] locatorsToDiscover; - public int handback = -1;//equivalent to null handback + public class RegistrationInfo { + private volatile String[] groupsToDiscover; + private volatile LookupLocator[] locatorsToDiscover; + private volatile int handback = -1;//equivalent to null handback - int expectedHandback; - - RegistrationInfo(String[] groupsToDiscover, - LookupLocator[] locatorsToDiscover, - int expectedHandback) - { - this.groupsToDiscover = groupsToDiscover; - this.locatorsToDiscover = locatorsToDiscover; - this.expectedHandback = expectedHandback; - initState(); - }//end constructor + private int expectedHandback; /* Modified by the listener as events are received */ - public HashMap discoveredMap = new HashMap(11); - public HashMap discardedMap = new HashMap(11); + private final HashMap discoveredMap; + private final HashMap discardedMap; /* Reflects current discovery/discard state for this regInfo. * Initialized to false. @@ -195,16 +315,40 @@ abstract public class AbstractBaseTest e * Should be re-set to false whenever the expected discovery or * expected discard events change (ex. because of a call to setGroups) */ - public boolean discoveryComplete = false; - public boolean discardComplete = false; + private volatile boolean discoveryComplete; + private volatile boolean discardComplete; /* holds current configuration for expected discoveries and discards */ - public HashMap expectedDiscoveredMap = new HashMap(11); + private final HashMap expectedDiscoveredMap; + + private final HashMap expectedActiveDiscardedMap; + private final HashMap expectedCommDiscardedMap; + private final Map expectedNoInterestDiscardedMap; + private final Map expectedPassiveDiscardedMap; + + + RegistrationInfo(String[] groupsToDiscover, + LookupLocator[] locatorsToDiscover, + int expectedHandback) + { + this.groupsToDiscover = groupsToDiscover; + this.locatorsToDiscover = locatorsToDiscover; + this.expectedHandback = expectedHandback; + discoveredMap = new HashMap(11); + discardedMap = new HashMap(11); + discoveryComplete = false; + discardComplete = false; + expectedDiscoveredMap = new HashMap(11); + expectedActiveDiscardedMap = new HashMap(11); + expectedCommDiscardedMap = new HashMap(11); + expectedNoInterestDiscardedMap = new ConcurrentHashMap(); + expectedPassiveDiscardedMap = new ConcurrentHashMap(11); + + initState(); + + }//end constructor - public HashMap expectedActiveDiscardedMap = new HashMap(11); - public HashMap expectedCommDiscardedMap = new HashMap(11); - public HashMap expectedNoInterestDiscardedMap = new HashMap(11); - public HashMap expectedPassiveDiscardedMap = new HashMap(11); + /** This method resets the state of each flag and set related to * discovery and discard events received for this regInfo. @@ -213,15 +357,15 @@ abstract public class AbstractBaseTest e synchronized(this) { discoveryComplete = false; discardComplete = false; - discoveredMap.clear(); - discardedMap.clear(); + getDiscoveredMap().clear(); + getDiscardedMap().clear(); - expectedDiscoveredMap.clear(); + getExpectedDiscoveredMap().clear(); - expectedActiveDiscardedMap.clear(); - expectedCommDiscardedMap.clear(); - expectedNoInterestDiscardedMap.clear(); - expectedPassiveDiscardedMap.clear(); + getExpectedActiveDiscardedMap().clear(); + getExpectedCommDiscardedMap().clear(); + getExpectedNoInterestDiscardedMap().clear(); + getExpectedPassiveDiscardedMap().clear(); }//end sync(this) }//end resetAllEventInfo @@ -231,8 +375,8 @@ abstract public class AbstractBaseTest e public void resetDiscoveryEventInfo() { synchronized(this) { discoveryComplete = false; - discoveredMap.clear(); - expectedDiscoveredMap.clear(); + getDiscoveredMap().clear(); + getExpectedDiscoveredMap().clear(); }//end sync(this) }//end resetDiscoveryEventInfo @@ -242,12 +386,12 @@ abstract public class AbstractBaseTest e public void resetDiscardEventInfo() { synchronized(this) { discardComplete = false; - discardedMap.clear(); + getDiscardedMap().clear(); - expectedActiveDiscardedMap.clear(); - expectedCommDiscardedMap.clear(); - expectedNoInterestDiscardedMap.clear(); - expectedPassiveDiscardedMap.clear(); + getExpectedActiveDiscardedMap().clear(); + getExpectedCommDiscardedMap().clear(); + getExpectedNoInterestDiscardedMap().clear(); + getExpectedPassiveDiscardedMap().clear(); }//end sync(this) }//end resetDiscardEventInfo @@ -257,13 +401,13 @@ abstract public class AbstractBaseTest e * and then re-sets the values of the fields in this class that * related to the expected discovery/discard state of this regInfo. */ - void setLookupsToDiscover(String[] groups, LookupLocator[] locators) { + public void setLookupsToDiscover(String[] groups, LookupLocator[] locators) { groupsToDiscover = groups; locatorsToDiscover = locators; discoveryComplete = false; discardComplete = false; - expectedNoInterestDiscardedMap.clear(); - expectedPassiveDiscardedMap.clear(); + getExpectedNoInterestDiscardedMap().clear(); + getExpectedPassiveDiscardedMap().clear(); synchronized(this) { /* If a registrar that's already been DISCOVERED belongs to * NONE of the groups to discover, and has a corresponding @@ -273,7 +417,7 @@ abstract public class AbstractBaseTest e * expectedNoInterestDiscardedMap and into the * expectedPassiveDiscardedMap. */ - Set eSet = discoveredMap.entrySet(); + Set eSet = getDiscoveredMap().entrySet(); Iterator iter = eSet.iterator(); while(iter.hasNext()) { Map.Entry pair = (Map.Entry)iter.next(); @@ -281,9 +425,9 @@ abstract public class AbstractBaseTest e String[] srvcRegGroups = (String[])pair.getValue(); boolean inSet = inToDiscoverSet(srvcReg,srvcRegGroups); if( inToDiscoverSet(srvcReg,srvcRegGroups) ) continue; - expectedDiscoveredMap.remove(srvcReg); - expectedNoInterestDiscardedMap.put(srvcReg,srvcRegGroups); - expectedPassiveDiscardedMap.put(srvcReg,srvcRegGroups); + getExpectedDiscoveredMap().remove(srvcReg); + getExpectedNoInterestDiscardedMap().put(srvcReg,srvcRegGroups); + getExpectedPassiveDiscardedMap().put(srvcReg,srvcRegGroups); }//end loop /* If one of the registrars that's already been DISCARDED * belongs to any of the groups to discover and/or has a @@ -291,17 +435,17 @@ abstract public class AbstractBaseTest e * discover, MOVE that registrar's corresponding element from * the discardedMap into the expectedDiscoveredMap. */ - eSet = discardedMap.entrySet(); + eSet = getDiscardedMap().entrySet(); iter = eSet.iterator(); while(iter.hasNext()) { Map.Entry pair = (Map.Entry)iter.next(); ServiceRegistrar srvcReg = (ServiceRegistrar)pair.getKey(); String[] srvcRegGroups = (String[])pair.getValue(); if( !inToDiscoverSet(srvcReg,srvcRegGroups) ) continue; - discardedMap.remove(srvcReg); - expectedNoInterestDiscardedMap.remove(srvcReg); - expectedPassiveDiscardedMap.remove(srvcReg); - expectedDiscoveredMap.put(srvcReg,srvcRegGroups); + getDiscardedMap().remove(srvcReg); + getExpectedNoInterestDiscardedMap().remove(srvcReg); + getExpectedPassiveDiscardedMap().remove(srvcReg); + getExpectedDiscoveredMap().put(srvcReg,srvcRegGroups); }//end loop }//end sync(this) /* If one of the groups or locs to discover corresponds to one @@ -311,7 +455,7 @@ abstract public class AbstractBaseTest e * those un-discovered lookups to the expectedDiscoveredMap. */ synchronized(lockObject) { - Iterator iter = genMap.keySet().iterator(); + Iterator iter = getGenMap().keySet().iterator(); while(iter.hasNext()) { Object curGen = iter.next(); ServiceRegistrar srvcReg = null; @@ -331,16 +475,16 @@ abstract public class AbstractBaseTest e continue; } }//endif - String[] srvcRegGroups = (String[])genMap.get(curGen); - if(groupsToDiscover==DiscoveryGroupManagement.ALL_GROUPS){ - expectedDiscoveredMap.put(srvcReg,srvcRegGroups); + String[] srvcRegGroups = (String[])getGenMap().get(curGen); + if(getGroupsToDiscover()==DiscoveryGroupManagement.ALL_GROUPS){ + getExpectedDiscoveredMap().put(srvcReg,srvcRegGroups); } else {//(groupsToDiscover != ALL_GROUPS boolean moveToExpected = false; iLoop: for(int i=0;i 0) { + if(getGenMap().size() > 0) { /* Stop announcements if the generator is simulated, but allow * the super class' tearDown method to actually destroy the * lookup services (simulated or non-simulated). */ if( !announcementsStopped ) { - Iterator iter = genMap.keySet().iterator(); + Iterator iter = getGenMap().keySet().iterator(); for(int i=0;iter.hasNext();i++) { Object generator = iter.next(); if(generator instanceof DiscoveryProtocolSimulator) { @@ -887,132 +1066,6 @@ abstract public class AbstractBaseTest e } }//end tearDown - /** Method that compares the given port to the ports of all the locators - * referenced in the set of elements that correspond to lookup services - * that have been started. Returns true if the given port - * equals any of the ports referenced in the set; false - * otherwise. Useful for guaranteeing unique port numbers when starting - * lookup serives. - */ - protected boolean portInUse(int port) { - for(int i=0;i 0) {//explicit ports were set in config - if(!collectionsEqual(lookupsToStart,locatorsStarted)) { - throw new TestException("locators started != locators " - +"wanted"); - - }//endif - }//endif - nStarted = genMap.size(); - }//end startAllLookups - - /** Convenience method that can be used to start, at any point during the - * current test run, a single lookup service with configuration - * referenced by the given parameter values. Useful when individual - * lookup services are to be started at different points in time during - * the test run. - */ - protected void startLookup(int indx, int port, String serviceHost) - throws Exception - { - logger.log(Level.FINE, "starting lookup service "+indx); - /* retrieve the member groups with which to configure the lookup */ - String[] memberGroups = (String[])memberGroupsList.get(indx); - ServiceRegistrar lookupProxy = null; - if(implClassname.equals("com.sun.jini.test.services.lookupsimulator.LookupSimulatorImpl")) - { - /* Use either a random or an explicit locator port */ - DiscoveryProtocolSimulator generator = - new DiscoveryProtocolSimulator(getConfig(), memberGroups, getManager(), port); - genMap.put( generator, memberGroups ); - lookupProxy = generator.getLookupProxy(); - } else {//start a non-simulated lookup service implementation - logger.log(Level.FINER, "Starting lookup for host " + serviceHost); - lookupProxy = getManager().startLookupService(serviceHost); // already prepared - genMap.put( lookupProxy, memberGroups ); - }//endif - lookupList.add( lookupProxy ); - LookupLocator lookupLocator = QAConfig.getConstrainedLocator(lookupProxy.getLocator()); - locatorsStarted.add(lookupLocator); - LocatorsUtil.displayLocator(lookupLocator, - " locator ",Level.FINE); - String displayGroups = GroupsUtil.toCommaSeparatedStr(memberGroups); - if(displayGroups.equals("")) displayGroups = new String("NO_GROUPS"); - logger.log(Level.FINE, " group(s) = " - +displayGroups); - /* Because the lookup discovery service can perform both group and - * locator discovery, some tests will focus only on group - * discovery, some only on locator discovery, and some on both - * group and locator discovery. To provide these tests with - * a variety of options for the groups and/or locators to discover, - * a number of data structures are populated below which the - * tests can use to configure the lookup discovery service for - * discovery. In some cases, only the member groups from above - * are stored, in other cases only the locators are stored, and - * in still other cases, a mix of groups and locators are stored. - * The case where the groups and locators are mixed is intended - * to provide tests that verify the lookup discovery service's - * ability to handle both group and locator discovery with a - * set that can be used to configure the lookup discovery service - * to discover some registrars through only group discovery, - * some registrars through only locator discovery, and some - * registrars through both group and locator discovery. - */ - if( (indx%3) == 0 ) {// add both groups and locs - useGroupAndLocDiscovery0.add - (new DiscoveryStruct(memberGroups,lookupLocator, - new RegGroupsPair(lookupProxy,memberGroups))); - useGroupAndLocDiscovery1.add - (new DiscoveryStruct(memberGroups,null, - new RegGroupsPair(lookupProxy,memberGroups))); - } else if( (indx%3) == 1 ) {// add only the groups - useGroupAndLocDiscovery0.add - (new DiscoveryStruct(memberGroups,null, - new RegGroupsPair(lookupProxy,memberGroups))); - useGroupAndLocDiscovery1.add(new DiscoveryStruct - (memberGroups,null, - new RegGroupsPair(lookupProxy,memberGroups))); - } else if( (indx%3) == 2 ) {// add only the locators - useGroupAndLocDiscovery0.add - (new DiscoveryStruct(null,lookupLocator, - new RegGroupsPair(lookupProxy,memberGroups))); - useGroupAndLocDiscovery1.add(new DiscoveryStruct - (memberGroups,lookupLocator, - new RegGroupsPair(lookupProxy,memberGroups))); - }//endif - useOnlyGroupDiscovery.add - (new DiscoveryStruct(memberGroups,null, - new RegGroupsPair(lookupProxy,memberGroups))); - useOnlyLocDiscovery.add - (new DiscoveryStruct(null,lookupLocator, - new RegGroupsPair(lookupProxy,memberGroups))); - }//end startLookup - /** Returns true if the given collections are referentially * equal, or if the given collections have the same contents; * false otherwise. @@ -1032,10 +1085,10 @@ abstract public class AbstractBaseTest e * String[] array containing the groups that should be used to configure * the lookup discovery service for group discovery. */ - protected String[] getGroupsToDiscover(ArrayList useList) { + protected String[] getGroupsToDiscover(List useList) { ArrayList groupsList = new ArrayList(); for(int i=0;i0)) { RegGroupsPair pair = - ((DiscoveryStruct)(useList.get(i))).regGroups; - discardMap.put(pair.reg,pair.groups); + ((DiscoveryStruct)(useList.get(i))).getRegGroups(); + discardMap.put(pair.getReg(), pair.getGroups()); } } return discardMap; @@ -1138,29 +1191,29 @@ abstract public class AbstractBaseTest e protected Map getActiveCommDiscardMap(ArrayList useList) { HashMap discardMap = new HashMap(); for(int i=0;i 0) ) || (loc != null) ) { RegGroupsPair pair = - ((DiscoveryStruct)(useList.get(i))).regGroups; - discardMap.put(pair.reg,pair.groups); + ((DiscoveryStruct)(useList.get(i))).getRegGroups(); + discardMap.put(pair.getReg(), pair.getGroups()); } } return discardMap; }//end getActiveCommDiscardMap /** Return any elements having at least a locators entry */ - protected Map getModLocatorsDiscardMap(ArrayList useList) { + protected Map getModLocatorsDiscardMap(List useList) { HashMap discardMap = new HashMap(); for(int i=0;i