Clover coverage report -
Coverage timestamp: Sat Jul 7 2007 16:41:13 CEST
Overview   Package   File
    FRAMES   NO FRAMES  
file stats: LOC: 347   Methods: 8
NCLOC: 165   Classes: 1
 
 Source file Conditionals Statements Methods TOTAL
AbstractParamsAssigner.java 71.1% 85.1% 100% 82.1%
coverage coverage
 1    /**
 2    * JTRunner is free software; you can redistribute it and/or modify it under the
 3    * terms of the GNU General Public License as published by the Free Software
 4    * Foundation; either version 2, or (at your option) any later version.
 5    */
 6   
 7    package jtr.assigner.impl;
 8   
 9    import java.lang.reflect.*;
 10    import java.util.*;
 11    import jtr.assigner.util.BeanUtilsExtension;
 12   
 13    import org.apache.commons.beanutils.*;
 14   
 15    import jtr.assigner.*;
 16    import jtr.config.*;
 17    import jtr.config.enterprise.EnterpriseConfig;
 18    import jtr.config.jms.JMSConfig;
 19    import jtr.config.ws.Binding;
 20    import jtr.config.ws.WebServiceConfig;
 21    import jtr.runners.*;
 22    import org.apache.log4j.Logger;
 23    import org.apache.log4j.spi.LoggerFactory;
 24   
 25    /**
 26    * This class is the base class for all the concrete
 27    * <code>IParamsAssigner</code> implementations. It provides all the basic
 28    * methods necessary for injecting the configuration parameters that can be
 29    * found in the <code>jtr.xml</code> configuration file into the concrete
 30    * <code>IRunner</code> implementation.
 31    *
 32    * @author Francesco Russo (frusso@dev.java.net)
 33    * @version 4.0
 34    * @since 1.0
 35    */
 36    abstract public class AbstractParamsAssigner implements IParamsAssigner {
 37   
 38    /**
 39    * This method reads all the JTR standard parameters and put them all into
 40    * an <code>HashMap</code>.<br>
 41    * The keys used within this <code>HashMap</code> are those specified as
 42    * constant fields into the <code>StdParameters</code> class.
 43    *
 44    * @param runnerConfig
 45    * RunnerConfig
 46    * @param params
 47    * ParametersMap
 48    * @throws MissingStdParameterException
 49    * @return HashMap
 50    * @see jtr.config.StdParameters
 51    */
 52  16062 public HashMap readStdParameters(RunnerConfig runnerConfig, ParametersMap params) throws MissingStdParameterException {
 53    // standard parameters are:
 54    // 1. sleepTime - a. could be RunnerConfig.sleepTime
 55    // b. could be the RunnerConfigParam having "name" sleepTime
 56    // 2. runs - a. could be RunnerConfig.runs
 57    // b. could be the RunnerConfigParam having "name" runs
 58    // 3. enterprise - a. could be TestConfig.enterprise
 59    // b. could be RunnerConfig.enterprise
 60    // c. could be the RunnerConfigParam having "name" enterprise
 61    // 4. jms - a. could be TestConfig.jms
 62    // b. could be RunnerConfig.jms
 63    // c. could be the RunnerConfigParam having "name" jms
 64    // 5. webservice - a. could be TestConfig.webservice
 65    // b. could be RunnerConfig.webservice
 66    // c. could be the RunnerConfigParam having "name" webservice
 67    // 6. binding - a. could be TestConfig.binding
 68    // b. could be RunnerConfig.binding
 69    // c. could be RunnerConfigParam.binding
 70   
 71  16064 HashMap map = new HashMap();
 72  16061 assignSleepTime(map, runnerConfig, params);
 73  16059 assignRuns(map, runnerConfig, params);
 74  16061 assignEnterpriseCfg(map, runnerConfig, params);
 75  16068 assignJmsCfg(map, runnerConfig, params);
 76  16068 assingBinding(map, runnerConfig, params);
 77  16068 assignWebservice(map, runnerConfig, params);
 78  16068 return map;
 79    }
 80   
 81    /**
 82    * This method loads into the provided <code>map</code> the
 83    * <code>BINDING</code> configuration to be assigned to the provided
 84    * runner implementation using <code>StdParameters.BINDING</code> as a
 85    * key.
 86    *
 87    * @param map
 88    * HashMap
 89    * @param runnerConfig
 90    * RunnerConfig
 91    * @param params
 92    * ParametersMap
 93    * @throws jtr.assigner.MissingStdParameterException
 94    */
 95  16068 protected void assingBinding(HashMap map, RunnerConfig runnerConfig, ParametersMap params) throws MissingStdParameterException {
 96  16068 logger.debug("Looking for " + StdParameters.BINDING + "...");
 97  16068 Binding binding = null;
 98  16068 if (params.containsKey(StdParameters.BINDING)) {
 99    // first let's check the runner parameters
 100  6006 binding = runnerConfig.getParent().getBindings().getBinding(params.getParameter(StdParameters.BINDING).getValue());
 101    } else {
 102    // otherwise let's check the RunnerConfig
 103  10062 if (runnerConfig.getBinding() != null) {
 104  8 binding = runnerConfig.getParent().getBindings().getBinding(runnerConfig.getBinding());
 105    } else {
 106    // otherwise it should have been specified globally in the
 107    // TestConfig
 108  10054 if (runnerConfig.getParent().getBinding() != null) {
 109  0 binding = runnerConfig.getParent().getBindings().getBinding(runnerConfig.getParent().getBinding());
 110    } else {
 111  10054 String msg = "Missing the " + StdParameters.BINDING + " standard parameter while examining runner " + runnerConfig + "with parameters map " + params;
 112  10054 logger.warn(msg);
 113    }
 114    }
 115    }
 116  16068 logger.debug(StdParameters.BINDING + " is: " + binding);
 117  16068 map.put(StdParameters.BINDING, binding);
 118    }
 119   
 120    /**
 121    * This method loads into the provided <code>map</code> the
 122    * <code>WEBSERVICE</code> configuration to be assigned to the provided
 123    * runner implementation using <code>StdParameters.WEBSERVICE</code> as a
 124    * key.
 125    *
 126    * @param map
 127    * HashMap
 128    * @param runnerConfig
 129    * RunnerConfig
 130    * @param params
 131    * ParametersMap
 132    * @throws jtr.assigner.MissingStdParameterException
 133    */
 134  16068 @SuppressWarnings("unchecked")
 135    protected void assignWebservice(HashMap map, RunnerConfig runnerConfig, ParametersMap params) throws MissingStdParameterException {
 136  16068 logger.debug("Looking for " + StdParameters.WEBSERVICE + "...");
 137  16068 WebServiceConfig cfg = null;
 138  16068 if (params.containsKey(StdParameters.WEBSERVICE)) {
 139    // first let's check the runner parameters
 140  0 cfg = runnerConfig.getParent().getWebserviceConfig(params.getParameter(StdParameters.WEBSERVICE).getValue());
 141    } else {
 142    // otherwise let's check the RunnerConfig
 143  16068 if (runnerConfig.getWebservice() != null) {
 144  0 cfg = runnerConfig.getParent().getWebserviceConfig(runnerConfig.getWebservice());
 145    } else {
 146    // otherwise it should have been specified globally in the
 147    // TestConfig
 148  16068 if (runnerConfig.getParent().getWebservice() != null) {
 149  0 cfg = runnerConfig.getParent().getWebserviceConfig(runnerConfig.getParent().getWebservice());
 150    } else {
 151  16068 String msg = "Missing the " + StdParameters.WEBSERVICE + " standard parameter while examining runner " + runnerConfig + "with parameters map " + params;
 152  16068 logger.warn(msg);
 153    }
 154    }
 155    }
 156  16068 logger.debug(StdParameters.WEBSERVICE + " is: " + cfg);
 157  16068 map.put(StdParameters.WEBSERVICE, cfg);
 158    }
 159   
 160    /**
 161    * This method loads into the provided <code>map</code> the
 162    * <code>SLEEP_TIME</code> value to be assigned to the provided runner
 163    * implementation using <code>StdParameters.SLEEP_TIME</code> as a key.
 164    *
 165    * @param map
 166    * HashMap
 167    * @param runnerConfig
 168    * RunnerConfig
 169    * @param params
 170    * ParametersMap
 171    * @throws MissingStdParameterException
 172    */
 173  16066 @SuppressWarnings("unchecked")
 174    protected void assignSleepTime(HashMap map, RunnerConfig runnerConfig, ParametersMap params) throws MissingStdParameterException {
 175  16062 long sleepTime = RunnerConfig.DEFAULT_SLEEP_TIME;
 176  16064 logger.debug("Looking for " + StdParameters.SLEEP_TIME + "...");
 177  16062 if (params.containsKey(StdParameters.SLEEP_TIME)) {
 178    // the runner parameters have priority
 179    // let's read the sleeptime from the parameters
 180  16062 sleepTime = new Long(params.getParameter(StdParameters.SLEEP_TIME).getValue()).longValue();
 181    } else {
 182    // otherwise it should have been specified within RunnerConfig...
 183  0 if (runnerConfig.getSleepTime() != RunnerConfig.DEFAULT_SLEEP_TIME) {
 184  0 sleepTime = runnerConfig.getSleepTime();
 185    } else {
 186  0 String msg = "Missing the " + StdParameters.SLEEP_TIME + " standard parameter while examining runner " + runnerConfig + "with parameters map " + params;
 187  0 MissingStdParameterException e = new MissingStdParameterException(msg, StdParameters.SLEEP_TIME);
 188  0 logger.fatal(msg, e);
 189  0 throw e;
 190    }
 191    }
 192  16056 logger.debug(StdParameters.SLEEP_TIME + " is " + sleepTime);
 193  16060 map.put(StdParameters.SLEEP_TIME, new Long(sleepTime));
 194    }
 195   
 196    /**
 197    * This method loads into the provided <code>map</code> the
 198    * <code>RUNS</code> value to be assigned to the provided runner
 199    * implementation using <code>StdParameters.RUN</code> as a key.
 200    *
 201    * @param map
 202    * HashMap
 203    * @param runnerConfig
 204    * RunnerConfig
 205    * @param params
 206    * ParametersMap
 207    */
 208  16066 @SuppressWarnings("unchecked")
 209    protected void assignRuns(HashMap map, RunnerConfig runnerConfig, ParametersMap params) {
 210  16066 int runs;
 211  16067 logger.debug("Looking for " + StdParameters.RUNS + "...");
 212  16068 if (params.containsKey(StdParameters.RUNS)) {
 213    // the parameters have greater priority
 214  0 runs = new Integer(params.getParameter(StdParameters.RUNS).getValue()).intValue();
 215    } else {
 216    // it should exist in RunnerConfig...
 217  16068 runs = runnerConfig.getRuns();
 218    }
 219  16060 logger.debug(StdParameters.RUNS + " is: " + runs);
 220  16060 map.put(StdParameters.RUNS, new Integer(runs));
 221    }
 222   
 223    /**
 224    * This method loads into the provided <code>map</code> the
 225    * <code>ENTERPRISE</code> configuration to be assigned to the provided
 226    * runner implementation using <code>StdParameters.ENTERPRISE</code> as a
 227    * key.
 228    *
 229    * @param map
 230    * HashMap
 231    * @param runnerConfig
 232    * RunnerConfig
 233    * @param params
 234    * ParametersMap
 235    * @throws MissingStdParameterException
 236    */
 237  16064 @SuppressWarnings("unchecked")
 238    protected void assignEnterpriseCfg(HashMap map, RunnerConfig runnerConfig, ParametersMap params) throws MissingStdParameterException {
 239  16064 logger.debug("Looking for " + StdParameters.ENTERPRISE + "...");
 240  16065 EnterpriseConfig enterpriseCfg = null;
 241  16066 if (params.containsKey(StdParameters.ENTERPRISE)) {
 242    // first let's check the runner parameters
 243  10 enterpriseCfg = runnerConfig.getParent().getEnterprise(params.getParameter(StdParameters.ENTERPRISE).getValue());
 244    } else {
 245    // otherwise let's check the RunnerConfig
 246  16057 if (runnerConfig.getEnterprise() != null) {
 247  10023 enterpriseCfg = runnerConfig.getParent().getEnterprise(runnerConfig.getEnterprise());
 248    } else {
 249    // otherwise it should have been specified globally in the
 250    // TestConfig
 251  6031 if (runnerConfig.getParent().getEnterprise() != null) {
 252  0 enterpriseCfg = runnerConfig.getParent().getEnterprise(runnerConfig.getParent().getEnterprise());
 253    } else {
 254  6034 String msg = "Missing the " + StdParameters.ENTERPRISE + " standard parameter while examining runner " + runnerConfig + "with parameters map " + params;
 255  6034 logger.warn(msg);
 256    }
 257    }
 258    }
 259  16064 logger.debug(StdParameters.ENTERPRISE + " is: " + enterpriseCfg);
 260  16068 map.put(StdParameters.ENTERPRISE, enterpriseCfg);
 261    }
 262   
 263    /**
 264    * This method loads into the provided <code>map</code> the
 265    * <code>JMS</code> configuration to be assigned to the provided runner
 266    * implementation using <code>StdParameters.JMS</code> as a key.
 267    *
 268    * @param map
 269    * HashMap
 270    * @param runnerConfig
 271    * RunnerConfig
 272    * @param params
 273    * ParametersMap
 274    * @throws MissingStdParameterException
 275    */
 276  16068 @SuppressWarnings("unchecked")
 277    protected void assignJmsCfg(HashMap map, RunnerConfig runnerConfig, ParametersMap params) throws MissingStdParameterException {
 278  16068 logger.debug("Looking for " + StdParameters.JMS + "...");
 279  16068 JMSConfig jmsCfg = null;
 280  16068 if (params.containsKey(StdParameters.JMS)) {
 281    // first let's check the runner parameters
 282  0 jmsCfg = runnerConfig.getParent().getJmsConfig(params.getParameter(StdParameters.JMS).getValue());
 283    } else {
 284    // otherwise let's check the RunnerConfig
 285  16068 if (runnerConfig.getJms() != null) {
 286  14 jmsCfg = runnerConfig.getParent().getJmsConfig(runnerConfig.getJms());
 287    } else {
 288    // otherwise it should have been specified globally in the
 289    // TestConfig
 290  16054 if (runnerConfig.getParent().getJms() != null) {
 291  0 jmsCfg = runnerConfig.getParent().getJmsConfig(runnerConfig.getParent().getJms());
 292    } else {
 293  16054 String msg = "Missing the " + StdParameters.JMS + " standard parameter while examining runner " + runnerConfig + "with parameters map " + params;
 294  16054 logger.warn(msg);
 295    }
 296    }
 297    }
 298  16068 logger.debug(StdParameters.JMS + " is: " + jmsCfg);
 299  16068 map.put(StdParameters.JMS, jmsCfg);
 300    }
 301   
 302    /**
 303    * This method assigns to the input <code>IRunnerClean</code> instance all
 304    * its configuration parameters specified in the <code>jtr.xml</code>
 305    * file.<br>
 306    * This parameters are stored into the <code>runnerConfig</code> and
 307    * <code>params</code> input parameters.
 308    *
 309    * @param cRunner
 310    * IRunnerClean
 311    * @param runnerConfig
 312    * RunnerConfig
 313    * @param params
 314    * ParametersMap
 315    * @param caller
 316    * IParamsAssigner
 317    */
 318  16067 protected void performStdAssignment(IRunnerClean cRunner, RunnerConfig runnerConfig, ParametersMap params, IParamsAssigner caller) {
 319  16067 HashMap stdParams = readStdParameters(runnerConfig, params);
 320  16068 cRunner.setEnterprise((EnterpriseConfig) stdParams.get(StdParameters.ENTERPRISE));
 321  16068 if (cRunner instanceof IRunnerJMS) {
 322  14 ((IRunnerJMS) cRunner).setJmsConfig((JMSConfig) stdParams.get(StdParameters.JMS));
 323    }
 324  16068 if (cRunner instanceof IRunnerWs) {
 325  6014 ((IRunnerWs) cRunner).setWsConfig((WebServiceConfig) stdParams.get(StdParameters.WEBSERVICE));
 326  6014 ((IRunnerWs) cRunner).setBinding((Binding) stdParams.get(StdParameters.BINDING));
 327    }
 328  16068 cRunner.setSleepTime(((Long) stdParams.get(StdParameters.SLEEP_TIME)).longValue());
 329  16068 cRunner.setRuns(((Integer) stdParams.get(StdParameters.RUNS)).intValue());
 330  16068 cRunner.setInstanceCount(runnerConfig.getCount());
 331  16068 cRunner.setParameters(params);
 332  16068 cRunner.setParamsAssigner(caller);
 333    // let's assign to the IRunner all the parameters assuming they are bean
 334    // properties
 335  16068 Iterator paramsIter = params.iterator();
 336  16068 while (paramsIter.hasNext()) {
 337  32186 RunnerConfigParam param = (RunnerConfigParam) paramsIter.next();
 338  32186 if(!StdParameters.isStandard(param)) {
 339  10102 logger.debug("Setting bean property " + param.getName() + " with value " + param.getValue() + "...");
 340  10102 BeanUtilsExtension.setProperty(cRunner, param.getName(), param.getValue());
 341  10102 logger.debug("...done");
 342    }
 343    }
 344    }
 345   
 346    private static Logger logger = Logger.getLogger(AbstractParamsAssigner.class);
 347    }
 
CloverReport generated by Clover Code Coverage v1.3.13
Sat Jul 7 2007 16:41:23 CEST.		   Open Source License registered to the JTR Java Test Runner Project. This license of Clover is provided to support the development of JTR Java Test Runner only.