nus-yam/ex-repair huggingface dataset:
Program: 28793
Project: 28793
Buggy source:
public void addEternalReferencedHolder(EternalReferencedHolder eternalReferencedHolder){
  eternalReferencedHolders.add(eternalReferencedHolder);
}

Fixed version (ground truth):
public synchronized void addEternalReferencedHolder(EternalReferencedHolder eternalReferencedHolder){
  eternalReferencedHolders.add(eternalReferencedHolder);
}
Program: 28794
Project: 28794
Buggy source:
public List<EternalReferencedHolder> getEternalReferencedHolders(){
  return eternalReferencedHolders;
}

Fixed version (ground truth):
public List<EternalReferencedHolder> getEternalReferencedHolders(){
  return Collections.unmodifiableList(new ArrayList<>(eternalReferencedHolders));
}
Program: 28795
Project: 28795
Buggy source:
public SiddhiAppContext(){
  this.eternalReferencedHolders=new CopyOnWriteArrayList<EternalReferencedHolder>();
  this.scriptFunctionMap=new HashMap<String,Script>();
}

Fixed version (ground truth):
public SiddhiAppContext(){
  this.eternalReferencedHolders=new LinkedList<>();
  this.scriptFunctionMap=new HashMap<String,Script>();
}
Program: 28797
Project: 28797
Buggy source:
@Override public void restoreState(Map<String,Object> state){
  HashMap<String,Map<String,Object>> data=(HashMap<String,Map<String,Object>>)state.get("String_Node_Str");
  for (  Map.Entry<String,Map<String,Object>> entry : data.entrySet()) {
    String key=entry.getKey();
    AttributeAggregator aAttributeAggregator=attributeAggregator.cloneAggregator(key);
    aAttributeAggregator.initAggregator(attributeExpressionExecutors,siddhiAppContext,configReader);
    aAttributeAggregator.start();
    aAttributeAggregator.restoreState(entry.getValue());
    aggregatorMap.put(key,aAttributeAggregator);
  }
}

Fixed version (ground truth):
@Override public void restoreState(Map<String,Object> state){
  HashMap<String,Map<String,Object>> data=(HashMap<String,Map<String,Object>>)state.get("String_Node_Str");
  for (  Map.Entry<String,Map<String,Object>> entry : data.entrySet()) {
    String key=entry.getKey();
    AttributeAggregator aAttributeAggregator=attributeAggregator.cloneAggregator(key);
    aAttributeAggregator.start();
    aAttributeAggregator.restoreState(entry.getValue());
    aggregatorMap.put(key,aAttributeAggregator);
  }
}
Program: 28798
Project: 28798
Buggy source:
@Override public Object execute(ComplexEvent event){
  if (event.getType() == ComplexEvent.Type.RESET) {
    Object aOutput=null;
    for (    AttributeAggregator attributeAggregator : aggregatorMap.values()) {
      aOutput=attributeAggregator.process(event);
    }
    return aOutput;
  }
  String key=keyThreadLocal.get();
  AttributeAggregator currentAttributeAggregator=aggregatorMap.get(key);
  if (currentAttributeAggregator == null) {
    currentAttributeAggregator=attributeAggregator.cloneAggregator(key);
    currentAttributeAggregator.initAggregator(attributeExpressionExecutors,siddhiAppContext,configReader);
    currentAttributeAggregator.start();
    aggregatorMap.put(key,currentAttributeAggregator);
  }
  return currentAttributeAggregator.process(event);
}

Fixed version (ground truth):
@Override public Object execute(ComplexEvent event){
  if (event.getType() == ComplexEvent.Type.RESET) {
    Object aOutput=null;
    for (    AttributeAggregator attributeAggregator : aggregatorMap.values()) {
      aOutput=attributeAggregator.process(event);
    }
    return aOutput;
  }
  String key=keyThreadLocal.get();
  AttributeAggregator currentAttributeAggregator=aggregatorMap.get(key);
  if (currentAttributeAggregator == null) {
    currentAttributeAggregator=attributeAggregator.cloneAggregator(key);
    currentAttributeAggregator.start();
    aggregatorMap.put(key,currentAttributeAggregator);
  }
  return currentAttributeAggregator.process(event);
}
Program: 28799
Project: 28799
Buggy source:
public AbsentLogicalPreStateProcessor(LogicalStateElement.Type type,StateInputStream.Type stateType,List<Map.Entry<Long,Set<Integer>>> withinStates,TimeConstant waitingTime,ReentrantLock lock){
  super(type,stateType,withinStates);
  this.lock=lock;
  if (waitingTime != null) {
    this.waitingTime=waitingTime.value();
  }
}

Fixed version (ground truth):
public AbsentLogicalPreStateProcessor(LogicalStateElement.Type type,StateInputStream.Type stateType,List<Map.Entry<Long,Set<Integer>>> withinStates,TimeConstant waitingTime){
  super(type,stateType,withinStates);
  if (waitingTime != null) {
    this.waitingTime=waitingTime.value();
    this.waitingTimeConstant=waitingTime;
  }
}
Program: 28800
Project: 28800
Buggy source:
/** 
 * Construct an AbsentStreamPreStateProcessor object.
 * @param stateType    PATTERN or SEQUENCE
 * @param withinStates the time defined by 'within' keyword
 * @param waitingTime  the waiting time defined by 'for' keyword
 */
public AbsentStreamPreStateProcessor(StateInputStream.Type stateType,List<Map.Entry<Long,Set<Integer>>> withinStates,TimeConstant waitingTime){
  super(stateType,withinStates);
  this.waitingTime=waitingTime.value();
}

Fixed version (ground truth):
/** 
 * Construct an AbsentStreamPreStateProcessor object.
 * @param stateType    PATTERN or SEQUENCE
 * @param withinStates the time defined by 'within' keyword
 * @param waitingTime  the waiting time defined by 'for' keyword
 */
public AbsentStreamPreStateProcessor(StateInputStream.Type stateType,List<Map.Entry<Long,Set<Integer>>> withinStates,TimeConstant waitingTime){
  super(stateType,withinStates);
  this.waitingTime=waitingTime.value();
  this.waitingTimeConstant=waitingTime;
}
Program: 28804
Project: 28804
Buggy source:
/** 
 * Remove the snapshot version documentation files from docs/api directory
 * @param mkdocsConfigFile           The mkdocs configuration file
 * @param documentationBaseDirectory The path of the base directory in which the documentation will be generated
 * @param logger                     The maven plugin logger
 */
public static void removeSnapshotAPIDocs(File mkdocsConfigFile,String documentationBaseDirectory,Log logger){
  File apiDocsDirectory=new File(documentationBaseDirectory + File.separator + Constants.API_SUB_DIRECTORY);
  String[] documentationFileNames=apiDocsDirectory.list((directory,fileName) -> fileName.endsWith(Constants.MARKDOWN_FILE_EXTENSION));
  if (documentationFileNames != null) {
    List<String> documentationFilesList=new ArrayList<>();
    for (    String documentationFileName : documentationFileNames) {
      if (documentationFileName.endsWith(Constants.SNAPSHOT_VERSION_POSTFIX + Constants.MARKDOWN_FILE_EXTENSION)) {
        File documentationFile=new File(apiDocsDirectory.getAbsolutePath() + File.separator + documentationFileName);
        if (!documentationFile.delete()) {
          logger.warn("String_Node_Str" + documentationFile.getAbsolutePath());
        }
      }
 else {
        documentationFilesList.add(documentationFileName);
      }
    }
    try {
      updateAPIPagesInMkdocsConfig(mkdocsConfigFile,documentationFilesList);
    }
 catch (    FileNotFoundException e) {
      logger.warn("String_Node_Str" + mkdocsConfigFile.getAbsolutePath() + "String_Node_Str");
    }
  }
}

Fixed version (ground truth):
/** 
 * Remove the snapshot version documentation files from docs/api directory
 * @param mkdocsConfigFile           The mkdocs configuration file
 * @param documentationBaseDirectory The path of the base directory in which the documentation will be generated
 * @param logger                     The maven plugin logger
 */
public static void removeSnapshotAPIDocs(File mkdocsConfigFile,String documentationBaseDirectory,Log logger){
  File apiDocsDirectory=new File(documentationBaseDirectory + File.separator + Constants.API_SUB_DIRECTORY);
  String[] documentationFileNames=apiDocsDirectory.list((directory,fileName) -> fileName.endsWith(Constants.MARKDOWN_FILE_EXTENSION));
  if (documentationFileNames != null) {
    for (    String documentationFileName : documentationFileNames) {
      if (documentationFileName.endsWith(Constants.SNAPSHOT_VERSION_POSTFIX + Constants.MARKDOWN_FILE_EXTENSION)) {
        File documentationFile=new File(apiDocsDirectory.getAbsolutePath() + File.separator + documentationFileName);
        if (!documentationFile.delete()) {
          logger.warn("String_Node_Str" + documentationFile.getAbsolutePath());
        }
      }
    }
    try {
      updateAPIPagesInMkdocsConfig(mkdocsConfigFile,documentationBaseDirectory);
    }
 catch (    FileNotFoundException e) {
      logger.warn("String_Node_Str" + mkdocsConfigFile.getAbsolutePath() + "String_Node_Str");
    }
  }
}
Program: 28805
Project: 28805
Buggy source:
/** 
 * Commit the documentation directory and the mkdocs config file
 * @param docsDirectory    The docs drectory
 * @param mkdocsConfigFile The mkdocs configuration file
 * @param version          The version of the documentation
 * @param logger           The maven logger
 */
public static void updateDocumentationOnGitHub(String docsDirectory,File mkdocsConfigFile,String version,Log logger){
  try {
    executeCommand(new String[]{Constants.GIT_COMMAND,Constants.GIT_ADD_COMMAND,docsDirectory},logger);
    executeCommand(new String[]{Constants.GIT_COMMAND,Constants.GIT_COMMIT_COMMAND,Constants.GIT_COMMIT_COMMAND_MESSAGE_ARGUMENT,String.format(Constants.GIT_COMMIT_COMMAND_MESSAGE_FORMAT,version,version),Constants.GIT_COMMIT_COMMAND_FILES_ARGUMENT,docsDirectory,mkdocsConfigFile.getAbsolutePath()},logger);
    executeCommand(new String[]{Constants.GIT_COMMAND,Constants.GIT_PUSH_COMMAND,Constants.GIT_PUSH_COMMAND_REMOTE,Constants.GIT_PUSH_COMMAND_REMOTE_BRANCH},logger);
  }
 catch (  Throwable t) {
    logger.warn("String_Node_Str",t);
  }
}

Fixed version (ground truth):
/** 
 * Commit the documentation directory and the mkdocs config file
 * @param docsDirectory    The docs drectory
 * @param mkdocsConfigFile The mkdocs configuration file
 * @param readmeFile       The read me file
 * @param version          The version of the documentation
 * @param logger           The maven logger
 */
public static void updateDocumentationOnGitHub(String docsDirectory,File mkdocsConfigFile,File readmeFile,String version,Log logger){
  try {
    executeCommand(new String[]{Constants.GIT_COMMAND,Constants.GIT_ADD_COMMAND,docsDirectory},logger);
    executeCommand(new String[]{Constants.GIT_COMMAND,Constants.GIT_COMMIT_COMMAND,Constants.GIT_COMMIT_COMMAND_MESSAGE_ARGUMENT,String.format(Constants.GIT_COMMIT_COMMAND_MESSAGE_FORMAT,version,version),Constants.GIT_COMMIT_COMMAND_FILES_ARGUMENT,docsDirectory,mkdocsConfigFile.getAbsolutePath(),readmeFile.getAbsolutePath()},logger);
    executeCommand(new String[]{Constants.GIT_COMMAND,Constants.GIT_PUSH_COMMAND,Constants.GIT_PUSH_COMMAND_REMOTE,Constants.GIT_PUSH_COMMAND_REMOTE_BRANCH},logger);
  }
 catch (  Throwable t) {
    logger.warn("String_Node_Str",t);
  }
}
Program: 28808
Project: 28808
Buggy source:
@Override public void process(ComplexEventChunk complexEventChunk){
  ComplexEventChunk<StreamEvent> streamEventChunk=new ComplexEventChunk<>(complexEventChunk.isBatch());
  while (complexEventChunk.hasNext()) {
    ComplexEvent complexEvent=complexEventChunk.next();
    streamEventChunk.add(streamEventCloner.copyStreamEvent((StreamEvent)complexEvent));
  }
  incrementalExecutor.execute(complexEventChunk);
}

Fixed version (ground truth):
@Override public void process(ComplexEventChunk complexEventChunk){
  ComplexEventChunk<StreamEvent> streamEventChunk=new ComplexEventChunk<>(complexEventChunk.isBatch());
  while (complexEventChunk.hasNext()) {
    ComplexEvent complexEvent=complexEventChunk.next();
    StreamEvent borrowedEvent=streamEventPool.borrowEvent();
    for (int i=0; i < incomingExpressionExecutors.size(); i++) {
      ExpressionExecutor expressionExecutor=incomingExpressionExecutors.get(i);
      borrowedEvent.setOutputData(expressionExecutor.execute(complexEvent),i);
    }
    streamEventChunk.add(borrowedEvent);
  }
  incrementalExecutor.execute(streamEventChunk);
}
Program: 28809
Project: 28809
Buggy source:
public IncrementalAggregationProcessor(IncrementalExecutor incrementalExecutor,List<ExpressionExecutor> incomingExpressionExecutors,MetaStreamEvent processedMetaStreamEvent){
  this.incrementalExecutor=incrementalExecutor;
  this.incomingExpressionExecutors=incomingExpressionExecutors;
  this.processedMetaStreamEvent=processedMetaStreamEvent;
  this.streamEventCloner=new StreamEventCloner(processedMetaStreamEvent,new StreamEventPool(processedMetaStreamEvent,5));
}

Fixed version (ground truth):
public IncrementalAggregationProcessor(IncrementalExecutor incrementalExecutor,List<ExpressionExecutor> incomingExpressionExecutors,MetaStreamEvent processedMetaStreamEvent){
  this.incrementalExecutor=incrementalExecutor;
  this.incomingExpressionExecutors=incomingExpressionExecutors;
  this.processedMetaStreamEvent=processedMetaStreamEvent;
  this.streamEventPool=new StreamEventPool(processedMetaStreamEvent,5);
}
Program: 28810
Project: 28810
Buggy source:
public void clearValues(){
  this.values=new Object[expressionExecutors.size()];
}

Fixed version (ground truth):
public void clearValues(){
  this.values=new Object[expressionExecutors.size() + 1];
}
Program: 28811
Project: 28811
Buggy source:
private void dispatchEvent(long startTimeOfNewAggregates,BaseIncrementalValueStore aBaseIncrementalValueStore){
  if (aBaseIncrementalValueStore.isProcessed) {
    StreamEvent streamEvent=createStreamEvent(aBaseIncrementalValueStore);
    ComplexEventChunk<StreamEvent> eventChunk=new ComplexEventChunk<>(true);
    eventChunk.add(streamEvent);
    next.execute(eventChunk);
  }
  cleanBaseIncrementalValueStore(startTimeOfNewAggregates,aBaseIncrementalValueStore);
}

Fixed version (ground truth):
private void dispatchEvent(long startTimeOfNewAggregates,BaseIncrementalValueStore aBaseIncrementalValueStore){
  if (aBaseIncrementalValueStore.isProcessed) {
    StreamEvent streamEvent=createStreamEvent(aBaseIncrementalValueStore);
    ComplexEventChunk<StreamEvent> eventChunk=new ComplexEventChunk<>(true);
    eventChunk.add(streamEvent);
    table.addEvents(eventChunk);
    next.execute(eventChunk);
  }
  cleanBaseIncrementalValueStore(startTimeOfNewAggregates,aBaseIncrementalValueStore);
}
Program: 28813
Project: 28813
Buggy source:
private void dispatchEvents(Map<String,BaseIncrementalValueStore> baseIncrementalValueGroupByStore){
  if (baseIncrementalValueGroupByStore.size() > 0) {
    ComplexEventChunk<StreamEvent> eventChunk=new ComplexEventChunk<>(true);
    for (    BaseIncrementalValueStore aBaseIncrementalValueStore : baseIncrementalValueGroupByStore.values()) {
      StreamEvent streamEvent=createStreamEvent(aBaseIncrementalValueStore);
      eventChunk.add(streamEvent);
    }
    next.execute(eventChunk);
  }
  baseIncrementalValueGroupByStore.clear();
}

Fixed version (ground truth):
private void dispatchEvents(Map<String,BaseIncrementalValueStore> baseIncrementalValueGroupByStore){
  if (baseIncrementalValueGroupByStore.size() > 0) {
    ComplexEventChunk<StreamEvent> eventChunk=new ComplexEventChunk<>(true);
    for (    BaseIncrementalValueStore aBaseIncrementalValueStore : baseIncrementalValueGroupByStore.values()) {
      StreamEvent streamEvent=createStreamEvent(aBaseIncrementalValueStore);
      eventChunk.add(streamEvent);
    }
    table.addEvents(eventChunk);
    next.execute(eventChunk);
  }
  baseIncrementalValueGroupByStore.clear();
}
Program: 28814
Project: 28814
Buggy source:
private void processAggregates(StreamEvent streamEvent){
synchronized (this) {
    if (isGroupBy) {
      try {
        String groupedByKey=groupByKeyGenerator.constructEventKey(streamEvent);
        keyThreadLocal.set(groupedByKey);
        if (baseIncrementalValueGroupByStoreList != null) {
          Map<String,BaseIncrementalValueStore> baseIncrementalValueGroupByStore=baseIncrementalValueGroupByStoreList.get(currentBufferIndex);
          BaseIncrementalValueStore aBaseIncrementalValueStore=baseIncrementalValueGroupByStore.computeIfAbsent(groupedByKey,k -> baseIncrementalValueStore.cloneStore(k));
          process(streamEvent,aBaseIncrementalValueStore);
        }
 else {
          BaseIncrementalValueStore aBaseIncrementalValueStore=baseIncrementalValueStoreMap.computeIfAbsent(groupedByKey,k -> baseIncrementalValueStore.cloneStore(k));
          process(streamEvent,aBaseIncrementalValueStore);
        }
      }
  finally {
        keyThreadLocal.remove();
      }
    }
 else {
      if (baseIncrementalValueStoreList != null) {
        BaseIncrementalValueStore aBaseIncrementalValueStore=baseIncrementalValueStoreList.get(currentBufferIndex);
        process(streamEvent,aBaseIncrementalValueStore);
      }
 else {
        process(streamEvent,baseIncrementalValueStore);
      }
    }
  }
}

Fixed version (ground truth):
private void processAggregates(StreamEvent streamEvent){
synchronized (this) {
    if (isGroupBy) {
      try {
        String groupedByKey=groupByKeyGenerator.constructEventKey(streamEvent);
        keyThreadLocal.set(groupedByKey);
        if (baseIncrementalValueGroupByStoreList != null) {
          Map<String,BaseIncrementalValueStore> baseIncrementalValueGroupByStore=baseIncrementalValueGroupByStoreList.get(currentBufferIndex);
          BaseIncrementalValueStore aBaseIncrementalValueStore=baseIncrementalValueGroupByStore.computeIfAbsent(groupedByKey,k -> baseIncrementalValueStore.cloneStore(k,startTimeOfAggregates));
          process(streamEvent,aBaseIncrementalValueStore);
        }
 else {
          BaseIncrementalValueStore aBaseIncrementalValueStore=baseIncrementalValueStoreMap.computeIfAbsent(groupedByKey,k -> baseIncrementalValueStore.cloneStore(k,startTimeOfAggregates));
          process(streamEvent,aBaseIncrementalValueStore);
        }
      }
  finally {
        keyThreadLocal.remove();
      }
    }
 else {
      if (baseIncrementalValueStoreList != null) {
        BaseIncrementalValueStore aBaseIncrementalValueStore=baseIncrementalValueStoreList.get(currentBufferIndex);
        process(streamEvent,aBaseIncrementalValueStore);
      }
 else {
        process(streamEvent,baseIncrementalValueStore);
      }
    }
  }
}
Program: 28815
Project: 28815
Buggy source:
private BaseIncrementalValueStore(long timeStamp,List<ExpressionExecutor> expressionExecutors){
  this.timestamp=timeStamp;
  this.values=new Object[expressionExecutors.size()];
  this.expressionExecutors=expressionExecutors;
}

Fixed version (ground truth):
public BaseIncrementalValueStore(long timeStamp,List<ExpressionExecutor> expressionExecutors){
  this.timestamp=timeStamp;
  this.values=new Object[expressionExecutors.size() + 1];
  this.expressionExecutors=expressionExecutors;
}
Program: 28816
Project: 28816
Buggy source:
@Override public void execute(ComplexEventChunk streamEventChunk){
  while (streamEventChunk.hasNext()) {
    StreamEvent streamEvent=(StreamEvent)streamEventChunk.next();
    streamEventChunk.remove();
    LOG.info(duration + "String_Node_Str" + streamEvent.getType());
    long timestamp=getTimestamp(streamEvent);
    if (timestamp >= nextEmitTime) {
      nextEmitTime=IncrementalTimeConverterUtil.getNextEmitTime(timestamp,duration);
      long startTimeOfAggregates=IncrementalTimeConverterUtil.getStartTimeOfAggregates(timestamp,duration);
      dispatchAggregateEvents(startTimeOfAggregates,timestamp);
      sendTimerEvent(streamEvent,timestamp);
    }
    if (streamEvent.getType() == ComplexEvent.Type.CURRENT) {
      processAggregates(streamEvent);
    }
  }
}

Fixed version (ground truth):
@Override public void execute(ComplexEventChunk streamEventChunk){
  streamEventChunk.reset();
  while (streamEventChunk.hasNext()) {
    StreamEvent streamEvent=(StreamEvent)streamEventChunk.next();
    streamEventChunk.remove();
    long timestamp=getTimestamp(streamEvent);
    if (timestamp >= nextEmitTime) {
      nextEmitTime=IncrementalTimeConverterUtil.getNextEmitTime(timestamp,duration);
      startTimeOfAggregates=IncrementalTimeConverterUtil.getStartTimeOfAggregates(timestamp,duration);
      dispatchAggregateEvents(startTimeOfAggregates,timestamp);
      sendTimerEvent(streamEvent,timestamp);
    }
    if (streamEvent.getType() == ComplexEvent.Type.CURRENT) {
      processAggregates(streamEvent);
    }
  }
}
Program: 28817
Project: 28817
Buggy source:
public BaseIncrementalValueStore cloneStore(String key){
  List<ExpressionExecutor> newExpressionExecutors=new ArrayList<>(expressionExecutors.size());
  expressionExecutors.forEach(expressionExecutor -> newExpressionExecutors.add(expressionExecutor.cloneExecutor(key)));
  return new BaseIncrementalValueStore(newExpressionExecutors);
}

Fixed version (ground truth):
public BaseIncrementalValueStore cloneStore(String key,long timestamp){
  List<ExpressionExecutor> newExpressionExecutors=new ArrayList<>(expressionExecutors.size());
  expressionExecutors.forEach(expressionExecutor -> newExpressionExecutors.add(expressionExecutor.cloneExecutor(key)));
  return new BaseIncrementalValueStore(timestamp,newExpressionExecutors);
}
Program: 28818
Project: 28818
Buggy source:
public void defineAggregation(AggregationDefinition aggregationDefinition){
  DefinitionParserHelper.validateDefinition(aggregationDefinition,streamDefinitionMap,tableDefinitionMap,windowDefinitionMap,aggregationDefinitionMap);
  aggregationDefinitionMap.putIfAbsent(aggregationDefinition.getId(),aggregationDefinition);
  AggregationRuntime aggregationRuntime=AggregationParser.parse(aggregationDefinition,siddhiAppContext,streamDefinitionMap,tableDefinitionMap,windowDefinitionMap,tableMap,windowMap);
  ProcessStreamReceiver processStreamReceiver=aggregationRuntime.getSingleStreamRuntime().getProcessStreamReceiver();
  streamJunctionMap.get(processStreamReceiver.getStreamId()).subscribe(processStreamReceiver);
}

Fixed version (ground truth):
public void defineAggregation(AggregationDefinition aggregationDefinition){
  DefinitionParserHelper.validateDefinition(aggregationDefinition,streamDefinitionMap,tableDefinitionMap,windowDefinitionMap,aggregationDefinitionMap);
  aggregationDefinitionMap.putIfAbsent(aggregationDefinition.getId(),aggregationDefinition);
  AggregationRuntime aggregationRuntime=AggregationParser.parse(aggregationDefinition,siddhiAppContext,streamDefinitionMap,tableDefinitionMap,windowDefinitionMap,tableMap,windowMap,this);
  ProcessStreamReceiver processStreamReceiver=aggregationRuntime.getSingleStreamRuntime().getProcessStreamReceiver();
  streamJunctionMap.get(processStreamReceiver.getStreamId()).subscribe(processStreamReceiver);
}
Program: 28819
Project: 28819
Buggy source:
protected void process(StateEvent stateEvent,ComplexEventChunk complexEventChunk){
switch (type) {
case AND:
    if (stateEvent.getStreamEvent(partnerPreStateProcessor.getStateId()) != null) {
      super.process(stateEvent,complexEventChunk);
    }
 else {
      thisStatePreProcessor.stateChanged();
    }
  break;
case OR:
super.process(stateEvent,complexEventChunk);
break;
case NOT:
break;
}
}

Fixed version (ground truth):
protected void process(StateEvent stateEvent,ComplexEventChunk complexEventChunk){
switch (type) {
case AND:
    if (stateEvent.getStreamEvent(partnerPreStateProcessor.getStateId()) != null) {
      super.process(stateEvent,complexEventChunk);
    }
 else {
      thisStatePreProcessor.stateChanged();
    }
  break;
case OR:
super.process(stateEvent,complexEventChunk);
if (partnerPostStateProcessor.nextProcessor != null && thisStatePreProcessor.thisLastProcessor == partnerPostStateProcessor) {
partnerPostStateProcessor.isEventReturned=true;
}
break;
case NOT:
break;
}
}
Program: 28820
Project: 28820
Buggy source:
@Override public void addEveryState(StateEvent stateEvent){
  newAndEveryStateEventList.add(stateEventCloner.copyStateEvent(stateEvent));
}

Fixed version (ground truth):
@Override public void addEveryState(StateEvent stateEvent){
  StateEvent clonedEvent=stateEventCloner.copyStateEvent(stateEvent);
  clonedEvent.setEvent(stateId,null);
  newAndEveryStateEventList.add(clonedEvent);
  if (partnerStatePreProcessor != null) {
    partnerStatePreProcessor.newAndEveryStateEventList.add(clonedEvent);
  }
}
Program: 28821
Project: 28821
Buggy source:
@Override public void resetState(){
  pendingStateEventList.clear();
  partnerStatePreProcessor.pendingStateEventList.clear();
  if (isStartState && newAndEveryStateEventList.isEmpty()) {
    init();
  }
}

Fixed version (ground truth):
@Override public void resetState(){
  if (logicalType == LogicalStateElement.Type.OR || pendingStateEventList.size() == partnerStatePreProcessor.pendingStateEventList.size()) {
    pendingStateEventList.clear();
    partnerStatePreProcessor.pendingStateEventList.clear();
    if (isStartState && newAndEveryStateEventList.isEmpty()) {
      if (stateType == StateInputStream.Type.SEQUENCE && thisStatePostProcessor.nextEveryStatePerProcessor == null && !((StreamPreStateProcessor)thisStatePostProcessor.nextStatePerProcessor).pendingStateEventList.isEmpty()) {
        return;
      }
      init();
    }
  }
}
Program: 28822
Project: 28822
Buggy source:
@Override public ComplexEventChunk<StateEvent> processAndReturn(ComplexEventChunk complexEventChunk){
  ComplexEventChunk<StateEvent> returnEventChunk=new ComplexEventChunk<StateEvent>(false);
  complexEventChunk.reset();
  StreamEvent streamEvent=(StreamEvent)complexEventChunk.next();
  for (Iterator<StateEvent> iterator=pendingStateEventList.iterator(); iterator.hasNext(); ) {
    StateEvent stateEvent=iterator.next();
    if (logicalType == LogicalStateElement.Type.OR && stateEvent.getStreamEvent(partnerStatePreProcessor.getStateId()) != null) {
      iterator.remove();
      continue;
    }
    stateEvent.setEvent(stateId,streamEventCloner.copyStreamEvent(streamEvent));
    process(stateEvent);
    if (this.thisLastProcessor.isEventReturned()) {
      this.thisLastProcessor.clearProcessedEvent();
      returnEventChunk.add(stateEvent);
    }
    if (stateChanged) {
      iterator.remove();
    }
 else {
switch (stateType) {
case PATTERN:
        stateEvent.setEvent(stateId,null);
      break;
case SEQUENCE:
    stateEvent.setEvent(stateId,null);
  iterator.remove();
break;
}
}
}
return returnEventChunk;
}

Fixed version (ground truth):
@Override public ComplexEventChunk<StateEvent> processAndReturn(ComplexEventChunk complexEventChunk){
  ComplexEventChunk<StateEvent> returnEventChunk=new ComplexEventChunk<StateEvent>(false);
  complexEventChunk.reset();
  StreamEvent streamEvent=(StreamEvent)complexEventChunk.next();
  for (Iterator<StateEvent> iterator=pendingStateEventList.iterator(); iterator.hasNext(); ) {
    StateEvent stateEvent=iterator.next();
    if (withinStates.size() > 0) {
      if (isExpired(stateEvent,streamEvent)) {
        iterator.remove();
        continue;
      }
    }
    if (logicalType == LogicalStateElement.Type.OR && stateEvent.getStreamEvent(partnerStatePreProcessor.getStateId()) != null) {
      iterator.remove();
      continue;
    }
    stateEvent.setEvent(stateId,streamEventCloner.copyStreamEvent(streamEvent));
    process(stateEvent);
    if (this.thisLastProcessor.isEventReturned()) {
      this.thisLastProcessor.clearProcessedEvent();
      returnEventChunk.add(stateEvent);
    }
    if (stateChanged) {
      iterator.remove();
    }
 else {
switch (stateType) {
case PATTERN:
        stateEvent.setEvent(stateId,null);
      break;
case SEQUENCE:
    stateEvent.setEvent(stateId,null);
  iterator.remove();
break;
}
}
}
return returnEventChunk;
}
Program: 28823
Project: 28823
Buggy source:
@Override public void addState(StateEvent stateEvent){
  if (newAndEveryStateEventList.isEmpty()) {
    newAndEveryStateEventList.add(stateEvent);
  }
  if (partnerStatePreProcessor != null && partnerStatePreProcessor.newAndEveryStateEventList.isEmpty()) {
    partnerStatePreProcessor.newAndEveryStateEventList.add(stateEvent);
  }
}

Fixed version (ground truth):
@Override public void addState(StateEvent stateEvent){
  if (isStartState || stateType == StateInputStream.Type.SEQUENCE) {
    if (newAndEveryStateEventList.isEmpty()) {
      newAndEveryStateEventList.add(stateEvent);
    }
    if (partnerStatePreProcessor != null && partnerStatePreProcessor.newAndEveryStateEventList.isEmpty()) {
      partnerStatePreProcessor.newAndEveryStateEventList.add(stateEvent);
    }
  }
 else {
    newAndEveryStateEventList.add(stateEvent);
    if (partnerStatePreProcessor != null) {
      partnerStatePreProcessor.newAndEveryStateEventList.add(stateEvent);
    }
  }
}
Program: 28824
Project: 28824
Buggy source:
public void init(){
  if (isStartState) {
    StateEvent stateEvent=stateEventPool.borrowEvent();
    addState(stateEvent);
  }
}

Fixed version (ground truth):
public void init(){
  if (isStartState && (!initialized || this.thisStatePostProcessor.nextEveryStatePerProcessor != null)) {
    StateEvent stateEvent=stateEventPool.borrowEvent();
    addState(stateEvent);
    initialized=true;
  }
}
Program: 28825
Project: 28825
Buggy source:
@Override public void resetState(){
  pendingStateEventList.clear();
  if (isStartState && newAndEveryStateEventList.isEmpty()) {
    init();
  }
}

Fixed version (ground truth):
@Override public void resetState(){
  pendingStateEventList.clear();
  if (isStartState && newAndEveryStateEventList.isEmpty()) {
    if (stateType == StateInputStream.Type.SEQUENCE && thisStatePostProcessor.nextEveryStatePerProcessor == null && !((StreamPreStateProcessor)thisStatePostProcessor.nextStatePerProcessor).pendingStateEventList.isEmpty()) {
      return;
    }
    init();
  }
}
Program: 28826
Project: 28826
Buggy source:
private boolean isExpired(StateEvent pendingStateEvent,StreamEvent incomingStreamEvent){
  for (  Map.Entry<Long,Set<Integer>> withinEntry : withinStates) {
    for (    Integer withinStateId : withinEntry.getValue()) {
      if (withinStateId == SiddhiConstants.ANY) {
        if (Math.abs(pendingStateEvent.getTimestamp() - incomingStreamEvent.getTimestamp()) > withinEntry.getKey()) {
          return true;
        }
      }
 else {
        if (Math.abs(pendingStateEvent.getStreamEvent(withinStateId).getTimestamp() - incomingStreamEvent.getTimestamp()) > withinEntry.getKey()) {
          return true;
        }
      }
    }
  }
  return false;
}

Fixed version (ground truth):
protected boolean isExpired(StateEvent pendingStateEvent,StreamEvent incomingStreamEvent){
  for (  Map.Entry<Long,Set<Integer>> withinEntry : withinStates) {
    for (    Integer withinStateId : withinEntry.getValue()) {
      if (withinStateId == SiddhiConstants.ANY) {
        if (Math.abs(pendingStateEvent.getTimestamp() - incomingStreamEvent.getTimestamp()) > withinEntry.getKey()) {
          return true;
        }
      }
 else {
        if (Math.abs(pendingStateEvent.getStreamEvent(withinStateId).getTimestamp() - incomingStreamEvent.getTimestamp()) > withinEntry.getKey()) {
          return true;
        }
      }
    }
  }
  return false;
}
Program: 28828
Project: 28828
Buggy source:
protected void process(StateEvent stateEvent,ComplexEventChunk complexEventChunk){
switch (type) {
case AND:
    if (stateEvent.getStreamEvent(partnerPreStateProcessor.getStateId()) != null) {
      super.process(stateEvent,complexEventChunk);
    }
 else {
      thisStatePreProcessor.stateChanged();
    }
  break;
case OR:
super.process(stateEvent,complexEventChunk);
break;
case NOT:
break;
}
}

Fixed version (ground truth):
protected void process(StateEvent stateEvent,ComplexEventChunk complexEventChunk){
switch (type) {
case AND:
    if (stateEvent.getStreamEvent(partnerPreStateProcessor.getStateId()) != null) {
      super.process(stateEvent,complexEventChunk);
    }
 else {
      thisStatePreProcessor.stateChanged();
    }
  break;
case OR:
super.process(stateEvent,complexEventChunk);
if (partnerPostStateProcessor.nextProcessor != null && thisStatePreProcessor.thisLastProcessor == partnerPostStateProcessor) {
partnerPostStateProcessor.isEventReturned=true;
}
break;
case NOT:
break;
}
}
Program: 28829
Project: 28829
Buggy source:
@Override public void addEveryState(StateEvent stateEvent){
  newAndEveryStateEventList.add(stateEventCloner.copyStateEvent(stateEvent));
}

Fixed version (ground truth):
@Override public void addEveryState(StateEvent stateEvent){
  StateEvent clonedEvent=stateEventCloner.copyStateEvent(stateEvent);
  clonedEvent.setEvent(stateId,null);
  newAndEveryStateEventList.add(clonedEvent);
  if (partnerStatePreProcessor != null) {
    partnerStatePreProcessor.newAndEveryStateEventList.add(clonedEvent);
  }
}
Program: 28830
Project: 28830
Buggy source:
@Override public void resetState(){
  pendingStateEventList.clear();
  partnerStatePreProcessor.pendingStateEventList.clear();
  if (isStartState && newAndEveryStateEventList.isEmpty()) {
    init();
  }
}

Fixed version (ground truth):
@Override public void resetState(){
  if (logicalType == LogicalStateElement.Type.OR || pendingStateEventList.size() == partnerStatePreProcessor.pendingStateEventList.size()) {
    pendingStateEventList.clear();
    partnerStatePreProcessor.pendingStateEventList.clear();
    if (isStartState && newAndEveryStateEventList.isEmpty()) {
      if (stateType == StateInputStream.Type.SEQUENCE && thisStatePostProcessor.nextEveryStatePerProcessor == null && !((StreamPreStateProcessor)thisStatePostProcessor.nextStatePerProcessor).pendingStateEventList.isEmpty()) {
        return;
      }
      init();
    }
  }
}
Program: 28831
Project: 28831
Buggy source:
@Override public ComplexEventChunk<StateEvent> processAndReturn(ComplexEventChunk complexEventChunk){
  ComplexEventChunk<StateEvent> returnEventChunk=new ComplexEventChunk<StateEvent>(false);
  complexEventChunk.reset();
  StreamEvent streamEvent=(StreamEvent)complexEventChunk.next();
  for (Iterator<StateEvent> iterator=pendingStateEventList.iterator(); iterator.hasNext(); ) {
    StateEvent stateEvent=iterator.next();
    if (logicalType == LogicalStateElement.Type.OR && stateEvent.getStreamEvent(partnerStatePreProcessor.getStateId()) != null) {
      iterator.remove();
      continue;
    }
    stateEvent.setEvent(stateId,streamEventCloner.copyStreamEvent(streamEvent));
    process(stateEvent);
    if (this.thisLastProcessor.isEventReturned()) {
      this.thisLastProcessor.clearProcessedEvent();
      returnEventChunk.add(stateEvent);
    }
    if (stateChanged) {
      iterator.remove();
    }
 else {
switch (stateType) {
case PATTERN:
        stateEvent.setEvent(stateId,null);
      break;
case SEQUENCE:
    stateEvent.setEvent(stateId,null);
  iterator.remove();
break;
}
}
}
return returnEventChunk;
}

Fixed version (ground truth):
@Override public ComplexEventChunk<StateEvent> processAndReturn(ComplexEventChunk complexEventChunk){
  ComplexEventChunk<StateEvent> returnEventChunk=new ComplexEventChunk<StateEvent>(false);
  complexEventChunk.reset();
  StreamEvent streamEvent=(StreamEvent)complexEventChunk.next();
  for (Iterator<StateEvent> iterator=pendingStateEventList.iterator(); iterator.hasNext(); ) {
    StateEvent stateEvent=iterator.next();
    if (withinStates.size() > 0) {
      if (isExpired(stateEvent,streamEvent)) {
        iterator.remove();
        continue;
      }
    }
    if (logicalType == LogicalStateElement.Type.OR && stateEvent.getStreamEvent(partnerStatePreProcessor.getStateId()) != null) {
      iterator.remove();
      continue;
    }
    stateEvent.setEvent(stateId,streamEventCloner.copyStreamEvent(streamEvent));
    process(stateEvent);
    if (this.thisLastProcessor.isEventReturned()) {
      this.thisLastProcessor.clearProcessedEvent();
      returnEventChunk.add(stateEvent);
    }
    if (stateChanged) {
      iterator.remove();
    }
 else {
switch (stateType) {
case PATTERN:
        stateEvent.setEvent(stateId,null);
      break;
case SEQUENCE:
    stateEvent.setEvent(stateId,null);
  iterator.remove();
break;
}
}
}
return returnEventChunk;
}
Program: 28832
Project: 28832
Buggy source:
@Override public void addState(StateEvent stateEvent){
  if (newAndEveryStateEventList.isEmpty()) {
    newAndEveryStateEventList.add(stateEvent);
  }
  if (partnerStatePreProcessor != null && partnerStatePreProcessor.newAndEveryStateEventList.isEmpty()) {
    partnerStatePreProcessor.newAndEveryStateEventList.add(stateEvent);
  }
}

Fixed version (ground truth):
@Override public void addState(StateEvent stateEvent){
  if (isStartState || stateType == StateInputStream.Type.SEQUENCE) {
    if (newAndEveryStateEventList.isEmpty()) {
      newAndEveryStateEventList.add(stateEvent);
    }
    if (partnerStatePreProcessor != null && partnerStatePreProcessor.newAndEveryStateEventList.isEmpty()) {
      partnerStatePreProcessor.newAndEveryStateEventList.add(stateEvent);
    }
  }
 else {
    newAndEveryStateEventList.add(stateEvent);
    if (partnerStatePreProcessor != null) {
      partnerStatePreProcessor.newAndEveryStateEventList.add(stateEvent);
    }
  }
}
Program: 28833
Project: 28833
Buggy source:
public void init(){
  if (isStartState) {
    StateEvent stateEvent=stateEventPool.borrowEvent();
    addState(stateEvent);
  }
}

Fixed version (ground truth):
public void init(){
  if (isStartState && (!initialized || this.thisStatePostProcessor.nextEveryStatePerProcessor != null)) {
    StateEvent stateEvent=stateEventPool.borrowEvent();
    addState(stateEvent);
    initialized=true;
  }
}
Program: 28834
Project: 28834
Buggy source:
@Override public void resetState(){
  pendingStateEventList.clear();
  if (isStartState && newAndEveryStateEventList.isEmpty()) {
    init();
  }
}

Fixed version (ground truth):
@Override public void resetState(){
  pendingStateEventList.clear();
  if (isStartState && newAndEveryStateEventList.isEmpty()) {
    if (stateType == StateInputStream.Type.SEQUENCE && thisStatePostProcessor.nextEveryStatePerProcessor == null && !((StreamPreStateProcessor)thisStatePostProcessor.nextStatePerProcessor).pendingStateEventList.isEmpty()) {
      return;
    }
    init();
  }
}
Program: 28835
Project: 28835
Buggy source:
private boolean isExpired(StateEvent pendingStateEvent,StreamEvent incomingStreamEvent){
  for (  Map.Entry<Long,Set<Integer>> withinEntry : withinStates) {
    for (    Integer withinStateId : withinEntry.getValue()) {
      if (withinStateId == SiddhiConstants.ANY) {
        if (Math.abs(pendingStateEvent.getTimestamp() - incomingStreamEvent.getTimestamp()) > withinEntry.getKey()) {
          return true;
        }
      }
 else {
        if (Math.abs(pendingStateEvent.getStreamEvent(withinStateId).getTimestamp() - incomingStreamEvent.getTimestamp()) > withinEntry.getKey()) {
          return true;
        }
      }
    }
  }
  return false;
}

Fixed version (ground truth):
protected boolean isExpired(StateEvent pendingStateEvent,StreamEvent incomingStreamEvent){
  for (  Map.Entry<Long,Set<Integer>> withinEntry : withinStates) {
    for (    Integer withinStateId : withinEntry.getValue()) {
      if (withinStateId == SiddhiConstants.ANY) {
        if (Math.abs(pendingStateEvent.getTimestamp() - incomingStreamEvent.getTimestamp()) > withinEntry.getKey()) {
          return true;
        }
      }
 else {
        if (Math.abs(pendingStateEvent.getStreamEvent(withinStateId).getTimestamp() - incomingStreamEvent.getTimestamp()) > withinEntry.getKey()) {
          return true;
        }
      }
    }
  }
  return false;
}
Program: 28837
Project: 28837
Buggy source:
/** 
 * This method uses for validate @Extension -> @ReturnAttribute elements.
 * @param returnAttributes returnA attributes array which needs to be validate.
 * @throws AnnotationValidationException whenever if the validate rule violate, throws the annotation validateexception with proper message.
 */
public void returnAttributesValidation(ReturnAttribute[] returnAttributes) throws AnnotationValidationException {
  for (  ReturnAttribute returnAttribute : returnAttributes) {
    String returnAttributeName=returnAttribute.name();
    if (returnAttributeName.isEmpty()) {
      throw new AnnotationValidationException(MessageFormat.format("String_Node_Str" + "String_Node_Str",extensionClassFullName));
    }
 else     if (!CAMEL_CASE_PATTERN.matcher(returnAttributeName).find()) {
      throw new AnnotationValidationException(MessageFormat.format("String_Node_Str" + "String_Node_Str",returnAttributeName,extensionClassFullName));
    }
    if (returnAttribute.description().isEmpty()) {
      throw new AnnotationValidationException(MessageFormat.format("String_Node_Str" + "String_Node_Str",returnAttributeName,extensionClassFullName));
    }
    if (returnAttribute.type().length == 0) {
      throw new AnnotationValidationException(MessageFormat.format("String_Node_Str" + "String_Node_Str",returnAttributeName,extensionClassFullName));
    }
  }
}

Fixed version (ground truth):
/** 
 * This method uses for validate @Extension / @ReturnAttribute elements.
 * @param returnAttributes returnA attributes array which needs to be validate.
 * @throws AnnotationValidationException whenever if the validate rule violate, throws the annotation validateexception with proper message.
 */
public void returnAttributesValidation(ReturnAttribute[] returnAttributes) throws AnnotationValidationException {
  for (  ReturnAttribute returnAttribute : returnAttributes) {
    String returnAttributeName=returnAttribute.name();
    if (returnAttributeName.isEmpty()) {
      throw new AnnotationValidationException(MessageFormat.format("String_Node_Str" + "String_Node_Str",extensionClassFullName));
    }
 else     if (!CAMEL_CASE_PATTERN.matcher(returnAttributeName).find()) {
      throw new AnnotationValidationException(MessageFormat.format("String_Node_Str" + "String_Node_Str",returnAttributeName,extensionClassFullName));
    }
    if (returnAttribute.description().isEmpty()) {
      throw new AnnotationValidationException(MessageFormat.format("String_Node_Str" + "String_Node_Str",returnAttributeName,extensionClassFullName));
    }
    if (returnAttribute.type().length == 0) {
      throw new AnnotationValidationException(MessageFormat.format("String_Node_Str" + "String_Node_Str",returnAttributeName,extensionClassFullName));
    }
  }
}
Program: 28838
Project: 28838
Buggy source:
/** 
 * This method uses for validate @Extension -> @Example elements.
 * @param examples examples array which needs to be validate.
 * @throws AnnotationValidationException whenever if the validate rule violate, throws the annotation validateexception with proper message.
 */
public void examplesValidation(Example[] examples) throws AnnotationValidationException {
  if (examples.length == 0) {
    throw new AnnotationValidationException(MessageFormat.format("String_Node_Str" + "String_Node_Str",extensionClassFullName));
  }
 else {
    for (    Example example : examples) {
      if (example.syntax().isEmpty()) {
        throw new AnnotationValidationException(MessageFormat.format("String_Node_Str" + "String_Node_Str",extensionClassFullName));
      }
      if (example.description().isEmpty()) {
        throw new AnnotationValidationException(MessageFormat.format("String_Node_Str" + "String_Node_Str",extensionClassFullName));
      }
    }
  }
}

Fixed version (ground truth):
/** 
 * This method uses for validate @Extension / @Example elements.
 * @param examples examples array which needs to be validate.
 * @throws AnnotationValidationException whenever if the validate rule violate, throws the annotation validateexception with proper message.
 */
public void examplesValidation(Example[] examples) throws AnnotationValidationException {
  if (examples.length == 0) {
    throw new AnnotationValidationException(MessageFormat.format("String_Node_Str" + "String_Node_Str",extensionClassFullName));
  }
 else {
    for (    Example example : examples) {
      if (example.syntax().isEmpty()) {
        throw new AnnotationValidationException(MessageFormat.format("String_Node_Str" + "String_Node_Str",extensionClassFullName));
      }
      if (example.description().isEmpty()) {
        throw new AnnotationValidationException(MessageFormat.format("String_Node_Str" + "String_Node_Str",extensionClassFullName));
      }
    }
  }
}
Program: 28839
Project: 28839
Buggy source:
/** 
 * This method uses for validate @Extension -> @SystemParameter elements.
 * @param systemParameters system property array which needs to be validate.
 * @throws AnnotationValidationException whenever if the validate rule violate, throws the annotation validateexception with proper message.
 */
public void systemParametersValidation(SystemParameter[] systemParameters) throws AnnotationValidationException {
  for (  SystemParameter systemParameter : systemParameters) {
    String systemParameterName=systemParameter.name();
    if (systemParameterName.isEmpty()) {
      throw new AnnotationValidationException(MessageFormat.format("String_Node_Str" + "String_Node_Str",extensionClassFullName));
    }
    if (systemParameter.description().isEmpty()) {
      throw new AnnotationValidationException(MessageFormat.format("String_Node_Str" + "String_Node_Str",systemParameterName,extensionClassFullName));
    }
    if (systemParameter.defaultValue().isEmpty()) {
      throw new AnnotationValidationException(MessageFormat.format("String_Node_Str" + "String_Node_Str",systemParameterName,extensionClassFullName));
    }
    if (systemParameter.possibleParameters().length == 0) {
      throw new AnnotationValidationException(MessageFormat.format("String_Node_Str" + "String_Node_Str" + "String_Node_Str",systemParameterName,extensionClassFullName));
    }
  }
}

Fixed version (ground truth):
/** 
 * This method uses for validate @Extension / @SystemParameter elements.
 * @param systemParameters system property array which needs to be validate.
 * @throws AnnotationValidationException whenever if the validate rule violate, throws the annotation validateexception with proper message.
 */
public void systemParametersValidation(SystemParameter[] systemParameters) throws AnnotationValidationException {
  for (  SystemParameter systemParameter : systemParameters) {
    String systemParameterName=systemParameter.name();
    if (systemParameterName.isEmpty()) {
      throw new AnnotationValidationException(MessageFormat.format("String_Node_Str" + "String_Node_Str",extensionClassFullName));
    }
    if (systemParameter.description().isEmpty()) {
      throw new AnnotationValidationException(MessageFormat.format("String_Node_Str" + "String_Node_Str",systemParameterName,extensionClassFullName));
    }
    if (systemParameter.defaultValue().isEmpty()) {
      throw new AnnotationValidationException(MessageFormat.format("String_Node_Str" + "String_Node_Str",systemParameterName,extensionClassFullName));
    }
    if (systemParameter.possibleParameters().length == 0) {
      throw new AnnotationValidationException(MessageFormat.format("String_Node_Str" + "String_Node_Str" + "String_Node_Str",systemParameterName,extensionClassFullName));
    }
  }
}