nus-yam/ex-repair huggingface dataset:
Program: 167401
Project: 167401
Buggy source:
private int execute(ISqlTransaction transaction,DmlStatement dmlStatement,Object marker,Object[] data){
  String sql=dmlStatement.getSql();
  if (!sql.equals(lastPreparedDml)) {
    transaction.flush();
    if (log.isDebugEnabled()) {
      log.debug("String_Node_Str",sql);
    }
    transaction.prepare(sql);
    lastPreparedDml=sql;
  }
  if (log.isDebugEnabled()) {
    log.debug("String_Node_Str",Arrays.toString(data),Arrays.toString(dmlStatement.getTypes()));
  }
  try {
    return transaction.addRow(marker,data,dmlStatement.getTypes());
  }
 catch (  SqlException ex) {
    if (!(continueOnError || (replaceRows && ex instanceof UniqueKeyException))) {
      log(LogLevel.WARN,String.format("String_Node_Str",dmlStatement.getSql(),Arrays.toString(data),Arrays.toString(dmlStatement.getTypes())));
    }
    throw ex;
  }
}

Fixed version (ground truth):
private int execute(ISqlTransaction transaction,DmlStatement dmlStatement,Object marker,Object[] data){
  String sql=dmlStatement.getSql();
  if (!sql.equals(lastPreparedDml)) {
    transaction.flush();
    if (log.isDebugEnabled()) {
      log.debug("String_Node_Str",sql);
    }
    transaction.prepare(sql);
    lastPreparedDml=sql;
  }
  if (log.isDebugEnabled()) {
    log.debug("String_Node_Str",Arrays.toString(data),Arrays.toString(dmlStatement.getTypes()));
  }
  try {
    return transaction.addRow(marker,data,dmlStatement.getTypes());
  }
 catch (  SqlException ex) {
    if (!(replaceRows && ex instanceof UniqueKeyException)) {
      if (continueOnError) {
        log(LogLevel.WARN,String.format("String_Node_Str" + "String_Node_Str",dmlStatement.getSql(),Arrays.toString(data),Arrays.toString(dmlStatement.getTypes())));
        return 0;
      }
 else {
        log(LogLevel.ERROR,String.format("String_Node_Str",dmlStatement.getSql(),Arrays.toString(data),Arrays.toString(dmlStatement.getTypes())));
        throw ex;
      }
    }
 else {
      throw ex;
    }
  }
}
Program: 167402
Project: 167402
Buggy source:
public void setSource(Object obj){
  value=obj;
  editButton.setVisible(hasAdvancedEditor());
  FormLayout formLayout=new FormLayout();
  formLayout.setWidth(100,Unit.PERCENTAGE);
  formLayout.setMargin(false);
  formLayout.addStyleName(ValoTheme.FORMLAYOUT_LIGHT);
  if (obj != null) {
    if (obj instanceof FlowStep) {
      obj=((FlowStep)obj).getComponent();
    }
    if (obj instanceof Component) {
      Component component=(Component)obj;
      context.getConfigurationService().refresh(component);
      addComponentProperties(formLayout,component);
    }
    if (obj instanceof Resource) {
      Resource resource=(Resource)obj;
      context.getConfigurationService().refresh(resource);
      addResourceProperties(formLayout,resource);
    }
    if (obj instanceof AbstractObjectWithSettings) {
      List<XMLSetting> settings=buildSettings(obj);
      if (settings != null) {
        for (        XMLSetting definition : settings) {
          addSettingField(definition,(AbstractObjectWithSettings)obj,formLayout);
        }
      }
    }
    if (obj instanceof Component) {
      Component component=(Component)obj;
      XMLComponent componentDefintion=context.getComponentFactory().getComonentDefinition(component.getType());
      addThreadCount(componentDefintion,formLayout,component);
      addComponentShared(formLayout,component);
    }
  }
  panel.setContent(formLayout);
}

Fixed version (ground truth):
public void setSource(Object obj){
  value=obj;
  editButton.setVisible(hasAdvancedEditor());
  FormLayout formLayout=new FormLayout();
  formLayout.setWidth(100,Unit.PERCENTAGE);
  formLayout.setMargin(false);
  formLayout.addStyleName(ValoTheme.FORMLAYOUT_LIGHT);
  if (obj != null) {
    if (obj instanceof FlowStep) {
      obj=((FlowStep)obj).getComponent();
    }
    if (obj instanceof Component) {
      Component component=(Component)obj;
      context.getConfigurationService().refresh(component);
      addComponentProperties(formLayout,component);
    }
    if (obj instanceof Resource) {
      Resource resource=(Resource)obj;
      addResourceProperties(formLayout,resource);
    }
    if (obj instanceof AbstractObjectWithSettings) {
      List<XMLSetting> settings=buildSettings(obj);
      if (settings != null) {
        for (        XMLSetting definition : settings) {
          addSettingField(definition,(AbstractObjectWithSettings)obj,formLayout);
        }
      }
    }
    if (obj instanceof Component) {
      Component component=(Component)obj;
      XMLComponent componentDefintion=context.getComponentFactory().getComonentDefinition(component.getType());
      addThreadCount(componentDefintion,formLayout,component);
      addComponentShared(formLayout,component);
    }
  }
  panel.setContent(formLayout);
}
Program: 167404
Project: 167404
Buggy source:
protected Field<?> buildEditableNavigatorField(Object itemId){
  if (itemBeingEdited != null && itemBeingEdited.equals(itemId)) {
    final EnableFocusTextField field=new EnableFocusTextField();
    field.addStyleName(ValoTheme.TEXTFIELD_SMALL);
    field.setImmediate(true);
    field.addFocusListener(new FocusListener(){
      @Override public void focus(      FocusEvent event){
        field.setFocusAllowed(false);
        field.selectAll();
        field.setFocusAllowed(true);
      }
    }
);
    field.focus();
    field.addShortcutListener(new ShortcutListener("String_Node_Str",KeyCode.ESCAPE,null){
      @Override public void handleAction(      Object sender,      Object target){
        abortEditingItem();
      }
    }
);
    field.addValueChangeListener(event -> finishEditingItem());
    field.addBlurListener(new BlurListener(){
      @Override public void blur(      BlurEvent event){
        finishEditingItem();
      }
    }
);
    return field;
  }
 else {
    return null;
  }
}

Fixed version (ground truth):
protected Field<?> buildEditableNavigatorField(Object itemId){
  if (itemBeingEdited != null && itemBeingEdited.equals(itemId)) {
    final EnableFocusTextField field=new EnableFocusTextField();
    field.addStyleName(ValoTheme.TEXTFIELD_SMALL);
    field.setImmediate(true);
    field.addFocusListener(new FocusListener(){
      @Override public void focus(      FocusEvent event){
        field.setFocusAllowed(false);
        field.selectAll();
        field.setFocusAllowed(true);
      }
    }
);
    field.focus();
    field.addShortcutListener(new ShortcutListener("String_Node_Str",KeyCode.ESCAPE,null){
      @Override public void handleAction(      Object sender,      Object target){
        abortEditingItem();
      }
    }
);
    field.addValueChangeListener(event -> finishEditingItem());
    field.addBlurListener(event -> finishEditingItem());
    return field;
  }
 else {
    return null;
  }
}
Program: 167405
Project: 167405
Buggy source:
@Override public void deselected(){
  treeTable.removeShortcutListener(enterKeyListener);
}

Fixed version (ground truth):
@Override public void deselected(){
}
Program: 167407
Project: 167407
Buggy source:
@Override public void selected(){
  treeTable.addShortcutListener(enterKeyListener);
}

Fixed version (ground truth):
@Override public void selected(){
}
Program: 167409
Project: 167409
Buggy source:
@Override public void afterFlow(){
  super.afterFlow();
  Execution execution=getExecution();
  execution.setEndTime(new Date());
  ExecutionStatus status=ExecutionStatus.DONE;
  if (steps != null) {
    for (    ExecutionStep executionStep : steps.values()) {
      if (ExecutionStatus.ERROR.name().equals(executionStep.getStatus())) {
        status=ExecutionStatus.ERROR;
      }
      if (ExecutionStatus.CANCELLED.name().equals(executionStep.getStatus())) {
        status=ExecutionStatus.CANCELLED;
      }
    }
  }
  execution.setStatus(status.name());
  this.recorder.record(execution);
}

Fixed version (ground truth):
@Override public void afterFlow(){
  super.afterFlow();
  Execution execution=getExecution();
  execution.setEndTime(new Date());
  ExecutionStatus status=ExecutionStatus.DONE;
  if (steps != null) {
    for (    ExecutionStep executionStep : steps.values()) {
      if (ExecutionStatus.ERROR.name().equals(executionStep.getStatus())) {
        status=ExecutionStatus.ERROR;
      }
      if (status != ExecutionStatus.ERROR && ExecutionStatus.CANCELLED.name().equals(executionStep.getStatus())) {
        status=ExecutionStatus.CANCELLED;
      }
    }
  }
  execution.setStatus(status.name());
  this.recorder.record(execution);
}
Program: 167410
Project: 167410
Buggy source:
@SuppressWarnings("String_Node_Str") protected void handleStringListPayload(Message inputMessage,ISendMessageCallback callback,boolean unitOfWorkBoundaryReached){
  Map<String,ArrayList<String>> outboundMessages=new HashMap<String,ArrayList<String>>();
  ArrayList<String> inputDatas=(ArrayList<String>)inputMessage.getPayload();
  for (  String data : inputDatas) {
    getComponentStatistics().incrementNumberEntitiesProcessed(threadNumber);
    bindStringData(scriptEngine,data);
    if (routes != null) {
      for (      Route route : routes) {
        try {
          if (Boolean.TRUE.equals(scriptEngine.eval(route.getMatchExpression()))) {
            ArrayList<String> outboundPayload=outboundMessages.get(route.getTargetStepId());
            if (outboundPayload == null) {
              outboundPayload=new ArrayList<String>();
              outboundMessages.put(route.getTargetStepId(),outboundPayload);
            }
            if (outboundPayload.size() >= rowsPerMessage) {
              outboundMessages.remove(route.getTargetStepId());
              callback.sendMessage(null,outboundPayload,false,route.getTargetStepId());
            }
            outboundPayload.add(data);
          }
        }
 catch (        ScriptException e) {
          throw new RuntimeException(e);
        }
      }
    }
  }
  for (  String targetFlowStepId : outboundMessages.keySet()) {
    callback.sendMessage(null,outboundMessages.get(targetFlowStepId),true,targetFlowStepId);
  }
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") protected void handleStringListPayload(Message inputMessage,ISendMessageCallback callback,boolean unitOfWorkBoundaryReached){
  Map<String,ArrayList<String>> outboundMessages=new HashMap<String,ArrayList<String>>();
  ArrayList<String> inputDatas=(ArrayList<String>)inputMessage.getPayload();
  for (  String data : inputDatas) {
    getComponentStatistics().incrementNumberEntitiesProcessed(threadNumber);
    bindStringData(scriptEngine,data);
    if (routes != null) {
      for (      Route route : routes) {
        try {
          if (Boolean.TRUE.equals(scriptEngine.eval(route.getMatchExpression()))) {
            ArrayList<String> outboundPayload=outboundMessages.get(route.getTargetStepId());
            if (outboundPayload == null) {
              outboundPayload=new ArrayList<String>();
              outboundMessages.put(route.getTargetStepId(),outboundPayload);
            }
            if (outboundPayload.size() >= rowsPerMessage) {
              outboundMessages.remove(route.getTargetStepId());
              callback.sendMessage(null,outboundPayload,false,route.getTargetStepId());
            }
            outboundPayload.add(data);
          }
        }
 catch (        ScriptException e) {
          throw new RuntimeException(e);
        }
      }
    }
  }
  for (  String targetFlowStepId : outboundMessages.keySet()) {
    callback.sendMessage(null,outboundMessages.get(targetFlowStepId),unitOfWorkBoundaryReached,targetFlowStepId);
  }
}
Program: 167411
Project: 167411
Buggy source:
private boolean isUnitOfWorkLastMessage(String unitOfWork,boolean lastMessage){
  if (unitOfWork.equalsIgnoreCase(UNIT_OF_WORK_INPUT_MESSAGE) || (unitOfWork.equalsIgnoreCase(UNIT_OF_WORK_FLOW) && lastMessage)) {
    return true;
  }
 else {
    return false;
  }
}

Fixed version (ground truth):
private boolean isUnitOfWorkLastMessage(boolean lastMessage){
  FlowStep flowStep=componentContext.getFlowStep();
  String unitOfWork=flowStep.getComponent().get(UNIT_OF_WORK,UNIT_OF_WORK_FLOW);
  if (unitOfWork.equalsIgnoreCase(UNIT_OF_WORK_INPUT_MESSAGE) || (unitOfWork.equalsIgnoreCase(UNIT_OF_WORK_FLOW) && lastMessage)) {
    return true;
  }
 else {
    return false;
  }
}
Program: 167412
Project: 167412
Buggy source:
@Override public void sendControlMessage(){
  FlowStep flowStep=componentContext.getFlowStep();
  sendMessage(new ControlMessage(flowStep.getId()));
}

Fixed version (ground truth):
@Override public void sendControlMessage(){
  FlowStep flowStep=componentContext.getFlowStep();
  sendMessage(createMessage(new ControlMessage(flowStep.getId()),null,null,true));
}
Program: 167413
Project: 167413
Buggy source:
private Message createMessage(Message newMessage,Map<String,Serializable> headerSettings,Serializable payload,boolean lastMessage){
  FlowStep flowStep=componentContext.getFlowStep();
  ComponentStatistics statistics=componentContext.getComponentStatistics();
  String unitOfWork=flowStep.getComponent().get(UNIT_OF_WORK,UNIT_OF_WORK_FLOW);
  MessageHeader header=newMessage.getHeader();
  Message inputMessage=currentInputMessages.get(ThreadUtils.getThreadNumber());
  if (inputMessage != null) {
    header.putAll(inputMessage.getHeader());
  }
  if (headerSettings != null) {
    header.putAll(headerSettings);
  }
  header.setUnitOfWorkLastMessage(isUnitOfWorkLastMessage(unitOfWork,lastMessage));
  header.setSequenceNumber(statistics.getNumberOutboundMessages(ThreadUtils.getThreadNumber()) + 1);
  newMessage.setPayload(payload);
  return newMessage;
}

Fixed version (ground truth):
private Message createMessage(Message newMessage,Map<String,Serializable> headerSettings,Serializable payload,boolean lastMessage){
  ComponentStatistics statistics=componentContext.getComponentStatistics();
  MessageHeader header=newMessage.getHeader();
  Message inputMessage=currentInputMessages.get(ThreadUtils.getThreadNumber());
  if (inputMessage != null) {
    header.putAll(inputMessage.getHeader());
  }
  if (headerSettings != null) {
    header.putAll(headerSettings);
  }
  header.setUnitOfWorkLastMessage(isUnitOfWorkLastMessage(lastMessage));
  header.setSequenceNumber(statistics.getNumberOutboundMessages(ThreadUtils.getThreadNumber()) + 1);
  newMessage.setPayload(payload);
  return newMessage;
}
Program: 167414
Project: 167414
Buggy source:
public Row toRow(EntityData data,boolean qualifyWithEntityName){
  Row row=new Row(data.size()){
    private static final long serialVersionUID=1L;
    @Override public String toString(){
      return String.format("String_Node_Str",data.getChangeType(),super.toString());
    }
  }
;
  Set<String> attributeIds=data.keySet();
  for (  String attributeId : attributeIds) {
    if (inputModel != null) {
      ModelAttribute attribute=inputModel.getAttributeById(attributeId);
      if (attribute != null) {
        ModelEntity entity=inputModel.getEntityById(attribute.getEntityId());
        if (qualifyWithEntityName) {
          row.put(entity.getName() + "String_Node_Str" + attribute.getName(),data.get(attributeId));
        }
 else {
          row.put(attribute.getName(),data.get(attributeId));
        }
      }
    }
 else {
      row.put(attributeId,data.get(attributeId));
    }
  }
  return row;
}

Fixed version (ground truth):
public Row toRow(EntityData data,boolean qualifyWithEntityName,boolean input){
  Row row=new Row(data.size()){
    private static final long serialVersionUID=1L;
    @Override public String toString(){
      return String.format("String_Node_Str",data.getChangeType(),super.toString());
    }
  }
;
  Model model=input ? inputModel : outputModel;
  Set<String> attributeIds=data.keySet();
  for (  String attributeId : attributeIds) {
    if (model != null) {
      ModelAttribute attribute=model.getAttributeById(attributeId);
      if (attribute != null) {
        ModelEntity entity=model.getEntityById(attribute.getEntityId());
        if (qualifyWithEntityName) {
          row.put(entity.getName() + "String_Node_Str" + attribute.getName(),data.get(attributeId));
        }
 else {
          row.put(attribute.getName(),data.get(attributeId));
        }
      }
    }
 else {
      row.put(attributeId,data.get(attributeId));
    }
  }
  return row;
}
Program: 167415
Project: 167415
Buggy source:
public Set<String> getEntityNames(EntityData data){
  Set<String> names=new HashSet<String>();
  Set<String> attributeIds=data.keySet();
  for (  String attributeId : attributeIds) {
    ModelAttribute attribute=inputModel.getAttributeById(attributeId);
    if (attribute != null) {
      ModelEntity entity=inputModel.getEntityById(attribute.getEntityId());
      names.add(entity.getName());
    }
  }
  return names;
}

Fixed version (ground truth):
public Set<String> getEntityNames(EntityData data,boolean input){
  Set<String> names=new HashSet<String>();
  Model model=input ? inputModel : outputModel;
  if (model != null) {
    Set<String> attributeIds=data.keySet();
    for (    String attributeId : attributeIds) {
      ModelAttribute attribute=model.getAttributeById(attributeId);
      if (attribute != null) {
        ModelEntity entity=model.getEntityById(attribute.getEntityId());
        names.add(entity.getName());
      }
    }
  }
  return names;
}
Program: 167416
Project: 167416
Buggy source:
protected Bindings bindEntityData(ScriptEngine scriptEngine,EntityData entityData){
  Bindings bindings=scriptEngine.createBindings();
  Model model=context.getFlowStep().getComponent().getInputModel();
  List<ModelEntity> entities=model.getModelEntities();
  for (  ModelEntity modelEntity : entities) {
    HashMap<String,Object> boundEntity=new HashMap<String,Object>();
    bindings.put(modelEntity.getName(),boundEntity);
  }
  bindings.put("String_Node_Str",context.getFlowStep().getComponent().getEntityNames(entityData));
  Set<String> attributeIds=entityData.keySet();
  for (  String attributeId : attributeIds) {
    ModelAttribute attribute=model.getAttributeById(attributeId);
    if (attribute != null) {
      ModelEntity entity=model.getEntityById(attribute.getEntityId());
      Object value=entityData.get(attributeId);
      @SuppressWarnings("String_Node_Str") Map<String,Object> boundEntity=(Map<String,Object>)bindings.get(entity.getName());
      boundEntity.put(attribute.getName(),value);
    }
 else {
      log(LogLevel.WARN,"String_Node_Str" + attributeId);
    }
  }
  scriptEngine.setBindings(bindings,ScriptContext.ENGINE_SCOPE);
  return bindings;
}

Fixed version (ground truth):
protected Bindings bindEntityData(ScriptEngine scriptEngine,EntityData entityData){
  Bindings bindings=scriptEngine.createBindings();
  Model model=context.getFlowStep().getComponent().getInputModel();
  List<ModelEntity> entities=model.getModelEntities();
  for (  ModelEntity modelEntity : entities) {
    HashMap<String,Object> boundEntity=new HashMap<String,Object>();
    bindings.put(modelEntity.getName(),boundEntity);
  }
  bindings.put("String_Node_Str",entityData.getChangeType().name());
  bindings.put("String_Node_Str",context.getFlowStep().getComponent().getEntityNames(entityData,true));
  Set<String> attributeIds=entityData.keySet();
  for (  String attributeId : attributeIds) {
    ModelAttribute attribute=model.getAttributeById(attributeId);
    if (attribute != null) {
      ModelEntity entity=model.getEntityById(attribute.getEntityId());
      Object value=entityData.get(attributeId);
      @SuppressWarnings("String_Node_Str") Map<String,Object> boundEntity=(Map<String,Object>)bindings.get(entity.getName());
      boundEntity.put(attribute.getName(),value);
    }
 else {
      log(LogLevel.WARN,"String_Node_Str" + attributeId);
    }
  }
  scriptEngine.setBindings(bindings,ScriptContext.ENGINE_SCOPE);
  return bindings;
}
Program: 167417
Project: 167417
Buggy source:
@Override public void handle(Message inputMessage,ISendMessageCallback callback,boolean unitOfWorkBoundaryReached){
  MessageHeader header=inputMessage.getHeader();
  log(LogLevel.INFO,String.format("String_Node_Str",inputMessage.getClass().getSimpleName(),header.getSequenceNumber(),header.isUnitOfWorkLastMessage(),unitOfWorkBoundaryReached,getFlow().findFlowStepWithId(header.getOriginatingStepId()).getName(),header.toString()));
  Serializable payload=inputMessage.getPayload();
  if (payload instanceof List) {
    @SuppressWarnings("String_Node_Str") List<Object> list=(List<Object>)payload;
    for (    Object object : list) {
      if (object instanceof EntityData && getComponent().getInputModel() != null) {
        getComponentStatistics().incrementNumberEntitiesProcessed(threadNumber);
        log(LogLevel.INFO,String.format("String_Node_Str",getComponent().toRow((EntityData)object,context.getFlowStep().getComponent().getBoolean(SETTING_QUALIFY_WITH_ENTITY_NAME,true))));
      }
 else {
        getComponentStatistics().incrementNumberEntitiesProcessed(threadNumber);
        log(LogLevel.INFO,String.format("String_Node_Str",object));
      }
    }
  }
  callback.sendMessage(null,payload,unitOfWorkBoundaryReached);
}

Fixed version (ground truth):
@Override public void handle(Message inputMessage,ISendMessageCallback callback,boolean unitOfWorkBoundaryReached){
  MessageHeader header=inputMessage.getHeader();
  log(LogLevel.INFO,String.format("String_Node_Str",inputMessage.getClass().getSimpleName(),header.getSequenceNumber(),header.isUnitOfWorkLastMessage(),unitOfWorkBoundaryReached,getFlow().findFlowStepWithId(header.getOriginatingStepId()).getName(),header.toString()));
  Serializable payload=inputMessage.getPayload();
  if (payload instanceof List) {
    @SuppressWarnings("String_Node_Str") List<Object> list=(List<Object>)payload;
    for (    Object object : list) {
      if (object instanceof EntityData && getComponent().getInputModel() != null) {
        getComponentStatistics().incrementNumberEntitiesProcessed(threadNumber);
        log(LogLevel.INFO,String.format("String_Node_Str",getComponent().toRow((EntityData)object,context.getFlowStep().getComponent().getBoolean(SETTING_QUALIFY_WITH_ENTITY_NAME,true),true)));
      }
 else {
        getComponentStatistics().incrementNumberEntitiesProcessed(threadNumber);
        log(LogLevel.INFO,String.format("String_Node_Str",object));
      }
    }
  }
  callback.sendMessage(null,payload,unitOfWorkBoundaryReached);
}
Program: 167418
Project: 167418
Buggy source:
protected Row nextRowFromInputMessage(){
  if (flowStep.getComponent().getInputModel() != null) {
    if (entityDataIterator == null) {
      List<EntityData> list=inputMessage.getPayload();
      entityDataIterator=list.iterator();
    }
    if (entityDataIterator.hasNext()) {
      EntityData data=entityDataIterator.next();
      return flowStep.getComponent().toRow(data,false);
    }
 else {
      return null;
    }
  }
 else {
    throw new IllegalStateException("String_Node_Str");
  }
}

Fixed version (ground truth):
protected Row nextRowFromInputMessage(){
  if (flowStep.getComponent().getInputModel() != null) {
    if (entityDataIterator == null) {
      List<EntityData> list=inputMessage.getPayload();
      entityDataIterator=list.iterator();
    }
    if (entityDataIterator.hasNext()) {
      EntityData data=entityDataIterator.next();
      return flowStep.getComponent().toRow(data,false,true);
    }
 else {
      return null;
    }
  }
 else {
    throw new IllegalStateException("String_Node_Str");
  }
}
Program: 167419
Project: 167419
Buggy source:
protected void setParamsFromInboundMsgAndRec(Map<String,Object> paramMap,final Message inputMessage,final EntityData entityData){
  paramMap.clear();
  paramMap.putAll(getParamsFromHeader(inputMessage));
  if (entityData != null) {
    paramMap.putAll(this.getComponent().toRow(entityData,true));
  }
}

Fixed version (ground truth):
protected void setParamsFromInboundMsgAndRec(Map<String,Object> paramMap,final Message inputMessage,final EntityData entityData){
  paramMap.clear();
  paramMap.putAll(getParamsFromHeader(inputMessage));
  if (entityData != null) {
    paramMap.putAll(this.getComponent().toRow(entityData,true,true));
  }
}
Program: 167420
Project: 167420
Buggy source:
private int processSql(Message inputMessage,NamedParameterJdbcTemplate template,Map<String,Object> params,String sqlToExecute){
  int sqlCount=0;
  if (runWhen.equals(PER_MESSAGE)) {
    int count=template.update(sqlToExecute,params);
    results.add(new Result(sqlToExecute,count));
    getComponentStatistics().incrementNumberEntitiesProcessed(count);
    sqlCount++;
  }
 else   if (runWhen.equals(PER_ENTITY)) {
    List<EntityData> datas=inputMessage.getPayload();
    for (    EntityData entityData : datas) {
      params.putAll(getComponent().toRow(entityData,false));
      int count=template.update(sqlToExecute,params);
      results.add(new Result(sqlToExecute,count));
      getComponentStatistics().incrementNumberEntitiesProcessed(count);
      sqlCount++;
    }
  }
  return sqlCount;
}

Fixed version (ground truth):
private int processSql(Message inputMessage,NamedParameterJdbcTemplate template,Map<String,Object> params,String sqlToExecute){
  int sqlCount=0;
  if (runWhen.equals(PER_MESSAGE)) {
    int count=template.update(sqlToExecute,params);
    results.add(new Result(sqlToExecute,count));
    getComponentStatistics().incrementNumberEntitiesProcessed(count);
    sqlCount++;
  }
 else   if (runWhen.equals(PER_ENTITY)) {
    List<EntityData> datas=inputMessage.getPayload();
    for (    EntityData entityData : datas) {
      params.putAll(getComponent().toRow(entityData,false,true));
      int count=template.update(sqlToExecute,params);
      results.add(new Result(sqlToExecute,count));
      getComponentStatistics().incrementNumberEntitiesProcessed(count);
      sqlCount++;
    }
  }
  return sqlCount;
}
Program: 167421
Project: 167421
Buggy source:
protected void logInput(Message inputMessage,ISendMessageCallback messageTarget,boolean unitOfWorkBoundaryReached){
  MessageHeader header=inputMessage.getHeader();
  int threadNumber=ThreadUtils.getThreadNumber();
  String source="String_Node_Str";
  try {
    source=componentContext.getManipulatedFlow().findFlowStepWithId(header.getOriginatingStepId()).getName();
  }
 catch (  NullPointerException e) {
  }
  componentContext.getExecutionTracker().log(threadNumber,LogLevel.INFO,componentContext,String.format("String_Node_Str",inputMessage.getClass().getSimpleName(),header.getSequenceNumber(),header.isUnitOfWorkLastMessage(),unitOfWorkBoundaryReached,source,header));
  Serializable payload=inputMessage.getPayload();
  if (payload instanceof List) {
    @SuppressWarnings("String_Node_Str") List<Object> list=(List<Object>)payload;
    for (    Object object : list) {
      if (object instanceof EntityData && componentContext.getFlowStep().getComponent().getInputModel() != null) {
        componentContext.getExecutionTracker().log(threadNumber,LogLevel.INFO,componentContext,String.format("String_Node_Str",componentContext.getFlowStep().getComponent().toRow((EntityData)object,true)));
      }
 else {
        componentContext.getExecutionTracker().log(threadNumber,LogLevel.INFO,componentContext,String.format("String_Node_Str",object));
      }
    }
  }
}

Fixed version (ground truth):
protected void logInput(Message inputMessage,ISendMessageCallback messageTarget,boolean unitOfWorkBoundaryReached){
  MessageHeader header=inputMessage.getHeader();
  int threadNumber=ThreadUtils.getThreadNumber();
  String source="String_Node_Str";
  try {
    source=componentContext.getManipulatedFlow().findFlowStepWithId(header.getOriginatingStepId()).getName();
  }
 catch (  NullPointerException e) {
  }
  componentContext.getExecutionTracker().log(threadNumber,LogLevel.INFO,componentContext,String.format("String_Node_Str",inputMessage.getClass().getSimpleName(),header.getSequenceNumber(),header.isUnitOfWorkLastMessage(),unitOfWorkBoundaryReached,source,header));
  Serializable payload=inputMessage.getPayload();
  if (payload instanceof List) {
    @SuppressWarnings("String_Node_Str") List<Object> list=(List<Object>)payload;
    for (    Object object : list) {
      if (object instanceof EntityData && componentContext.getFlowStep().getComponent().getInputModel() != null) {
        componentContext.getExecutionTracker().log(threadNumber,LogLevel.INFO,componentContext,String.format("String_Node_Str",componentContext.getFlowStep().getComponent().toRow((EntityData)object,true,true)));
      }
 else {
        componentContext.getExecutionTracker().log(threadNumber,LogLevel.INFO,componentContext,String.format("String_Node_Str",object));
      }
    }
  }
}
Program: 167422
Project: 167422
Buggy source:
protected void logOutput(Message message,String... targetFlowStepIds){
  Collection<String> targetStepIds=targetFlowStepIds != null ? Arrays.asList(targetFlowStepIds) : Collections.emptyList();
  int threadNumber=ThreadUtils.getThreadNumber();
  for (  StepRuntime targetRuntime : targetStepRuntimes) {
    boolean forward=targetStepIds == null || targetStepIds.size() == 0 || targetStepIds.contains(targetRuntime.getComponentContext().getFlowStep().getId());
    if (forward) {
      MessageHeader header=message.getHeader();
      componentContext.getExecutionTracker().log(threadNumber,LogLevel.INFO,componentContext,String.format("String_Node_Str",message.getClass().getSimpleName(),header.getSequenceNumber(),header.isUnitOfWorkLastMessage(),header));
      Serializable payload=message.getPayload();
      if (payload instanceof List) {
        @SuppressWarnings("String_Node_Str") List<Object> list=(List<Object>)payload;
        for (        Object object : list) {
          if (object instanceof EntityData) {
            componentContext.getExecutionTracker().log(threadNumber,LogLevel.INFO,componentContext,String.format("String_Node_Str",componentContext.getFlowStep().getComponent().toRow((EntityData)object,true)));
          }
 else {
            componentContext.getExecutionTracker().log(threadNumber,LogLevel.INFO,componentContext,String.format("String_Node_Str",object));
          }
        }
      }
    }
  }
}

Fixed version (ground truth):
protected void logOutput(Message message,String... targetFlowStepIds){
  Collection<String> targetStepIds=targetFlowStepIds != null ? Arrays.asList(targetFlowStepIds) : Collections.emptyList();
  int threadNumber=ThreadUtils.getThreadNumber();
  for (  StepRuntime targetRuntime : targetStepRuntimes) {
    boolean forward=targetStepIds == null || targetStepIds.size() == 0 || targetStepIds.contains(targetRuntime.getComponentContext().getFlowStep().getId());
    if (forward) {
      MessageHeader header=message.getHeader();
      componentContext.getExecutionTracker().log(threadNumber,LogLevel.INFO,componentContext,String.format("String_Node_Str",message.getClass().getSimpleName(),header.getSequenceNumber(),header.isUnitOfWorkLastMessage(),header));
      Serializable payload=message.getPayload();
      if (payload instanceof List) {
        @SuppressWarnings("String_Node_Str") List<Object> list=(List<Object>)payload;
        for (        Object object : list) {
          if (object instanceof EntityData) {
            componentContext.getExecutionTracker().log(threadNumber,LogLevel.INFO,componentContext,String.format("String_Node_Str",componentContext.getFlowStep().getComponent().toRow((EntityData)object,true,false)));
          }
 else {
            componentContext.getExecutionTracker().log(threadNumber,LogLevel.INFO,componentContext,String.format("String_Node_Str",object));
          }
        }
      }
    }
  }
}
Program: 167425
Project: 167425
Buggy source:
@Override public ProjectVersion findProjectVersion(String projectVersionId){
  ProjectVersion projectVersion=new ProjectVersion(projectVersionId);
  refresh(projectVersion);
  return projectVersion;
}

Fixed version (ground truth):
@Override public ProjectVersion findProjectVersion(String projectVersionId){
  Map<String,Object> params=new HashMap<>();
  params.put("String_Node_Str",projectVersionId);
  ProjectVersion projectVersion=findOne(ProjectVersion.class,params);
  if (projectVersion != null) {
    refresh(projectVersion);
  }
  return projectVersion;
}
Program: 167427
Project: 167427
Buggy source:
@Override public void handle(Message inputMessage,ISendMessageCallback callback,boolean unitOfWorkBoundaryReached){
  ArrayList<EntityData> inputRows=inputMessage.getPayload();
  if (inputRows == null) {
    return;
  }
  ArrayList<EntityData> outputPayload=new ArrayList<EntityData>();
  for (  EntityData inputRow : inputRows) {
    EntityData outputRow=new EntityData();
    for (    Entry<String,Object> attrEntry : inputRow.entrySet()) {
      Set<String> newAttrIds=attrToAttrMap.get(attrEntry.getKey());
      if (newAttrIds != null) {
        for (        String newAttrId : newAttrIds) {
          outputRow.put(newAttrId,attrEntry.getValue());
        }
      }
    }
    if (setUnmappedAttributesToNull) {
      for (      ModelEntity entity : getComponent().getOutputModel().getModelEntities()) {
        for (        ModelAttribute attr : entity.getModelAttributes()) {
          if (!outputRow.containsKey(attr.getId())) {
            outputRow.put(attr.getId(),null);
          }
        }
      }
    }
    if (outputRow.size() > 0) {
      outputPayload.add(outputRow);
      getComponentStatistics().incrementNumberEntitiesProcessed(threadNumber);
    }
  }
  callback.sendMessage(null,outputPayload,unitOfWorkBoundaryReached);
}

Fixed version (ground truth):
@Override public void handle(Message inputMessage,ISendMessageCallback callback,boolean unitOfWorkBoundaryReached){
  ArrayList<EntityData> inputRows=inputMessage.getPayload();
  if (inputRows == null) {
    return;
  }
  ArrayList<EntityData> outputPayload=new ArrayList<EntityData>();
  for (  EntityData inputRow : inputRows) {
    EntityData outputRow=new EntityData();
    outputRow.setChangeType(inputRow.getChangeType());
    for (    Entry<String,Object> attrEntry : inputRow.entrySet()) {
      Set<String> newAttrIds=attrToAttrMap.get(attrEntry.getKey());
      if (newAttrIds != null) {
        for (        String newAttrId : newAttrIds) {
          outputRow.put(newAttrId,attrEntry.getValue());
        }
      }
    }
    if (setUnmappedAttributesToNull) {
      for (      ModelEntity entity : getComponent().getOutputModel().getModelEntities()) {
        for (        ModelAttribute attr : entity.getModelAttributes()) {
          if (!outputRow.containsKey(attr.getId())) {
            outputRow.put(attr.getId(),null);
          }
        }
      }
    }
    if (outputRow.size() > 0) {
      outputPayload.add(outputRow);
      getComponentStatistics().incrementNumberEntitiesProcessed(threadNumber);
    }
  }
  callback.sendMessage(null,outputPayload,unitOfWorkBoundaryReached);
}
Program: 167428
Project: 167428
Buggy source:
@Override public ArrayList<EntityData> extractData(ResultSet rs) throws SQLException, DataAccessException {
  ResultSetMetaData meta=rs.getMetaData();
  Map<Integer,String> columnHints=getSqlColumnEntityHints(sqlToExecute);
  ArrayList<String> attributeIds=getAttributeIds(meta,columnHints);
  long ts=System.currentTimeMillis();
  while (rs.next()) {
    if (outputRecCount++ % rowsPerMessage == 0 && payload != null) {
      callback.sendMessage(null,payload,false);
      payload=null;
    }
    if (payload == null) {
      payload=new ArrayList<>();
    }
    getComponentStatistics().incrementNumberEntitiesProcessed(threadNumber);
    EntityData rowData=new EntityData();
    rowData.setChangeType(entityChangeType);
    for (int i=1; i <= meta.getColumnCount(); i++) {
      String attributeId=attributeIds.get(i - 1);
      if (isNotBlank(attributeId)) {
        Object value=JdbcUtils.getResultSetValue(rs,i);
        if (trimColumns && value instanceof String) {
          value=value.toString().trim();
        }
        rowData.put(attributeId,value);
      }
    }
    payload.add(rowData);
    if (context.getDeployment() != null && context.getDeployment().asLogLevel() == LogLevel.DEBUG) {
      logEntityAttributes(rowData);
    }
    long newTs=System.currentTimeMillis();
    if (newTs - ts > 10000) {
      getExecutionTracker().updateStatistics(threadNumber,context);
      ts=newTs;
    }
  }
  return payload;
}

Fixed version (ground truth):
@Override public ArrayList<EntityData> extractData(ResultSet rs) throws SQLException, DataAccessException {
  ResultSetMetaData meta=rs.getMetaData();
  Map<Integer,String> columnHints=getSqlColumnEntityHints(sqlToExecute);
  ArrayList<String> attributeIds=getAttributeIds(meta,columnHints);
  long ts=System.currentTimeMillis();
  while (rs.next()) {
    if (outputRecCount++ % rowsPerMessage == 0 && payload != null) {
      callback.sendMessage(null,payload,false);
      messageSent=true;
      payload=null;
    }
    if (payload == null) {
      payload=new ArrayList<>();
    }
    getComponentStatistics().incrementNumberEntitiesProcessed(threadNumber);
    EntityData rowData=new EntityData();
    rowData.setChangeType(entityChangeType);
    for (int i=1; i <= meta.getColumnCount(); i++) {
      String attributeId=attributeIds.get(i - 1);
      if (isNotBlank(attributeId)) {
        Object value=JdbcUtils.getResultSetValue(rs,i);
        if (trimColumns && value instanceof String) {
          value=value.toString().trim();
        }
        rowData.put(attributeId,value);
      }
    }
    payload.add(rowData);
    if (context.getDeployment() != null && context.getDeployment().asLogLevel() == LogLevel.DEBUG) {
      logEntityAttributes(rowData);
    }
    long newTs=System.currentTimeMillis();
    if (newTs - ts > 10000) {
      getExecutionTracker().updateStatistics(threadNumber,context);
      ts=newTs;
    }
  }
  return payload;
}
Program: 167429
Project: 167429
Buggy source:
@Override protected void start(){
  TypedProperties properties=getTypedProperties();
  sqls=getSqlStatements(true);
  rowsPerMessage=properties.getLong(ROWS_PER_MESSAGE);
  trimColumns=properties.is(TRIM_COLUMNS);
  matchOnColumnNameOnly=properties.is(MATCH_ON_COLUMN_NAME_ONLY,false);
}

Fixed version (ground truth):
@Override protected void start(){
  TypedProperties properties=getTypedProperties();
  sqls=getSqlStatements(true);
  rowsPerMessage=properties.getLong(ROWS_PER_MESSAGE);
  trimColumns=properties.is(TRIM_COLUMNS);
  matchOnColumnNameOnly=properties.is(MATCH_ON_COLUMN_NAME_ONLY,false);
  messageSent=false;
}
Program: 167432
Project: 167432
Buggy source:
private int execute(ISqlTransaction transaction,DmlStatement dmlStatement,Object marker,Object[] data,boolean logFailure){
  String sql=dmlStatement.getSql();
  if (!sql.equals(lastPreparedDml)) {
    transaction.flush();
    if (log.isDebugEnabled()) {
      log.debug("String_Node_Str",sql);
    }
    transaction.prepare(sql);
    lastPreparedDml=sql;
  }
  if (log.isInfoEnabled()) {
    log.info("String_Node_Str",Arrays.toString(data),Arrays.toString(dmlStatement.getTypes()));
  }
  try {
    return transaction.addRow(marker,data,dmlStatement.getTypes());
  }
 catch (  SqlException ex) {
    if (logFailure) {
      log(LogLevel.WARN,String.format("String_Node_Str",dmlStatement.getSql(),Arrays.toString(data),Arrays.toString(dmlStatement.getTypes())));
    }
    throw ex;
  }
}

Fixed version (ground truth):
private int execute(ISqlTransaction transaction,DmlStatement dmlStatement,Object marker,Object[] data,boolean logFailure){
  String sql=dmlStatement.getSql();
  if (!sql.equals(lastPreparedDml)) {
    transaction.flush();
    if (log.isDebugEnabled()) {
      log.debug("String_Node_Str",sql);
    }
    transaction.prepare(sql);
    lastPreparedDml=sql;
  }
  if (log.isDebugEnabled()) {
    log.debug("String_Node_Str",Arrays.toString(data),Arrays.toString(dmlStatement.getTypes()));
  }
  try {
    return transaction.addRow(marker,data,dmlStatement.getTypes());
  }
 catch (  SqlException ex) {
    if (logFailure) {
      log(LogLevel.WARN,String.format("String_Node_Str",dmlStatement.getSql(),Arrays.toString(data),Arrays.toString(dmlStatement.getTypes())));
    }
    throw ex;
  }
}
Program: 167433
Project: 167433
Buggy source:
@Override public void handle(Message inputMessage,ISendMessageCallback callback,boolean unitOfWorkBoundaryReached){
  Model inputModel=getComponent().getInputModel();
  List<EntityData> inDatas=inputMessage.getPayload();
  ArrayList<EntityData> outDatas=new ArrayList<EntityData>(inDatas.size());
  for (  EntityData inData : inDatas) {
    EntityData outData=new EntityData();
    outDatas.add(outData);
    Set<String> attributeIds=new HashSet<String>(inData.keySet());
    attributeIds.addAll(transformsByAttributeId.keySet());
    for (    String attributeId : attributeIds) {
      String transform=transformsByAttributeId.get(attributeId);
      Object value=inData.get(attributeId);
      if (isNotBlank(transform)) {
        ModelAttribute attribute=inputModel.getAttributeById(attributeId);
        ModelEntity entity=inputModel.getEntityById(attribute.getEntityId());
        value=ModelAttributeScriptHelper.eval(attribute,value,entity,inData,transform);
      }
      if (value != ModelAttributeScriptHelper.REMOVE_ATTRIBUTE) {
        outData.put(attributeId,value);
      }
    }
    getComponentStatistics().incrementNumberEntitiesProcessed(threadNumber);
  }
  callback.sendMessage(null,outDatas,unitOfWorkBoundaryReached);
}

Fixed version (ground truth):
@Override public void handle(Message inputMessage,ISendMessageCallback callback,boolean unitOfWorkBoundaryReached){
  Model inputModel=getComponent().getInputModel();
  List<EntityData> inDatas=inputMessage.getPayload();
  ArrayList<EntityData> outDatas=new ArrayList<EntityData>(inDatas.size());
  for (  EntityData inData : inDatas) {
    EntityData outData=new EntityData();
    outData.setChangeType(inData.getChangeType());
    outDatas.add(outData);
    Set<String> attributeIds=new HashSet<String>();
    Set<ModelEntity> processedEntities=new HashSet<ModelEntity>();
    for (    String attributeId : inData.keySet()) {
      ModelAttribute attribute=inputModel.getAttributeById(attributeId);
      if (attribute != null) {
        ModelEntity entity=inputModel.getEntityById(attribute.getEntityId());
        if (!processedEntities.contains(entity)) {
          List<ModelAttribute> attributes=entity.getModelAttributes();
          for (          ModelAttribute modelAttribute : attributes) {
            attributeIds.add(modelAttribute.getId());
          }
          processedEntities.add(entity);
        }
      }
    }
    for (    String attributeId : attributeIds) {
      String transform=transformsByAttributeId.get(attributeId);
      Object value=inData.get(attributeId);
      if (isNotBlank(transform)) {
        ModelAttribute attribute=inputModel.getAttributeById(attributeId);
        ModelEntity entity=inputModel.getEntityById(attribute.getEntityId());
        value=ModelAttributeScriptHelper.eval(attribute,value,entity,inData,transform);
      }
      if (value != ModelAttributeScriptHelper.REMOVE_ATTRIBUTE) {
        outData.put(attributeId,value);
      }
    }
    getComponentStatistics().incrementNumberEntitiesProcessed(threadNumber);
  }
  callback.sendMessage(null,outDatas,unitOfWorkBoundaryReached);
}
Program: 167435
Project: 167435
Buggy source:
@Override protected void start(){
  super.start();
  TypedProperties properties=getTypedProperties();
  ignoreNamespace=properties.is(IGNORE_NAMESPACE);
  useParameterReplacement=properties.is(PARAMETER_REPLACEMENT);
  xmlFormat=properties.get(XML_FORMAT);
  Setting templateSetting=getComponent().findSetting(XML_FORMATTER_TEMPLATE);
  if (templateSetting != null && StringUtils.isNotBlank(templateSetting.getValue())) {
    SAXBuilder builder=new SAXBuilder();
    builder.setXMLReaderFactory(XMLReaders.NONVALIDATING);
    builder.setFeature("String_Node_Str",false);
    try {
      String xml=templateSetting.getValue();
      if (useParameterReplacement) {
        xml=FormatUtils.replaceTokens(xml,context.getFlowParametersAsString(),true);
      }
      templateDocument=builder.build(new StringReader(xml));
    }
 catch (    Exception e) {
      throw new RuntimeException(e);
    }
  }
  Model model=getComponent().getInputModel();
  entitySettings=new HashMap<String,XmlFormatterEntitySetting>();
  attributeSettings=new ArrayList<XmlFormatterAttributeSetting>();
  if (model != null) {
    Map<Element,Namespace> namespaces=removeNamespaces(templateDocument);
    for (    ComponentEntitySetting compEntitySetting : getComponent().getEntitySettings()) {
      if (compEntitySetting.getName().equals(XML_FORMATTER_XPATH)) {
        XPathExpression<Element> expression=XPathFactory.instance().compile(compEntitySetting.getValue(),Filters.element());
        List<Element> matches=expression.evaluate(templateDocument.getRootElement());
        if (matches.size() == 0) {
          log(LogLevel.WARN,"String_Node_Str" + compEntitySetting.getValue() + "String_Node_Str");
        }
 else {
          Element templateElement=matches.get(0);
          entitySettings.put(compEntitySetting.getEntityId(),new XmlFormatterEntitySetting(compEntitySetting,expression,templateElement));
        }
      }
    }
    restoreNamespaces(templateDocument,namespaces);
    for (    ComponentAttributeSetting compAttrSetting : getComponent().getAttributeSettings()) {
      if (compAttrSetting.getName().equals(XML_FORMATTER_XPATH)) {
        ModelAttribute attr=model.getAttributeById(compAttrSetting.getAttributeId());
        if (attr != null) {
          XPathExpression<Object> expression=XPathFactory.instance().compile(compAttrSetting.getValue());
          XmlFormatterEntitySetting entitySetting=entitySettings.get(attr.getEntityId());
          XmlFormatterAttributeSetting attrSetting=new XmlFormatterAttributeSetting(compAttrSetting,expression);
          if (entitySetting != null) {
            entitySetting.getAttributeSettings().add(attrSetting);
          }
 else {
            attributeSettings.add(attrSetting);
          }
        }
      }
    }
  }
}

Fixed version (ground truth):
@Override protected void start(){
  super.start();
  TypedProperties properties=getTypedProperties();
  ignoreNamespace=properties.is(IGNORE_NAMESPACE);
  useParameterReplacement=properties.is(PARAMETER_REPLACEMENT);
  xmlFormat=properties.get(XML_FORMAT);
  template=properties.get(XML_FORMATTER_TEMPLATE);
}
Program: 167437
Project: 167437
Buggy source:
private Set<XmlFormatterEntitySetting> getEntitySettings(EntityData inputRow){
  Set<XmlFormatterEntitySetting> entitySettingSet=new HashSet<XmlFormatterEntitySetting>();
  Model model=getComponent().getInputModel();
  if (model != null && inputRow.size() > 0) {
    for (    String attributeId : inputRow.keySet()) {
      ModelAttribute attribute=model.getAttributeById(attributeId);
      if (attribute != null) {
        XmlFormatterEntitySetting entitySetting=entitySettings.get(attribute.getEntityId());
        if (entitySetting != null) {
          entitySettingSet.add(entitySetting);
        }
      }
    }
  }
  return entitySettingSet;
}

Fixed version (ground truth):
private Set<XmlFormatterEntitySetting> getEntitySettings(EntityData inputRow,Map<String,XmlFormatterEntitySetting> entitySettings){
  Set<XmlFormatterEntitySetting> entitySettingSet=new HashSet<XmlFormatterEntitySetting>();
  Model model=getComponent().getInputModel();
  if (model != null && inputRow.size() > 0) {
    for (    String attributeId : inputRow.keySet()) {
      ModelAttribute attribute=model.getAttributeById(attributeId);
      if (attribute != null) {
        XmlFormatterEntitySetting entitySetting=entitySettings.get(attribute.getEntityId());
        if (entitySetting != null) {
          entitySettingSet.add(entitySetting);
        }
      }
    }
  }
  return entitySettingSet;
}