nus-yam/ex-repair huggingface dataset:
Program: 137105
Project: 137105
Buggy source:
/** 
 * DOC talend Comment method "clearDrillDownMaps".
 */
@Override protected void clearDrillDownMap(){
  if (checkAllowDrillDown()) {
    AbstractDB<?> mapDB=getMapDB(StandardDBName.drillDown.name());
    mapDB.clearDB();
  }
}

Fixed version (ground truth):
/** 
 * DOC talend Comment method "clearDrillDownMaps".
 */
@Override protected void clearDrillDownMap(){
  if (isUsedMapDBMode() && checkAllowDrillDown()) {
    AbstractDB<?> mapDB=getMapDB(StandardDBName.drillDown.name());
    if (mapDB != null) {
      mapDB.clearDB(ResourceManager.getMapDBCatalogName(this));
    }
  }
}
Program: 137106
Project: 137106
Buggy source:
/** 
 * Create a new DBMap
 * @return
 */
private Map<Object,Long> initValueForDBMap(String dbName){
  if (isUsedMapDBMode()) {
    return new DBMap<Object,Long>(ResourceManager.getMapDBFilePath(this),ResourceHelper.getUUID(this),dbName);
  }
 else {
    return new TreeMap<Object,Long>();
  }
}

Fixed version (ground truth):
/** 
 * Create a new DBMap
 * @return
 */
private Map<Object,Long> initValueForDBMap(String dbName){
  if (isUsedMapDBMode()) {
    return new DBMap<Object,Long>(ResourceManager.getMapDBFilePath(),ResourceManager.getMapDBFileName(this),ResourceManager.getMapDBCatalogName(this,dbName));
  }
 else {
    return new TreeMap<Object,Long>();
  }
}
Program: 137107
Project: 137107
Buggy source:
/** 
 * init DBMap
 * @return
 */
private Map<Object,List<Object>> initValueForDBMap(String dbName){
  if (isUsedMapDBMode()) {
    return new DBMap<Object,List<Object>>(ResourceManager.getMapDBFilePath(this),ResourceHelper.getUUID(this),dbName);
  }
  return null;
}

Fixed version (ground truth):
/** 
 * init DBMap
 * @return
 */
private Map<Object,List<Object>> initValueForDBMap(String dbName){
  if (isUsedMapDBMode()) {
    return new DBMap<Object,List<Object>>(ResourceManager.getMapDBFilePath(),ResourceManager.getMapDBFileName(this),ResourceManager.getMapDBCatalogName(this,dbName));
  }
  return null;
}
Program: 137108
Project: 137108
Buggy source:
/** 
 * Create a new DBSet
 * @return
 */
private Set<Object> initValueForDBSet(String dbName){
  if (isUsedMapDBMode()) {
    return new DBSet<Object>(ResourceManager.getMapDBFilePath(this),ResourceHelper.getUUID(this),dbName);
  }
 else {
    return new HashSet<Object>();
  }
}

Fixed version (ground truth):
/** 
 * Create a new DBSet
 * @return
 */
private Set<Object> initValueForDBSet(String dbName){
  if (isUsedMapDBMode()) {
    return new DBSet<Object>(ResourceManager.getMapDBFilePath(),ResourceManager.getMapDBFileName(this),ResourceManager.getMapDBCatalogName(this,dbName));
  }
 else {
    return new HashSet<Object>();
  }
}
Program: 137109
Project: 137109
Buggy source:
/** 
 * Create a new DBMap
 * @return
 */
private Map<Object,Long> initValueForDBMap(String dbName){
  if (isUsedMapDBMode()) {
    return new DBMap<Object,Long>(ResourceManager.getMapDBFilePath(this),ResourceHelper.getUUID(this),dbName);
  }
 else {
    return new TreeMap<Object,Long>();
  }
}

Fixed version (ground truth):
/** 
 * Create a new DBMap
 * @return
 */
private Map<Object,Long> initValueForDBMap(String dbName){
  if (isUsedMapDBMode()) {
    return new DBMap<Object,Long>(ResourceManager.getMapDBFilePath(),ResourceManager.getMapDBFileName(this),ResourceManager.getMapDBCatalogName(this,dbName));
  }
 else {
    return new TreeMap<Object,Long>();
  }
}
Program: 137110
Project: 137110
Buggy source:
/** 
 * DOC zshen Comment method "createHideGroupComposite".
 * @param chartComposite
 */
protected void createHideGroupComposite(Composite chartComposite){
  GridData gridData;
  Composite toolComp=toolkit.createComposite(chartComposite,SWT.NONE);
  gridData=new GridData(GridData.FILL_HORIZONTAL);
  toolComp.setLayoutData(gridData);
  GridLayout gridLayout=new GridLayout(3,false);
  toolComp.setLayout(gridLayout);
  Label lessText=new Label(toolComp,SWT.NONE);
  lessText.setText(DefaultMessagesImpl.getString("String_Node_Str"));
  final Spinner lessSpin=new Spinner(toolComp,SWT.BORDER);
  lessSpin.addModifyListener(new ModifyListener(){
    @Override public void modifyText(    ModifyEvent e){
      if (matchRuleChartComp != null) {
        int oldValue=matchRuleChartComp.getTimes();
        String text=lessSpin.getText().trim();
        int times=StringUtils.isEmpty(text) ? 0 : Integer.parseInt(text);
        matchRuleChartComp.setTimes(times);
        matchRuleChartComp.refresh();
        listeners.firePropertyChange(MatchAnalysisConstant.NEED_REFRESH_DATA_SAMPLE_TABLE,oldValue,times);
        matchRows.clear();
      }
    }
  }
);
  lessSpin.setSelection(2);
  Label lessText2=new Label(toolComp,SWT.NONE);
  lessText2.setText(DefaultMessagesImpl.getString("String_Node_Str"));
}

Fixed version (ground truth):
/** 
 * DOC zshen Comment method "createHideGroupComposite".
 * @param chartComposite
 */
protected void createHideGroupComposite(Composite chartComposite){
  GridData gridData;
  Composite toolComp=toolkit.createComposite(chartComposite,SWT.NONE);
  gridData=new GridData(GridData.FILL_HORIZONTAL);
  toolComp.setLayoutData(gridData);
  GridLayout gridLayout=new GridLayout(3,false);
  toolComp.setLayout(gridLayout);
  Label lessText=new Label(toolComp,SWT.NONE);
  lessText.setText(DefaultMessagesImpl.getString("String_Node_Str"));
  final Spinner lessSpin=new Spinner(toolComp,SWT.BORDER);
  lessSpin.addModifyListener(new ModifyListener(){
    @Override public void modifyText(    ModifyEvent e){
      if (matchRuleChartComp != null) {
        int oldValue=matchRuleChartComp.getTimes();
        String text=lessSpin.getText().trim();
        int times=StringUtils.isEmpty(text) ? 0 : Integer.parseInt(text);
        matchRuleChartComp.setTimes(times);
        matchRuleChartComp.refresh();
        listeners.firePropertyChange(MatchAnalysisConstant.NEED_REFRESH_DATA_SAMPLE_TABLE,oldValue,times);
        matchRows.clear();
      }
    }
  }
);
  lessSpin.setSelection(PluginConstant.HIDDEN_GROUP_LESS_THAN_DEFAULT);
  Label lessText2=new Label(toolComp,SWT.NONE);
  lessText2.setText(DefaultMessagesImpl.getString("String_Node_Str"));
}
Program: 137111
Project: 137111
Buggy source:
@Override protected void handleRemoveElement(ModelElementChangeLeftTarget removeElement){
  ColumnSet removeColumnSet=SwitchHelpers.COLUMN_SET_SWITCH.doSwitch(removeElement.getLeftElement());
  if (removeColumnSet != null) {
    popRemoveElementConfirm();
    if (isValidTableHandle(removeColumnSet) || isValidViewHandle(removeColumnSet)) {
      PackageHelper.removeColumnSet(removeColumnSet,getPackageFromObject(selectedObj));
    }
  }
}

Fixed version (ground truth):
@Override protected void handleRemoveElement(ModelElementChangeLeftTarget removeElement){
  EObject leftElement=removeElement.getLeftElement();
  ColumnSet removeColumnSet=SwitchHelpers.COLUMN_SET_SWITCH.doSwitch(leftElement);
  if (removeColumnSet != null) {
    popRemoveElementConfirm();
    if (isValidTableHandle(removeColumnSet) || isValidViewHandle(removeColumnSet)) {
      PackageHelper.removeColumnSet(removeColumnSet,getPackageFromObject(selectedObj));
    }
  }
  if (leftElement instanceof TaggedValue) {
    TdTable elementOwner=SwitchHelpers.TABLE_SWITCH.doSwitch(leftElement.eContainer());
    if (elementOwner != null) {
      TaggedValueHelper.setTaggedValue(elementOwner,((TaggedValue)leftElement).getTag(),null);
    }
  }
}
Program: 137112
Project: 137112
Buggy source:
@SuppressWarnings("String_Node_Str") @Override protected void handleAddElement(ModelElementChangeRightTarget addElement){
  EObject rightElement=addElement.getRightElement();
  ColumnSet columnSetSwitch=SwitchHelpers.COLUMN_SET_SWITCH.doSwitch(rightElement);
  if (columnSetSwitch != null) {
    if (isValidTableHandle(columnSetSwitch) || isValidViewHandle(columnSetSwitch)) {
      PackageHelper.addColumnSet(columnSetSwitch,getPackageFromObject(selectedObj));
    }
  }
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") @Override protected void handleAddElement(ModelElementChangeRightTarget addElement){
  EObject rightElement=addElement.getRightElement();
  ColumnSet columnSetSwitch=SwitchHelpers.COLUMN_SET_SWITCH.doSwitch(rightElement);
  if (columnSetSwitch != null) {
    if (isValidTableHandle(columnSetSwitch) || isValidViewHandle(columnSetSwitch)) {
      PackageHelper.addColumnSet(columnSetSwitch,getPackageFromObject(selectedObj));
    }
  }
  if (rightElement instanceof TaggedValue) {
    TdTable elementOwner=SwitchHelpers.TABLE_SWITCH.doSwitch(addElement.getLeftParent());
    if (elementOwner != null) {
      TaggedValueHelper.setTaggedValue(elementOwner,((TaggedValue)rightElement).getTag(),((TaggedValue)rightElement).getValue());
    }
  }
}
Program: 137113
Project: 137113
Buggy source:
private EObject getTempTableFromOldFile() throws ReloadCompareException {
  MetadataTable[] metadataTables=ConnectionHelper.getTables((DelimitedFileConnection)tempReloadProvider).toArray(new MetadataTable[0]);
  String tableName=((MetadataTable)selectedObj).getLabel();
  for (  MetadataTable table : metadataTables) {
    if (table.getLabel().equals(tableName)) {
      tempMetadataTable=table;
      comparedColumns.addAll(table.getColumns());
      break;
    }
  }
  util.saveResource(tempMetadataTable.eResource());
  return tempMetadataTable;
}

Fixed version (ground truth):
private EObject getTempTableFromOldFile() throws ReloadCompareException {
  MetadataTable[] metadataTables=ConnectionHelper.getTables(tempReloadProvider).toArray(new MetadataTable[0]);
  String tableName=((MetadataTable)selectedObj).getLabel();
  for (  MetadataTable table : metadataTables) {
    if (table.getLabel().equals(tableName)) {
      tempMetadataTable=table;
      comparedColumns.addAll(table.getColumns());
      break;
    }
  }
  util.saveResource(tempMetadataTable.eResource());
  return tempMetadataTable;
}
Program: 137114
Project: 137114
Buggy source:
@Override protected EObject getSavedReloadObject() throws ReloadCompareException {
  ColumnSet selectedColumnSet=null;
  if (selectedObj instanceof DBColumnFolderRepNode) {
    DBColumnFolderRepNode columnFolderRepNode=(DBColumnFolderRepNode)selectedObj;
    selectedColumnSet=columnFolderRepNode.getColumnSet();
  }
 else   if (selectedObj instanceof ColumnSet) {
    selectedColumnSet=(ColumnSet)selectedObj;
  }
  ColumnSet toReloadcolumnSet=DQStructureComparer.findMatchedColumnSet(selectedColumnSet,tempReloadProvider);
  ColumnSetHelper.setColumns(toReloadcolumnSet,EMPTY_COLUMN_LIST);
  toReloadcolumnSet.getOwnedElement().clear();
  try {
    DqRepositoryViewService.getColumns(tempReloadProvider,toReloadcolumnSet,true);
    util.saveResource(toReloadcolumnSet.eResource());
  }
 catch (  Exception e1) {
    throw new ReloadCompareException(e1);
  }
  return toReloadcolumnSet;
}

Fixed version (ground truth):
@Override protected EObject getSavedReloadObject() throws ReloadCompareException {
  ColumnSet selectedColumnSet=getCurrentColumnSet();
  ColumnSet toReloadcolumnSet=DQStructureComparer.findMatchedColumnSet(selectedColumnSet,tempReloadProvider);
  ColumnSetHelper.setColumns(toReloadcolumnSet,EMPTY_COLUMN_LIST);
  toReloadcolumnSet.getOwnedElement().clear();
  try {
    DqRepositoryViewService.getColumns(tempReloadProvider,toReloadcolumnSet,true);
    util.saveResource(toReloadcolumnSet.eResource());
  }
 catch (  Exception e1) {
    throw new ReloadCompareException(e1);
  }
  return toReloadcolumnSet;
}
Program: 137115
Project: 137115
Buggy source:
@Override protected void handleRemoveElement(ModelElementChangeLeftTarget removeElement){
  TdColumn removeColumn=SwitchHelpers.COLUMN_SWITCH.doSwitch(removeElement.getLeftElement());
  if (removeColumn != null) {
    ColumnSet columnSet=null;
    if (selectedObj instanceof DBColumnFolderRepNode) {
      DBColumnFolderRepNode columnFolderRepNode=(DBColumnFolderRepNode)selectedObj;
      columnSet=columnFolderRepNode.getColumnSet();
    }
 else     if (selectedObj instanceof ColumnSet) {
      columnSet=(ColumnSet)selectedObj;
    }
    popRemoveElementConfirm();
    ColumnSetHelper.removeColumn(removeColumn,columnSet);
    return;
  }
  TdExpression removedExpression=DataqualitySwitchHelper.TDEXPRESSION_SWITCH.doSwitch(removeElement.getLeftElement());
  if (removedExpression != null) {
    TdColumn expressionOwner=SwitchHelpers.COLUMN_SWITCH.doSwitch(removedExpression.eContainer());
    if (expressionOwner != null) {
      expressionOwner.setInitialValue(null);
    }
  }
}

Fixed version (ground truth):
@Override protected void handleRemoveElement(ModelElementChangeLeftTarget removeElement){
  EObject leftElement=removeElement.getLeftElement();
  TdColumn removeColumn=SwitchHelpers.COLUMN_SWITCH.doSwitch(leftElement);
  if (removeColumn != null) {
    ColumnSet columnSet=getCurrentColumnSet();
    popRemoveElementConfirm();
    ColumnSetHelper.removeColumn(removeColumn,columnSet);
    return;
  }
  TdExpression removedExpression=DataqualitySwitchHelper.TDEXPRESSION_SWITCH.doSwitch(leftElement);
  if (removedExpression != null) {
    TdColumn expressionOwner=SwitchHelpers.COLUMN_SWITCH.doSwitch(removedExpression.eContainer());
    if (expressionOwner != null) {
      expressionOwner.setInitialValue(null);
    }
  }
  if (leftElement instanceof TaggedValue) {
    TdColumn elementOwner=SwitchHelpers.COLUMN_SWITCH.doSwitch(leftElement.eContainer());
    if (elementOwner != null) {
      TaggedValueHelper.setTaggedValue(elementOwner,((TaggedValue)leftElement).getTag(),null);
    }
  }
}
Program: 137116
Project: 137116
Buggy source:
@Override protected void handleAddElement(ModelElementChangeRightTarget addElement){
  EObject rightElement=addElement.getRightElement();
  TdColumn columnSetSwitch=SwitchHelpers.COLUMN_SWITCH.doSwitch(rightElement);
  if (columnSetSwitch != null) {
    ColumnSet columnSet=null;
    if (selectedObj instanceof DBColumnFolderRepNode) {
      DBColumnFolderRepNode columnFolderRepNode=(DBColumnFolderRepNode)selectedObj;
      columnSet=columnFolderRepNode.getColumnSet();
    }
 else     if (selectedObj instanceof ColumnSet) {
      columnSet=(ColumnSet)selectedObj;
    }
    ColumnSetHelper.addColumn(columnSetSwitch,columnSet);
    PrimaryKey primaryKey=ColumnHelper.getPrimaryKey(columnSetSwitch);
    if (primaryKey != null) {
      TableHelper.addPrimaryKey((TdTable)columnSet,columnSetSwitch);
    }
    Set<ForeignKey> foreignKeySet=ColumnHelper.getForeignKey(columnSetSwitch);
    for (    ForeignKey foreignKey : foreignKeySet) {
      if (foreignKey != null) {
        TableHelper.addForeignKey((TdTable)columnSet,foreignKey,columnSetSwitch);
      }
    }
    return;
  }
  TdExpression addedExpression=DataqualitySwitchHelper.TDEXPRESSION_SWITCH.doSwitch(rightElement);
  if (addedExpression != null) {
    TdColumn parentColumn=SwitchHelpers.COLUMN_SWITCH.doSwitch(addElement.getLeftParent());
    if (parentColumn != null) {
      parentColumn.setInitialValue(addedExpression);
    }
  }
}

Fixed version (ground truth):
@Override protected void handleAddElement(ModelElementChangeRightTarget addElement){
  EObject rightElement=addElement.getRightElement();
  TdColumn columnSetSwitch=SwitchHelpers.COLUMN_SWITCH.doSwitch(rightElement);
  if (columnSetSwitch != null) {
    ColumnSet columnSet=getCurrentColumnSet();
    ColumnSetHelper.addColumn(columnSetSwitch,columnSet);
    PrimaryKey primaryKey=ColumnHelper.getPrimaryKey(columnSetSwitch);
    if (primaryKey != null) {
      TableHelper.addPrimaryKey((TdTable)columnSet,columnSetSwitch);
    }
    Set<ForeignKey> foreignKeySet=ColumnHelper.getForeignKey(columnSetSwitch);
    for (    ForeignKey foreignKey : foreignKeySet) {
      if (foreignKey != null) {
        TableHelper.addForeignKey((TdTable)columnSet,foreignKey,columnSetSwitch);
      }
    }
    return;
  }
  TdExpression addedExpression=DataqualitySwitchHelper.TDEXPRESSION_SWITCH.doSwitch(rightElement);
  if (addedExpression != null) {
    TdColumn parentColumn=SwitchHelpers.COLUMN_SWITCH.doSwitch(addElement.getLeftParent());
    if (parentColumn != null) {
      parentColumn.setInitialValue(addedExpression);
    }
  }
  if (rightElement instanceof TaggedValue) {
    TdColumn elementOwner=SwitchHelpers.COLUMN_SWITCH.doSwitch(addElement.getLeftParent());
    if (elementOwner != null) {
      TaggedValueHelper.setTaggedValue(elementOwner,((TaggedValue)rightElement).getTag(),((TaggedValue)rightElement).getValue());
    }
  }
}
Program: 137117
Project: 137117
Buggy source:
/** 
 * Update the software systems given the database connection instance.<br>
 * @param database connection (Talend type)
 * @return
 * @throws SQLException
 */
public void updateSoftwareSystem(DatabaseConnection databaseConnection) throws SQLException {
  if (databaseConnection == null) {
    return;
  }
  Resource softwareSystemResource=EMFSharedResources.getInstance().getSoftwareDeploymentResource();
  List<EObject> softwareSystems=softwareSystemResource.getContents();
  Boolean isExisted=Boolean.FALSE;
  try {
    isExisted=isExistedInSoftwareSystem(databaseConnection,softwareSystems);
  }
 catch (  TalendException e) {
    return;
  }
  if (!isExisted) {
    update(databaseConnection,softwareSystems,softwareSystemResource);
  }
}

Fixed version (ground truth):
/** 
 * Update the software systems given the database connection instance.<br>
 * @param database connection (Talend type)
 * @return
 * @throws SQLException
 */
public void updateSoftwareSystem(DatabaseConnection databaseConnection) throws SQLException {
  if (databaseConnection == null) {
    return;
  }
  Resource softwareSystemResource=EMFSharedResources.getInstance().getSoftwareDeploymentResource();
  List<EObject> softwareSystems=softwareSystemResource.getContents();
  Boolean isExisted=Boolean.FALSE;
  try {
    isExisted=isExistedInSoftwareSystem(databaseConnection,softwareSystems);
  }
 catch (  TalendException e) {
    log.debug(e.getMessage());
    return;
  }
  if (!isExisted) {
    update(databaseConnection,softwareSystems,softwareSystemResource);
  }
}
Program: 137118
Project: 137118
Buggy source:
/** 
 * Update the software systems given the database connection instance.<br>
 * @param database connection (Talend type)
 * @return
 * @throws SQLException
 */
public void updateSoftwareSystem(DatabaseConnection databaseConnection) throws SQLException {
  if (databaseConnection == null) {
    return;
  }
  Resource softwareSystemResource=EMFSharedResources.getInstance().getSoftwareDeploymentResource();
  List<EObject> softwareSystems=softwareSystemResource.getContents();
  Boolean isExisted=Boolean.FALSE;
  try {
    isExisted=isExistedInSoftwareSystem(databaseConnection,softwareSystems);
  }
 catch (  TalendException e) {
    log.error(e.getMessage());
    return;
  }
  if (!isExisted) {
    update(databaseConnection,softwareSystems,softwareSystemResource);
  }
}

Fixed version (ground truth):
/** 
 * Update the software systems given the database connection instance.<br>
 * @param database connection (Talend type)
 * @return
 * @throws SQLException
 */
public void updateSoftwareSystem(DatabaseConnection databaseConnection) throws SQLException {
  if (databaseConnection == null) {
    return;
  }
  Resource softwareSystemResource=EMFSharedResources.getInstance().getSoftwareDeploymentResource();
  List<EObject> softwareSystems=softwareSystemResource.getContents();
  Boolean isExisted=Boolean.FALSE;
  try {
    isExisted=isExistedInSoftwareSystem(databaseConnection,softwareSystems);
  }
 catch (  TalendException e) {
    return;
  }
  if (!isExisted) {
    update(databaseConnection,softwareSystems,softwareSystemResource);
  }
}
Program: 137119
Project: 137119
Buggy source:
/** 
 * check every block keys and match keys, if any key .
 * @param matchRuleDef
 * @return
 */
private boolean isNeedColumnWarning(MatchRuleDefinition matchRuleDef){
  boolean needColumnWarning=false;
  if (dialogType != MATCHGROUP_TYPE && dialogType != RECORD_MATCHING_TYPE) {
    for (    BlockKeyDefinition bkd : matchRuleDef.getBlockKeys()) {
      if (hasColumnMatchTheKey(bkd)) {
        needColumnWarning=true;
        break;
      }
    }
  }
  if (dialogType != GENKEY_TYPE) {
    for (    MatchRule rule : matchRuleDef.getMatchRules()) {
      EList<MatchKeyDefinition> matchKeys=rule.getMatchKeys();
      for (      MatchKeyDefinition mkd : matchKeys) {
        if (!hasColumnMatchTheKey(mkd)) {
          needColumnWarning=true;
          break;
        }
      }
      if (needColumnWarning) {
        break;
      }
    }
  }
  return needColumnWarning;
}

Fixed version (ground truth):
/** 
 * check every block keys and match keys, if any key .
 * @param matchRuleDef
 * @return
 */
private boolean isNeedColumnWarning(MatchRuleDefinition matchRuleDef){
  boolean needColumnWarning=false;
  if (dialogType != MATCHGROUP_TYPE && dialogType != RECORD_MATCHING_TYPE) {
    for (    BlockKeyDefinition bkd : matchRuleDef.getBlockKeys()) {
      if (!hasColumnMatchTheKey(bkd)) {
        needColumnWarning=true;
        break;
      }
    }
  }
  if (dialogType != GENKEY_TYPE) {
    for (    MatchRule rule : matchRuleDef.getMatchRules()) {
      EList<MatchKeyDefinition> matchKeys=rule.getMatchKeys();
      for (      MatchKeyDefinition mkd : matchKeys) {
        if (!hasColumnMatchTheKey(mkd)) {
          needColumnWarning=true;
          break;
        }
      }
      if (needColumnWarning) {
        break;
      }
    }
  }
  return needColumnWarning;
}
Program: 137121
Project: 137121
Buggy source:
/** 
 * check every block keys and match keys, if any key .
 * @param matchRuleDef
 * @return
 */
private boolean isNeedColumnWarning(MatchRuleDefinition matchRuleDef){
  boolean needColumnWarning=false;
  if (dialogType != MATCHGROUP_TYPE && dialogType != RECORD_MATCHING_TYPE) {
    for (    BlockKeyDefinition bkd : matchRuleDef.getBlockKeys()) {
      if (hasColumnMatchTheKey(bkd)) {
        needColumnWarning=true;
        break;
      }
    }
  }
  if (dialogType != GENKEY_TYPE) {
    for (    MatchRule rule : matchRuleDef.getMatchRules()) {
      EList<MatchKeyDefinition> matchKeys=rule.getMatchKeys();
      for (      MatchKeyDefinition mkd : matchKeys) {
        if (!hasColumnMatchTheKey(mkd)) {
          needColumnWarning=true;
          break;
        }
      }
      if (needColumnWarning) {
        break;
      }
    }
  }
  return needColumnWarning;
}

Fixed version (ground truth):
/** 
 * check every block keys and match keys, if any key .
 * @param matchRuleDef
 * @return
 */
private boolean isNeedColumnWarning(MatchRuleDefinition matchRuleDef){
  boolean needColumnWarning=false;
  if (dialogType != MATCHGROUP_TYPE && dialogType != RECORD_MATCHING_TYPE) {
    for (    BlockKeyDefinition bkd : matchRuleDef.getBlockKeys()) {
      if (!hasColumnMatchTheKey(bkd)) {
        needColumnWarning=true;
        break;
      }
    }
  }
  if (dialogType != GENKEY_TYPE) {
    for (    MatchRule rule : matchRuleDef.getMatchRules()) {
      EList<MatchKeyDefinition> matchKeys=rule.getMatchKeys();
      for (      MatchKeyDefinition mkd : matchKeys) {
        if (!hasColumnMatchTheKey(mkd)) {
          needColumnWarning=true;
          break;
        }
      }
      if (needColumnWarning) {
        break;
      }
    }
  }
  return needColumnWarning;
}
Program: 137123
Project: 137123
Buggy source:
/** 
 * Test method for   {@link org.talend.dq.helper.ReportUtils#getTheLatestReport(org.eclipse.core.resources.IFile)}.
 */
@Test public void testGetTheLatestReport(){
  if (this.realProject != null) {
    String folderName1=ERepositoryObjectType.TDQ_DATA_PROFILING.getFolder();
    String folderName2=ERepositoryObjectType.TDQ_REPORT_ELEMENT.getFolder();
    String reportName="String_Node_Str" + StringUtilities.getRandomString(7);
    UnitTestBuildHelper.createRealFolder(this.realProject,folderName1);
    IFolder folder2=UnitTestBuildHelper.createRealFolder(this.realProject,folderName2);
    IFile iFile=UnitTestBuildHelper.createRealFile(folder2,reportName + "String_Node_Str");
    assertTrue(iFile.exists());
    assertTrue(WorkspaceUtils.ifileToFile(iFile).exists());
    ReportListParameters reportListParameters=ReportUtils.getTheLatestReport(iFile);
    assertNotNull(reportListParameters);
  }
 else {
    fail("String_Node_Str");
  }
}

Fixed version (ground truth):
/** 
 * Test method for   {@link org.talend.dq.helper.ReportUtils#getTheLatestReport(org.eclipse.core.resources.IFile)}.
 * @throws Exception
 */
@Test public void testGetTheLatestReport() throws Exception {
  if (this.realProject != null) {
    String folderName1=ERepositoryObjectType.TDQ_DATA_PROFILING.getFolder();
    String folderName2=ERepositoryObjectType.TDQ_REPORT_ELEMENT.getFolder();
    String reportName="String_Node_Str" + StringUtilities.getRandomString(7);
    UnitTestBuildHelper.createRealFolder(this.realProject,folderName1);
    IFolder folder2=UnitTestBuildHelper.createRealFolder(this.realProject,folderName2);
    IFile iFile=UnitTestBuildHelper.createRealFile(folder2,reportName + "String_Node_Str");
    assertTrue(iFile.exists());
    assertTrue(WorkspaceUtils.ifileToFile(iFile).exists());
    ReportUtils.recordReportFiles(iFile,"String_Node_Str","String_Node_Str",System.currentTimeMillis());
    ReportUtils.recordReportFiles(iFile,"String_Node_Str","String_Node_Str",System.currentTimeMillis());
    ReportUtils.recordReportFiles(iFile,"String_Node_Str","String_Node_Str",System.currentTimeMillis());
    ReportListParameters lastest=ReportUtils.getTheLatestReport(iFile);
    assertNotNull(lastest);
    Assert.assertEquals("String_Node_Str",lastest.getName());
  }
 else {
    fail("String_Node_Str");
  }
}
Program: 137124
Project: 137124
Buggy source:
public java.util.Map.Entry<K,V> lowerEntry(K key){
  return dbMap.lowerEntry(key);
}

Fixed version (ground truth):
@Override public java.util.Map.Entry<K,V> lowerEntry(K key){
  return dbMap.lowerEntry(key);
}
Program: 137125
Project: 137125
Buggy source:
public NavigableSet<K> descendingKeySet(){
  return dbMap.descendingKeySet();
}

Fixed version (ground truth):
@Override public NavigableSet<K> descendingKeySet(){
  return dbMap.descendingKeySet();
}
Program: 137126
Project: 137126
Buggy source:
public java.util.Map.Entry<K,V> ceilingEntry(K key){
  return dbMap.ceilingEntry(key);
}

Fixed version (ground truth):
@Override public java.util.Map.Entry<K,V> ceilingEntry(K key){
  return dbMap.ceilingEntry(key);
}
Program: 137127
Project: 137127
Buggy source:
public ConcurrentNavigableMap<K,V> descendingMap(){
  return dbMap.descendingMap();
}

Fixed version (ground truth):
@Override public ConcurrentNavigableMap<K,V> descendingMap(){
  return dbMap.descendingMap();
}
Program: 137128
Project: 137128
Buggy source:
public Collection<V> values(){
  return dbMap.values();
}

Fixed version (ground truth):
@Override public Collection<V> values(){
  return dbMap.values();
}
Program: 137129
Project: 137129
Buggy source:
public V replace(K key,V value){
  return dbMap.replace(key,value);
}

Fixed version (ground truth):
@Override public V replace(K key,V value){
  return dbMap.replace(key,value);
}
Program: 137130
Project: 137130
Buggy source:
public NavigableSet<K> navigableKeySet(){
  return dbMap.navigableKeySet();
}

Fixed version (ground truth):
@Override public NavigableSet<K> navigableKeySet(){
  return dbMap.navigableKeySet();
}
Program: 137131
Project: 137131
Buggy source:
public java.util.Map.Entry<K,V> higherEntry(K key){
  return dbMap.higherEntry(key);
}

Fixed version (ground truth):
@Override public java.util.Map.Entry<K,V> higherEntry(K key){
  return dbMap.higherEntry(key);
}
Program: 137132
Project: 137132
Buggy source:
public boolean containsValue(Object value){
  return dbMap.containsValue(value);
}

Fixed version (ground truth):
@Override public boolean containsValue(Object value){
  return dbMap.containsValue(value);
}
Program: 137133
Project: 137133
Buggy source:
@SuppressWarnings("String_Node_Str") public V put(K key,V value){
  if (key == null) {
    return dbMap.put((K)EMPTY,value);
  }
  return dbMap.put(key,value);
}

Fixed version (ground truth):
@Override @SuppressWarnings("String_Node_Str") public V put(K key,V value){
  if (key == null) {
    return dbMap.put((K)EMPTY,value);
  }
  return dbMap.put(key,value);
}
Program: 137134
Project: 137134
Buggy source:
public boolean remove(Object key,Object value){
  return dbMap.remove(key,value);
}

Fixed version (ground truth):
@Override public boolean remove(Object key,Object value){
  return dbMap.remove(key,value);
}
Program: 137135
Project: 137135
Buggy source:
public java.util.Map.Entry<K,V> pollFirstEntry(){
  return dbMap.pollFirstEntry();
}

Fixed version (ground truth):
@Override public java.util.Map.Entry<K,V> pollFirstEntry(){
  return dbMap.pollFirstEntry();
}
Program: 137136
Project: 137136
Buggy source:
public K higherKey(K key){
  return dbMap.higherKey(key);
}

Fixed version (ground truth):
@Override public K higherKey(K key){
  return dbMap.higherKey(key);
}
Program: 137137
Project: 137137
Buggy source:
public V get(Object key){
  if (key == null) {
    return dbMap.get(EMPTY);
  }
  return dbMap.get(key);
}

Fixed version (ground truth):
@Override public V get(Object key){
  if (key == null) {
    return dbMap.get(EMPTY);
  }
  return dbMap.get(key);
}
Program: 137138
Project: 137138
Buggy source:
public void putAll(Map<? extends K,? extends V> m){
  dbMap.putAll(m);
}

Fixed version (ground truth):
@Override public void putAll(Map<? extends K,? extends V> m){
  dbMap.putAll(m);
}
Program: 137139
Project: 137139
Buggy source:
public K lastKey(){
  return dbMap.lastKey();
}

Fixed version (ground truth):
@Override public K lastKey(){
  return dbMap.lastKey();
}
Program: 137140
Project: 137140
Buggy source:
public java.util.Map.Entry<K,V> firstEntry(){
  return dbMap.firstEntry();
}

Fixed version (ground truth):
@Override public java.util.Map.Entry<K,V> firstEntry(){
  return dbMap.firstEntry();
}
Program: 137141
Project: 137141
Buggy source:
public NavigableSet<K> keySet(){
  return dbMap.keySet();
}

Fixed version (ground truth):
@Override public NavigableSet<K> keySet(){
  return dbMap.keySet();
}
Program: 137142
Project: 137142
Buggy source:
public K floorKey(K key){
  return dbMap.floorKey(key);
}

Fixed version (ground truth):
@Override public K floorKey(K key){
  return dbMap.floorKey(key);
}
Program: 137143
Project: 137143
Buggy source:
public Set<java.util.Map.Entry<K,V>> entrySet(){
  return dbMap.entrySet();
}

Fixed version (ground truth):
@Override public Set<java.util.Map.Entry<K,V>> entrySet(){
  return dbMap.entrySet();
}
Program: 137144
Project: 137144
Buggy source:
public boolean containsKey(Object key){
  if (key == null) {
    return dbMap.containsKey(EMPTY);
  }
  return dbMap.containsKey(key);
}

Fixed version (ground truth):
@Override public boolean containsKey(Object key){
  if (key == null) {
    return dbMap.containsKey(EMPTY);
  }
  return dbMap.containsKey(key);
}
Program: 137145
Project: 137145
Buggy source:
public java.util.Map.Entry<K,V> floorEntry(K key){
  return dbMap.floorEntry(key);
}

Fixed version (ground truth):
@Override public java.util.Map.Entry<K,V> floorEntry(K key){
  return dbMap.floorEntry(key);
}
Program: 137146
Project: 137146
Buggy source:
public ConcurrentNavigableMap<K,V> subMap(K fromKey,K toKey){
  return dbMap.subMap(fromKey,toKey);
}

Fixed version (ground truth):
@Override public ConcurrentNavigableMap<K,V> subMap(K fromKey,K toKey){
  return dbMap.subMap(fromKey,toKey);
}
Program: 137147
Project: 137147
Buggy source:
public void clear(){
  this.getDB().delete(mapName);
  this.getDB().getEngine().clearCache();
}

Fixed version (ground truth):
@Override public void clear(){
  if (!getDB().isClosed()) {
    dbMap.clear();
    this.getDB().delete(mapName);
    this.getDB().getEngine().clearCache();
  }
}
Program: 137148
Project: 137148
Buggy source:
public K ceilingKey(K key){
  return dbMap.ceilingKey(key);
}

Fixed version (ground truth):
@Override public K ceilingKey(K key){
  return dbMap.ceilingKey(key);
}
Program: 137149
Project: 137149
Buggy source:
public java.util.Map.Entry<K,V> pollLastEntry(){
  return dbMap.pollLastEntry();
}

Fixed version (ground truth):
@Override public java.util.Map.Entry<K,V> pollLastEntry(){
  return dbMap.pollLastEntry();
}
Program: 137150
Project: 137150
Buggy source:
public Comparator<? super K> comparator(){
  return dbMap.comparator();
}

Fixed version (ground truth):
@Override public Comparator<? super K> comparator(){
  return dbMap.comparator();
}
Program: 137151
Project: 137151
Buggy source:
public java.util.Map.Entry<K,V> lastEntry(){
  return dbMap.lastEntry();
}

Fixed version (ground truth):
@Override public java.util.Map.Entry<K,V> lastEntry(){
  return dbMap.lastEntry();
}
Program: 137152
Project: 137152
Buggy source:
public K firstKey(){
  return dbMap.firstKey();
}

Fixed version (ground truth):
@Override public K firstKey(){
  return dbMap.firstKey();
}
Program: 137153
Project: 137153
Buggy source:
public K lowerKey(K key){
  return dbMap.lowerKey(key);
}

Fixed version (ground truth):
@Override public K lowerKey(K key){
  return dbMap.lowerKey(key);
}
Program: 137154
Project: 137154
Buggy source:
public ConcurrentNavigableMap<K,V> headMap(K toKey){
  return dbMap.headMap(toKey);
}

Fixed version (ground truth):
@Override public ConcurrentNavigableMap<K,V> headMap(K toKey){
  return dbMap.headMap(toKey);
}
Program: 137155
Project: 137155
Buggy source:
public V putIfAbsent(K key,V value){
  return dbMap.putIfAbsent(key,value);
}

Fixed version (ground truth):
@Override public V putIfAbsent(K key,V value){
  return dbMap.putIfAbsent(key,value);
}
Program: 137156
Project: 137156
Buggy source:
public ConcurrentNavigableMap<K,V> tailMap(K fromKey){
  return dbMap.tailMap(fromKey);
}

Fixed version (ground truth):
@Override public ConcurrentNavigableMap<K,V> tailMap(K fromKey){
  return dbMap.tailMap(fromKey);
}
Program: 137157
Project: 137157
Buggy source:
@Override public boolean reset(){
  if (this.isUsedMapDBMode()) {
    if (needReconnect((AbstractDB<?>)duplicateMap)) {
      duplicateMap=initValueForDBMap(StandardDBName.computeProcess.name());
      if (duplicateMap != null) {
        duplicateMap.clear();
      }
    }
    if (needReconnect((AbstractDB<?>)duplicateMap)) {
      duplicateObjects=initValueForDBSet(StandardDBName.computeProcessSet.name());
      if (duplicateObjects != null) {
        duplicateObjects.clear();
      }
    }
  }
  return super.reset();
}

Fixed version (ground truth):
@Override public boolean reset(){
  if (this.isUsedMapDBMode()) {
    if (needReconnect((AbstractDB<?>)duplicateMap)) {
      duplicateMap=initValueForDBMap(StandardDBName.computeProcess.name());
      duplicateMap.clear();
    }
    if (needReconnect((AbstractDB<?>)duplicateObjects)) {
      duplicateObjects=initValueForDBSet(StandardDBName.computeProcessSet.name());
      duplicateObjects.clear();
    }
  }
 else {
    duplicateMap=initValueForDBMap(StandardDBName.computeProcess.name());
    duplicateObjects=initValueForDBSet(StandardDBName.computeProcessSet.name());
    duplicateMap.clear();
    duplicateObjects.clear();
  }
  return super.reset();
}
Program: 137158
Project: 137158
Buggy source:
@Override public DataSet getCurrentPageDataSet(){
  long pageSize=endIndex - startIndex;
  Comparable[][] compareArray=new Comparable[(int)(pageSize)][this.getColumns().length];
  List<Object[]> subList=MapDBUtils.getDefault().getDataSetDBMapSubList(this.dataMap,startIndex,endIndex,null);
  if (columnFilter != null) {
    subList=columnFilter.filterArray(subList);
  }
  for (int i=0; i < pageSize; i++) {
    Object[] objArray=subList.get(i);
    for (int j=0; j < this.getColumns().length; j++) {
      compareArray[i][j]=(Comparable)objArray[j];
    }
  }
  return new DataSet(this.columnHeads,compareArray);
}

Fixed version (ground truth):
@Override public DataSet getCurrentPageDataSet(){
  long pageSize=endIndex - startIndex;
  List<Object[]> subList=MapDBUtils.getDefault().getDataSetDBMapSubList(this.dataMap,startIndex,endIndex,null);
  if (columnFilter != null) {
    subList=columnFilter.filterArray(subList);
  }
  int count=(int)(pageSize > subList.size() ? subList.size() : pageSize);
  Comparable[][] compareArray=new Comparable[(count)][this.getColumns().length];
  for (int i=0; i < count; i++) {
    Object[] objArray=subList.get(i);
    for (int j=0; j < objArray.length; j++) {
      compareArray[i][j]=(Comparable)objArray[j];
    }
  }
  return new DataSet(this.columnHeads,compareArray);
}
Program: 137159
Project: 137159
Buggy source:
@Override public boolean reset(){
  if (this.isUsedMapDBMode()) {
    if (needReconnect((AbstractDB<?>)duplicateMap)) {
      duplicateMap=initValueForDBMap(StandardDBName.computeProcess.name());
      duplicateMap.clear();
    }
    if (needReconnect((AbstractDB<?>)duplicateObjects)) {
      duplicateObjects=initValueForDBSet(StandardDBName.computeProcessSet.name());
      duplicateObjects.clear();
    }
  }
 else {
    duplicateMap=initValueForDBMap(StandardDBName.computeProcess.name());
    duplicateObjects=initValueForDBSet(StandardDBName.computeProcessSet.name());
    duplicateMap.clear();
    duplicateObjects.clear();
  }
  return super.reset();
}

Fixed version (ground truth):
@Override public boolean reset(){
  if (this.isUsedMapDBMode()) {
    if (needReconnect((AbstractDB<?>)duplicateMap)) {
      duplicateMap=initValueForDBMap(StandardDBName.computeProcess.name());
    }
    duplicateMap.clear();
    if (needReconnect((AbstractDB<?>)duplicateObjects)) {
      duplicateObjects=initValueForDBSet(StandardDBName.computeProcessSet.name());
    }
    duplicateObjects.clear();
  }
 else {
    duplicateMap=initValueForDBMap(StandardDBName.computeProcess.name());
    duplicateObjects=initValueForDBSet(StandardDBName.computeProcessSet.name());
    duplicateMap.clear();
    duplicateObjects.clear();
  }
  return super.reset();
}
Program: 137160
Project: 137160
Buggy source:
@Override public boolean reset(){
  this.uniqueValueCount=UNIQUE_VALUE_COUNT_EDEFAULT;
  if (isUsedMapDBMode()) {
    if (uniqueObjects != null) {
      ((DBSet<Object>)uniqueObjects).clear();
    }
    uniqueObjects=initValueForDBSet(StandardDBName.computeProcessSet.name());
    if (duplicateObjects != null) {
      ((DBSet<Object>)duplicateObjects).clear();
    }
    duplicateObjects=initValueForDBSet(StandardDBName.temp.name());
  }
 else {
    this.uniqueObjects.clear();
    this.duplicateObjects.clear();
  }
  return super.reset();
}

Fixed version (ground truth):
@Override public boolean reset(){
  this.uniqueValueCount=UNIQUE_VALUE_COUNT_EDEFAULT;
  if (isUsedMapDBMode()) {
    uniqueObjects=initValueForDBSet(StandardDBName.computeProcessSet.name());
    if (uniqueObjects != null) {
      ((DBSet<Object>)uniqueObjects).clear();
    }
    duplicateObjects=initValueForDBSet(StandardDBName.temp.name());
    if (duplicateObjects != null) {
      ((DBSet<Object>)duplicateObjects).clear();
    }
  }
 else {
    this.uniqueObjects.clear();
    this.duplicateObjects.clear();
  }
  return super.reset();
}
Program: 137161
Project: 137161
Buggy source:
/** 
 * DOC talend Comment method "cancelCloseTask".
 * @param db
 */
protected void cancelCloseTask(DB db){
  CloseDBTimeTask closeDBTimeTask=closeTaskMap.get(db);
  if (closeDBTimeTask != null) {
    closeDBTimeTask.cancel();
    timer.purge();
    closeTaskMap.remove(closeDBTimeTask);
  }
}

Fixed version (ground truth):
/** 
 * DOC talend Comment method "cancelCloseTask".
 * @param db
 */
protected void cancelCloseTask(DB db){
  CloseDBTimeTask closeDBTimeTask=closeTaskMap.get(db);
  if (closeDBTimeTask != null) {
    closeDBTimeTask.cancel();
    timer.purge();
    closeTaskMap.remove(db);
  }
}
Program: 137162
Project: 137162
Buggy source:
@Override public boolean reset(){
  this.duplicateValueCount=DUPLICATE_VALUE_COUNT_EDEFAULT;
  if (duplicateMap != null) {
    duplicateMap.clear();
  }
  duplicateMap=initValueForDBMap(StandardDBName.computeProcess.name());
  if (duplicateObjects != null) {
    duplicateObjects.clear();
  }
  duplicateObjects=initValueForDBSet(StandardDBName.computeProcessSet.name());
  return super.reset();
}

Fixed version (ground truth):
@Override public boolean reset(){
  if (this.isUsedMapDBMode()) {
    if (needReconnect((AbstractDB<?>)duplicateMap)) {
      duplicateMap=initValueForDBMap(StandardDBName.computeProcess.name());
      if (duplicateMap != null) {
        duplicateMap.clear();
      }
    }
    if (needReconnect((AbstractDB<?>)duplicateMap)) {
      duplicateObjects=initValueForDBSet(StandardDBName.computeProcessSet.name());
      if (duplicateObjects != null) {
        duplicateObjects.clear();
      }
    }
  }
  return super.reset();
}
Program: 137165
Project: 137165
Buggy source:
@SuppressWarnings("String_Node_Str") @Override public void handleDrillDownData(Object masterObject,Object currentObject,int columnCount,int currentIndex,String currentColumnName){
  String dbName=getDBName(masterObject);
  drillDownMap=(DBMap<Object,List<Object>>)getMapDB(dbName);
  super.handleDrillDownData(masterObject,currentObject,columnCount,currentIndex,currentColumnName);
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") @Override public void handleDrillDownData(Object masterObject,List<Object> inputRowList){
  String dbName=getDBName(masterObject);
  drillDownMap=(DBMap<Object,List<Object>>)getMapDB(dbName);
  super.handleDrillDownData(masterObject,inputRowList);
}
Program: 137166
Project: 137166
Buggy source:
@Override public void handleDrillDownData(Object masterObject,Object currentObject,int columnCount,int currentIndex,String currentColumnName){
  List<Object> rowData=drillDownMap.get(count);
  if (rowData == null) {
    rowData=new ArrayList<Object>();
    drillDownMap.put(count,rowData);
    this.drillDownRowCount++;
  }
  rowData.add(currentObject == null ? PluginConstant.NULL_STRING : currentObject);
}

Fixed version (ground truth):
@Override public void handleDrillDownData(Object masterObject,List<Object> inputRowList){
  drillDownRowCount++;
  drillDownMap.put(count,inputRowList);
}
Program: 137167
Project: 137167
Buggy source:
@Override public void handleDrillDownData(Object masterObject,Object currentObject,int columnCount,int currentIndex,String currentColumnName){
  String dbName=getDBName(masterObject);
  drillDownMap=(DBMap<Object,List<Object>>)getMapDB(dbName);
  super.handleDrillDownData(masterObject,currentObject,columnCount,currentIndex,currentColumnName);
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") @Override public void handleDrillDownData(Object masterObject,List<Object> inputRowList){
  String dbName=getDBName(masterObject);
  drillDownMap=(DBMap<Object,List<Object>>)getMapDB(dbName);
  super.handleDrillDownData(masterObject,inputRowList);
}
Program: 137168
Project: 137168
Buggy source:
@Override public void handleDrillDownData(Object masterObject,Object currentObject,int columnCount,int currentIndex,String currentColumnName){
  List<Object> rowData=drillDownMap.get(masterObject);
  if (rowData == null) {
    rowData=new ArrayList<Object>();
    drillDownMap.put(masterObject,rowData);
    this.drillDownRowCount++;
  }
  rowData.add(currentObject == null ? PluginConstant.NULL_STRING : currentObject);
}

Fixed version (ground truth):
@Override public void handleDrillDownData(Object masterObject,List<Object> inputRowList){
  drillDownRowCount++;
  drillDownMap.put(masterObject,inputRowList);
}
Program: 137169
Project: 137169
Buggy source:
/** 
 * DOC talend Comment method "handleDrillDownData".
 * @param masterObject
 * @param currentObject
 * @param columnCount
 * @param currentIndex
 * @param currentColumnName
 */
void handleDrillDownData(Object masterObject,Object currentObject,int columnCount,int currentIndex,String currentColumnName);

Fixed version (ground truth):
/** 
 * DOC msjian Comment method "handleDrillDownData".
 * @param masterObject
 * @param inputRowList
 */
void handleDrillDownData(Object masterObject,List<Object> inputRowList);
Program: 137170
Project: 137170
Buggy source:
public java.util.Map.Entry<K,V> lowerEntry(K key){
  return dbMap.lowerEntry(key);
}

Fixed version (ground truth):
@Override public java.util.Map.Entry<K,V> lowerEntry(K key){
  return dbMap.lowerEntry(key);
}
Program: 137171
Project: 137171
Buggy source:
public NavigableSet<K> descendingKeySet(){
  return dbMap.descendingKeySet();
}

Fixed version (ground truth):
@Override public NavigableSet<K> descendingKeySet(){
  return dbMap.descendingKeySet();
}
Program: 137172
Project: 137172
Buggy source:
public java.util.Map.Entry<K,V> ceilingEntry(K key){
  return dbMap.ceilingEntry(key);
}

Fixed version (ground truth):
@Override public java.util.Map.Entry<K,V> ceilingEntry(K key){
  return dbMap.ceilingEntry(key);
}
Program: 137173
Project: 137173
Buggy source:
public ConcurrentNavigableMap<K,V> descendingMap(){
  return dbMap.descendingMap();
}

Fixed version (ground truth):
@Override public ConcurrentNavigableMap<K,V> descendingMap(){
  return dbMap.descendingMap();
}
Program: 137174
Project: 137174
Buggy source:
public Collection<V> values(){
  return dbMap.values();
}

Fixed version (ground truth):
@Override public Collection<V> values(){
  return dbMap.values();
}
Program: 137175
Project: 137175
Buggy source:
public V replace(K key,V value){
  return dbMap.replace(key,value);
}

Fixed version (ground truth):
@Override public V replace(K key,V value){
  return dbMap.replace(key,value);
}
Program: 137176
Project: 137176
Buggy source:
public NavigableSet<K> navigableKeySet(){
  return dbMap.navigableKeySet();
}

Fixed version (ground truth):
@Override public NavigableSet<K> navigableKeySet(){
  return dbMap.navigableKeySet();
}
Program: 137177
Project: 137177
Buggy source:
public java.util.Map.Entry<K,V> higherEntry(K key){
  return dbMap.higherEntry(key);
}

Fixed version (ground truth):
@Override public java.util.Map.Entry<K,V> higherEntry(K key){
  return dbMap.higherEntry(key);
}
Program: 137178
Project: 137178
Buggy source:
public boolean containsValue(Object value){
  return dbMap.containsValue(value);
}

Fixed version (ground truth):
@Override public boolean containsValue(Object value){
  return dbMap.containsValue(value);
}
Program: 137179
Project: 137179
Buggy source:
@SuppressWarnings("String_Node_Str") public V put(K key,V value){
  if (key == null) {
    return dbMap.put((K)EMPTY,value);
  }
  return dbMap.put(key,value);
}

Fixed version (ground truth):
@Override @SuppressWarnings("String_Node_Str") public V put(K key,V value){
  if (key == null) {
    return dbMap.put((K)EMPTY,value);
  }
  return dbMap.put(key,value);
}
Program: 137180
Project: 137180
Buggy source:
public boolean remove(Object key,Object value){
  return dbMap.remove(key,value);
}

Fixed version (ground truth):
@Override public boolean remove(Object key,Object value){
  return dbMap.remove(key,value);
}
Program: 137181
Project: 137181
Buggy source:
public java.util.Map.Entry<K,V> pollFirstEntry(){
  return dbMap.pollFirstEntry();
}

Fixed version (ground truth):
@Override public java.util.Map.Entry<K,V> pollFirstEntry(){
  return dbMap.pollFirstEntry();
}
Program: 137182
Project: 137182
Buggy source:
public K higherKey(K key){
  return dbMap.higherKey(key);
}

Fixed version (ground truth):
@Override public K higherKey(K key){
  return dbMap.higherKey(key);
}
Program: 137183
Project: 137183
Buggy source:
public V get(Object key){
  if (key == null) {
    return dbMap.get(EMPTY);
  }
  return dbMap.get(key);
}

Fixed version (ground truth):
@Override public V get(Object key){
  if (key == null) {
    return dbMap.get(EMPTY);
  }
  return dbMap.get(key);
}
Program: 137184
Project: 137184
Buggy source:
public void putAll(Map<? extends K,? extends V> m){
  dbMap.putAll(m);
}

Fixed version (ground truth):
@Override public void putAll(Map<? extends K,? extends V> m){
  dbMap.putAll(m);
}
Program: 137185
Project: 137185
Buggy source:
public K lastKey(){
  return dbMap.lastKey();
}

Fixed version (ground truth):
@Override public K lastKey(){
  return dbMap.lastKey();
}
Program: 137186
Project: 137186
Buggy source:
public java.util.Map.Entry<K,V> firstEntry(){
  return dbMap.firstEntry();
}

Fixed version (ground truth):
@Override public java.util.Map.Entry<K,V> firstEntry(){
  return dbMap.firstEntry();
}
Program: 137187
Project: 137187
Buggy source:
public NavigableSet<K> keySet(){
  return dbMap.keySet();
}

Fixed version (ground truth):
@Override public NavigableSet<K> keySet(){
  return dbMap.keySet();
}
Program: 137188
Project: 137188
Buggy source:
public K floorKey(K key){
  return dbMap.floorKey(key);
}

Fixed version (ground truth):
@Override public K floorKey(K key){
  return dbMap.floorKey(key);
}