Java Config.getInstance方法代码示例

import gov.nasa.jpf.Config; //导入方法依赖的package包/类
public HeuristicListener(Config jpfConf, JPF jpf) {
  super(jpfConf, jpf);
  policiesEnabled = jpfConf.getBoolean(WorstCaseAnalyzer.ENABLE_POLICIES, WorstCaseAnalyzer.ENABLE_POLICIES_DEF);

  if (policiesEnabled) {
    PolicyManager policyManager = new PolicyManager(new File(getSerializedInputDir(jpfConf)));

    try {
      this.heuristicPolicy = policyManager.loadPolicy(measuredMethods, Policy.class);
    } catch (IOException | PolicyManagerException e) {
      logger.severe(e.getMessage());
      throw new RuntimeException(e);
    }
  }

  // Set termination strategy
  this.terminationStrategy = jpfConf.getInstance(TERMINATION_STRATEGY_CONF,
      TerminationStrategy.class, DEFAULT_TERMINATION_STRATEGY);
}
 

import gov.nasa.jpf.Config; //导入方法依赖的package包/类
protected void addToFieldWatchList (Config conf, String id){
  String keyPrefix = "perturb." + id;

  String fs = conf.getString(keyPrefix + ".field");
  if (fs != null) {
    FieldSpec fieldSpec = FieldSpec.createFieldSpec(fs);
    if (fieldSpec != null){
      Object[] args = {conf, keyPrefix};
      OperandPerturbator perturbator = conf.getInstance(keyPrefix + ".class", OperandPerturbator.class, argTypes, args);
      if (perturbator != null) {
        String loc = conf.getString(keyPrefix + ".location");
        FieldPerturbation p = new FieldPerturbation(fieldSpec, perturbator, loc);
        fieldWatchList.add(p);
      } else {
        log.warning("invalid perturbator spec for ", keyPrefix);
      }
    } else {
      log.warning("malformed field specification for ", keyPrefix);
    }

  } else {
    log.warning("missing field specification for ", keyPrefix);
  }
}
 

import gov.nasa.jpf.Config; //导入方法依赖的package包/类
protected void addToReturnWatchList (Config conf, String id){
  String keyPrefix = "perturb." + id;

  String ms = conf.getString(keyPrefix + ".method");
  if (ms != null) {
    MethodSpec mthSpec = MethodSpec.createMethodSpec(ms);
    if (mthSpec != null) {
      Object[] args = {conf, keyPrefix};
      OperandPerturbator perturbator = conf.getInstance(keyPrefix + ".class", OperandPerturbator.class, argTypes, args);
      if (perturbator != null) {
        String loc = conf.getString(keyPrefix + ".location");
        ReturnPerturbation p = new ReturnPerturbation(mthSpec, perturbator, loc);
        returnWatchList.add(p);
      } else {
        log.warning("invalid perturbator spec for ", keyPrefix);
      }

    } else {
      log.warning("malformed method specification for ", keyPrefix);
    }

  } else {
    log.warning("missing method specification for ", keyPrefix);
  }
}
 

import gov.nasa.jpf.Config; //导入方法依赖的package包/类
protected void addToParamsWatchList (Config conf, String id){
  String keyPrefix = "perturb." + id;

  String ms = conf.getString(keyPrefix + ".method");
  if (ms != null) {
    MethodSpec mthSpec = MethodSpec.createMethodSpec(ms);
    if (mthSpec != null) {
      Object[] args = {conf, keyPrefix};
      OperandPerturbator perturbator = conf.getInstance(keyPrefix + ".class", OperandPerturbator.class, argTypes, args);        
      if (perturbator != null) {
        String loc = conf.getString(keyPrefix + ".location");
        ParamsPerturbation p = new ParamsPerturbation(mthSpec, perturbator, loc);
        paramsWatchList.add(p);
      } else {
        log.warning("invalid perturbator spec for ", keyPrefix);
      }

    } else {
      log.warning("malformed method specification for ", keyPrefix);
    }
  } else {
    log.warning("missing method specification for ", keyPrefix);
  }
}
 

import gov.nasa.jpf.Config; //导入方法依赖的package包/类
void addConfiguredPublishers (Config conf) {
  String[] def = { "console" };

  Class<?>[] argTypes = { Config.class, Reporter.class };
  Object[] args = { conf, this };

  for (String id : conf.getStringArray("report.publisher", def)){
    Publisher p = conf.getInstance("report." + id + ".class",
                                   Publisher.class, argTypes, args);
    if (p != null){
      publishers.add(p);
    } else {
      log.warning("could not instantiate publisher class: " + id);
    }
  }
}
 

import gov.nasa.jpf.Config; //导入方法依赖的package包/类
/**
 * note - this is not allowed to fail, since we couldn't log that. Hardcoded default
 * values have to do in this case (make sure we catch the proper Config exceptions)
 */
public static void init (Config conf) {
  try {
    defaultLevel = Level.parse( conf.getString("log.level", "INFO").toUpperCase());
  } catch (Throwable x) {
    defaultLevel = Level.WARNING;
  }
  
  activeSevere = conf.getStringArray("log.severe");
  activeWarning = conf.getStringArray("log.warning");
  activeInfo = conf.getStringArray("log.info");
  activeConfig = conf.getStringArray("log.config");
  activeFine = conf.getStringArray("log.fine");
  activeFiner = conf.getStringArray("log.finer");
  activeFinest = conf.getStringArray("log.finest");
  
  handler = conf.getInstance("log.handler.class", Handler.class);
}
 

import gov.nasa.jpf.Config; //导入方法依赖的package包/类
public DebugCopyPreservingStateSet(Config conf){
  String serializerCls = conf.getString("vm.serializer.class");

  if (serializerCls == null) {
      serializerCls = "gov.nasa.jpf.abstraction.util.DebugPredicateAbstractionSerializer";
  }

  try {
      serializer = conf.getInstance(null, serializerCls, DebugStateSerializer.class);
  } catch (Throwable t) {
      throw new JPFConfigException("Debug StateSet cannot instantiate debug serializer: " + serializerCls, t);
  }

  String path = conf.getString("vm.serializer.output", "tmp");
  outputDir = new File(path);
  if (!outputDir.isDirectory()){
    if (!outputDir.mkdirs()){
      throw new JPFConfigException("Debug StateSet cannot create output dir: " + outputDir.getAbsolutePath());
    }
  }

  outputFile = new File( outputDir, LOGFILE);
}
 

import gov.nasa.jpf.Config; //导入方法依赖的package包/类
protected List<FieldAbstraction> getFieldAbstractions(Config conf){
  List<FieldAbstraction> list = null;
  
  String[] fids = conf.getCompactTrimmedStringArray("das.fields");
  for (String id : fids) {
    String keyPrefix = "das." + id;
    String fs = conf.getString(keyPrefix + ".field");
    if (fs != null) {
      FieldSpec fspec = FieldSpec.createFieldSpec(fs);
      if (fspec != null) {
        String aKey = keyPrefix + ".abstraction";
        Abstraction abstraction = conf.getInstance(aKey, Abstraction.class);

        logger.info("found field abstraction for ", fspec, " = ", abstraction.getClass().getName());
        
        if (list == null){
          list = new LinkedList<FieldAbstraction>();
        }
        
        list.add(new FieldAbstraction(fspec, abstraction));
      }
    } else {
      logger.warning("no field spec for id: " + id);
    }
  }
  
  return list;
}
 

import gov.nasa.jpf.Config; //导入方法依赖的package包/类
public DebugJenkinsStateSet (Config conf){
  String serializerCls = conf.getString("vm.serializer.class");
  if (serializerCls != null){
    int idx = serializerCls.lastIndexOf('.') + 1;
    String cname = serializerCls.substring(idx);
    
    if (!cname.startsWith("Debug")){
      if (idx > 0){
        serializerCls = serializerCls.substring(0,idx) + "Debug" + cname;
      } else {
        serializerCls = "Debug" + cname;
      }
    }
    
    serializer = conf.getInstance(null, serializerCls, DebugStateSerializer.class);
    if (serializer == null){
      throw new JPFConfigException("Debug StateSet cannot instantiate serializer: " + serializerCls);
    }
  }
  
  String path = conf.getString("vm.serializer.output", "tmp");
  outputDir = new File(path);
  if (!outputDir.isDirectory()){
    if (!outputDir.mkdirs()){
      throw new JPFConfigException("Debug StateSet cannot create output dir: " + outputDir.getAbsolutePath());        
    }
  }
  
  outputFile = new File( outputDir, LOGFILE);
}
 

import gov.nasa.jpf.Config; //导入方法依赖的package包/类
public void initFields (Config config) {
  path = new Path("fix-this!");
  out = null;

  ss = new SystemState(config, this);

  stateSet = config.getInstance("vm.storage.class", StateSet.class);
  if (stateSet != null) stateSet.attach(this);
  backtracker = config.getEssentialInstance("vm.backtracker.class", Backtracker.class);
  backtracker.attach(this);

  scheduler = config.getEssentialInstance("vm.scheduler.class", Scheduler.class);
  
  newStateId = -1;
}
 

import gov.nasa.jpf.Config; //导入方法依赖的package包/类
public JPF_gov_nasa_jpf_EventProducer (Config config){
  eventTree = config.getEssentialInstance(EventTree.CONFIG_KEY, EventTree.class);
  ctx = config.getInstance("event.context.class", EventContext.class);
  
  logger.info("event tree generated by: ", eventTree.getClass().getName());
  if (ctx != null){
    logger.info("using context event: ", ctx.getClass().getName());
  }
}
 

import gov.nasa.jpf.Config; //导入方法依赖的package包/类
public PathListener(Config jpfConf, JPF jpf) {
  this.jpfConf = jpfConf;
  
  //TODO: we can make this even more precise by also allowing specifying the EXACT 
  //call (e.g. src line number + class) after which count collection should start 
  if(!jpfConf.hasValue(MEASURED_METHODS) && !jpfConf.hasValue(SYMBOLIC_METHODS)) {
    RuntimeException e = new RuntimeException("Must set either " + MEASURED_METHODS + " or " + SYMBOLIC_METHODS);
    logger.severe(e.getMessage());
    throw e;
  }
  this.measuredMethods = getMeasuredMethods(this.jpfConf);
  this.symbolicMethods = getSymbolicMethods(this.jpfConf);
  logger.info("Measured methods: " + this.measuredMethods.toString());
  
  this.policyManager = new PolicyManager(this.getPolicyBaseDir(jpfConf));
  if(this.visualize(this.jpfConf))
    this.visDir = this.getVisualizationDir(this.jpfConf);
  
  this.showInstrs = jpfConf.getBoolean(SHOW_INSTRS_CONF, false);
  
  this.ctxManager = new ContextManager();
  
  //Initialize state
  if(jpfConf.hasValue(WORST_CASE_STATE_BLDR_CONF)) {
    this.stateBuilder = jpfConf.getInstance(WORST_CASE_STATE_BLDR_CONF, StateBuilder.class);
  } else
    this.stateBuilder = new DepthState.DepthStateBuilder();
  
  if(jpfConf.hasValue(POLICY_GENERATOR_CLS_CONF)) {
    this.policyGenerator = jpfConf.getInstance(POLICY_GENERATOR_CLS_CONF, PolicyGenerator.class);
    this.worstCasePathBuilder = new WorstCasePath.Builder(ctxManager);
  } else {
    HistoryBasedPolicy.Builder histGenerator = new HistoryBasedPolicy.Builder();
    if(jpfConf.hasValue(HISTORY_SIZE_CONF)) {
      this.historySize = jpfConf.getInt(HISTORY_SIZE_CONF);
      histGenerator.setMaxHistorySize(historySize);
      this.worstCasePathBuilder = new WorstCasePath.Builder(ctxManager, historySize);
    } else { // adaptive by default
      histGenerator.setAdaptive(true);
      this.worstCasePathBuilder = new WorstCasePath.Builder(ctxManager);
    }
    this.policyGenerator = histGenerator;
  }

  this.wcPath = null;
}
 

import gov.nasa.jpf.Config; //导入方法依赖的package包/类
public static void main (String[] args) {
  try {
    int options = getOptions(args);

    if (args.length == 0 || isOptionEnabled(HELP, options)) {
      showUsage();
      return;
    }

    if (isOptionEnabled(ADD_PROJECT, options)){
      addProject(args);
      return;
    }
    
    if (isOptionEnabled(DELAY_START, options)) {
      delay("press any key to start");
    }
    
    if (isOptionEnabled(LOG, options)) {
      Config.enableLogging(true);
    }

    Config conf = new Config(args);

    if (isOptionEnabled(SHOW, options)) {
      conf.printEntries();
    }

    ClassLoader cl = conf.initClassLoader(RunJPF.class.getClassLoader());

    if (isOptionEnabled(VERSION, options)) {
      showVersion(cl);
    }

    if (isOptionEnabled(BUILD_INFO, options)) {
      showBuild(cl);
    }

    // using JPFShell is Ok since it is just a simple non-derived interface
    // note this uses a <init>(Config) ctor in the shell class if there is one, i.e. there is no need for a separate
    // start(Config,..) or re-loading the config itself
    JPFShell shell = conf.getInstance("shell", JPFShell.class);
    if (shell != null) {
      shell.start( removeConfigArgs(args)); // responsible for exception handling itself

    } else {
      // we have to load JPF explicitly through the URLClassLoader, and
      // call its start() via reflection - interfaces would only work if
      // we instantiate a JPF object here, which would force us to duplicate all
      // the logging and event handling that preceedes JPF instantiation
      Class<?> jpfCls = cl.loadClass(JPF_CLASSNAME);
      if (!call( jpfCls, "start", new Object[] {conf,args})){
        error("cannot find 'public static start(Config,String[])' in " + JPF_CLASSNAME);
      }
    }
    
    if (isOptionEnabled(DELAY_EXIT, options)) {
      delay("press any key to exit");
    }

    
  } catch (NoClassDefFoundError ncfx){
    ncfx.printStackTrace();
  } catch (ClassNotFoundException cnfx){
    error("cannot find " + JPF_CLASSNAME);
  } catch (InvocationTargetException ix){
    // should already be handled by JPF
    ix.getCause().printStackTrace();
  }
  
}