nus-yam/ex-repair huggingface dataset:
Program: 72702
Project: 72702
Buggy source:
public void shutdown(){
  logger.entering("String_Node_Str","String_Node_Str");
  if (dataSources == null) {
    logger.fine("String_Node_Str");
    return;
  }
  if (shutdownListenerList != null) {
    for (int i=0; i < shutdownListenerList.size(); i++) {
      ((IShutdownListener)shutdownListenerList.get(i)).dataEngineShutdown();
    }
    shutdownListenerList.clear();
  }
  Collection col=dataSources.values();
  Iterator it=col.iterator();
  while (it.hasNext()) {
    DataSourceRuntime ds=(DataSourceRuntime)it.next();
    try {
      closeDataSource(ds);
    }
 catch (    DataException e) {
      if (logger.isLoggable(Level.FINE))       logger.log(Level.FINE,"String_Node_Str" + ds + "String_Node_Str",e);
    }
  }
  this.dataSourceManager.close();
  logger.logp(Level.INFO,DataEngineImpl.class.getName(),"String_Node_Str","String_Node_Str");
  dataSetDesigns=null;
  dataSources=null;
  clearTempFile();
  logger.exiting(DataEngineImpl.class.getName(),"String_Node_Str");
}

Fixed version (ground truth):
public void shutdown(){
  logger.entering("String_Node_Str","String_Node_Str");
  if (dataSources == null) {
    logger.fine("String_Node_Str");
    return;
  }
  if (shutdownListenerList != null) {
    for (int i=0; i < shutdownListenerList.size(); i++) {
      ((IShutdownListener)shutdownListenerList.get(i)).dataEngineShutdown();
    }
    shutdownListenerList.clear();
  }
  Collection col=dataSources.values();
  Iterator it=col.iterator();
  while (it.hasNext()) {
    DataSourceRuntime ds=(DataSourceRuntime)it.next();
    try {
      closeDataSource(ds);
    }
 catch (    DataException e) {
      if (logger.isLoggable(Level.FINE))       logger.log(Level.FINE,"String_Node_Str" + ds + "String_Node_Str",e);
    }
  }
  this.dataSourceManager.close();
  logger.logp(Level.FINE,DataEngineImpl.class.getName(),"String_Node_Str","String_Node_Str");
  dataSetDesigns=null;
  dataSources=null;
  clearTempFile();
  logger.exiting(DataEngineImpl.class.getName(),"String_Node_Str");
}
Program: 72703
Project: 72703
Buggy source:
protected void paintFigure(Graphics graphics){
  if (isSelect()) {
    graphics.setBackgroundColor(ReportColorConstants.SelctionFillColor);
  }
 else {
    graphics.setBackgroundColor(ReportColorConstants.TableGuideFillColor);
  }
  graphics.setLineStyle(SWT.LINE_SOLID);
  Rectangle bounds=getBounds().getCopy().resize(-1,-1);
  graphics.fillRectangle(bounds);
  Font font=FontManager.getFont("String_Node_Str",7,SWT.NORMAL);
  graphics.setFont(font);
  Image image=getImage();
  if (image == null)   return;
  org.eclipse.swt.graphics.Rectangle rect=image.getBounds();
  int x=bounds.x + (bounds.width - rect.width) / 2;
  int y=bounds.y + (bounds.height - rect.height) / 2;
  graphics.drawImage(image,x,y);
  TableEditPart part=(TableEditPart)getOwner();
  RowHandleAdapter rowHandleAdapter=HandleAdapterFactory.getInstance().getRowHandleAdapter(part.getRow(getRowNumber()));
  String type=rowHandleAdapter.getType();
  String displayName=rowHandleAdapter.getDisplayName();
  if (TableHandleAdapter.TABLE_GROUP_HEADER.equals(type) || TableHandleAdapter.TABLE_GROUP_FOOTER.equals(type)) {
    graphics.drawString(displayName,x + rect.width + 2,y + 2);
  }
  graphics.setBackgroundColor(ColorConstants.black);
}

Fixed version (ground truth):
protected void paintFigure(Graphics graphics){
  if (isSelect()) {
    graphics.setBackgroundColor(ReportColorConstants.SelctionFillColor);
  }
 else {
    graphics.setBackgroundColor(ReportColorConstants.TableGuideFillColor);
  }
  graphics.setLineStyle(SWT.LINE_SOLID);
  Rectangle bounds=getBounds().getCopy().resize(-1,-1);
  graphics.fillRectangle(bounds);
  Font font=FontManager.getFont("String_Node_Str",7,SWT.NORMAL);
  graphics.setFont(font);
  Image image=getImage();
  if (image == null)   return;
  graphics.setForegroundColor(ColorConstants.white);
  graphics.setXORMode(true);
  org.eclipse.swt.graphics.Rectangle rect=image.getBounds();
  int x=bounds.x + (bounds.width - rect.width) / 2;
  int y=bounds.y + (bounds.height - rect.height) / 2;
  graphics.drawImage(image,x,y);
  TableEditPart part=(TableEditPart)getOwner();
  RowHandleAdapter rowHandleAdapter=HandleAdapterFactory.getInstance().getRowHandleAdapter(part.getRow(getRowNumber()));
  String type=rowHandleAdapter.getType();
  String displayName=rowHandleAdapter.getDisplayName();
  if (TableHandleAdapter.TABLE_GROUP_HEADER.equals(type) || TableHandleAdapter.TABLE_GROUP_FOOTER.equals(type)) {
    graphics.drawString(displayName,x + rect.width + 2,y + 2);
  }
  graphics.setBackgroundColor(ColorConstants.black);
  graphics.setXORMode(false);
}
Program: 72704
Project: 72704
Buggy source:
public long getID(){
  return componentID;
}

Fixed version (ground truth):
/** 
 * Get an identifier for a report component.
 * @return componentID
 */
public long getID(){
  return componentID;
}
Program: 72705
Project: 72705
Buggy source:
public String getName(){
  return name;
}

Fixed version (ground truth):
/** 
 * Get data extraction extension name.
 * @return name
 */
public String getName(){
  return name;
}
Program: 72706
Project: 72706
Buggy source:
public String getMimeType(){
  return mimeType;
}

Fixed version (ground truth):
/** 
 * Get mime type of the output file.
 * @return mimeType
 */
public String getMimeType(){
  return mimeType;
}
Program: 72707
Project: 72707
Buggy source:
public DataExtractionFormatInfo(String id,String format,String mimeType,String name,IConfigurationElement dataExtractionExtension){
  this.id=id;
  this.format=format;
  this.mimeType=mimeType;
  this.name=name;
  this.dataExtractionExtension=dataExtractionExtension;
}

Fixed version (ground truth):
/** 
 * Constructor of the class DataExtractionFormatInfo.
 * @param id
 * @param format
 * @param mimeType
 * @param name
 * @param dataExtractionExtension
 */
public DataExtractionFormatInfo(String id,String format,String mimeType,String name,IConfigurationElement dataExtractionExtension){
  this.id=id;
  this.format=format;
  this.mimeType=mimeType;
  this.name=name;
  this.dataExtractionExtension=dataExtractionExtension;
}
Program: 72708
Project: 72708
Buggy source:
public String getFormat(){
  return format;
}

Fixed version (ground truth):
/** 
 * Get extraction format of the output file.
 * @return format
 */
public String getFormat(){
  return format;
}
Program: 72709
Project: 72709
Buggy source:
public String getId(){
  return id;
}

Fixed version (ground truth):
/** 
 * Get data extraction extension id.
 * @return id
 */
public String getId(){
  return id;
}
Program: 72710
Project: 72710
Buggy source:
public IConfigurationElement getDataExtractionExtension(){
  return dataExtractionExtension;
}

Fixed version (ground truth):
/** 
 * Get configuration element of data extraction extension.
 * @return dataExtractionExtension
 */
public IConfigurationElement getDataExtractionExtension(){
  return dataExtractionExtension;
}
Program: 72711
Project: 72711
Buggy source:
public void setExtension(String extension){
  setOption(EXTENSION,extension);
}

Fixed version (ground truth):
/** 
 * Set extension id.
 * @param extension extension id.
 */
public void setExtension(String extension){
  setOption(EXTENSION,extension);
}
Program: 72712
Project: 72712
Buggy source:
public String getExtension(){
  return getStringOption(EXTENSION);
}

Fixed version (ground truth):
/** 
 * Get extension.
 */
public String getExtension(){
  return getStringOption(EXTENSION);
}
Program: 72713
Project: 72713
Buggy source:
public void setOutputStream(OutputStream out){
  setOption(OUTPUT_STREAM,out);
}

Fixed version (ground truth):
/** 
 * Set output stream.
 * @param out output stream.
 */
public void setOutputStream(OutputStream out){
  setOption(OUTPUT_STREAM,out);
}
Program: 72714
Project: 72714
Buggy source:
public String getOutputFormat(){
  return getStringOption(OUTPUT_FORMAT);
}

Fixed version (ground truth):
/** 
 * Get output format.
 */
public String getOutputFormat(){
  return getStringOption(OUTPUT_FORMAT);
}
Program: 72715
Project: 72715
Buggy source:
public OutputStream getOutputStream(){
  Object value=getOption(OUTPUT_STREAM);
  if (value instanceof OutputStream) {
    return (OutputStream)value;
  }
  return null;
}

Fixed version (ground truth):
/** 
 * Get output stream.
 */
public OutputStream getOutputStream(){
  Object value=getOption(OUTPUT_STREAM);
  if (value instanceof OutputStream) {
    return (OutputStream)value;
  }
  return null;
}
Program: 72716
Project: 72716
Buggy source:
public void setOutputFormat(String format){
  setOption(OUTPUT_FORMAT,format);
}

Fixed version (ground truth):
/** 
 * Set output format.
 * @param format output format.
 */
public void setOutputFormat(String format){
  setOption(OUTPUT_FORMAT,format);
}
Program: 72717
Project: 72717
Buggy source:
public void setOutputFile(String filename){
  setOption(OUTPUT_FILE_NAME,filename);
}

Fixed version (ground truth):
/** 
 * Set output file.
 * @param filename name of the output file.
 */
public void setOutputFile(String filename){
  setOption(OUTPUT_FILE_NAME,filename);
}
Program: 72718
Project: 72718
Buggy source:
public String getOutputFile(){
  return getStringOption(OUTPUT_FILE_NAME);
}

Fixed version (ground truth):
/** 
 * Get output file name.
 */
public String getOutputFile(){
  return getStringOption(OUTPUT_FILE_NAME);
}
Program: 72719
Project: 72719
Buggy source:
public DataID(DataSetID dataSet,String cellId){
  this.dataSet=dataSet;
  this.cellId=cellId;
}

Fixed version (ground truth):
/** 
 * Create the new data id instantce.
 * @param dataSet data set
 * @param cellId cell id
 */
public DataID(DataSetID dataSet,String cellId){
  this.dataSet=dataSet;
  this.cellId=cellId;
}
Program: 72720
Project: 72720
Buggy source:
/** 
 * return the row id
 * @return
 */
public long getRowID(){
  return rowId;
}

Fixed version (ground truth):
/** 
 * Return the row id.
 * @return
 */
public long getRowID(){
  return rowId;
}
Program: 72721
Project: 72721
Buggy source:
public String getCellID(){
  return cellId;
}

Fixed version (ground truth):
/** 
 * Return the cell id.
 * @return
 */
public String getCellID(){
  return cellId;
}
Program: 72722
Project: 72722
Buggy source:
static DataID parse(char[] buffer,int offset,int length){
  int ptr=offset + length - 1;
  while (ptr >= offset) {
    if (buffer[ptr] != ':') {
      ptr--;
    }
 else {
      if (ptr > offset && buffer[ptr - 1] == ':') {
        ptr--;
        ptr--;
      }
 else {
        break;
      }
    }
  }
  if (ptr >= offset && buffer[ptr] == ':') {
    String strRowId=new String(buffer,ptr + 1,offset + length - ptr - 1);
    ptr--;
    if (ptr >= offset) {
      DataSetID dataSetId=DataSetID.parse(buffer,offset,ptr - offset + 1);
      if (dataSetId != null) {
        try {
          long rowId=Long.parseLong(strRowId);
          return new DataID(dataSetId,rowId);
        }
 catch (        Exception ex) {
        }
        return new DataID(dataSetId,strRowId);
      }
    }
  }
  return null;
}

Fixed version (ground truth):
/** 
 * create a new data id instance from the buffer.
 * @param buffer
 * @param offset
 * @param length
 * @return data id instance
 */
static DataID parse(char[] buffer,int offset,int length){
  int ptr=offset + length - 1;
  while (ptr >= offset) {
    if (buffer[ptr] != ':') {
      ptr--;
    }
 else {
      if (ptr > offset && buffer[ptr - 1] == ':') {
        ptr--;
        ptr--;
      }
 else {
        break;
      }
    }
  }
  if (ptr >= offset && buffer[ptr] == ':') {
    String strRowId=new String(buffer,ptr + 1,offset + length - ptr - 1);
    ptr--;
    if (ptr >= offset) {
      DataSetID dataSetId=DataSetID.parse(buffer,offset,ptr - offset + 1);
      if (dataSetId != null) {
        try {
          long rowId=Long.parseLong(strRowId);
          return new DataID(dataSetId,rowId);
        }
 catch (        Exception ex) {
        }
        return new DataID(dataSetId,strRowId);
      }
    }
  }
  return null;
}
Program: 72723
Project: 72723
Buggy source:
/** 
 * row id in the parent data set.
 * @return
 */
public long getRowID(){
  return rowId;
}

Fixed version (ground truth):
/** 
 * row id in the parent data set.
 * @return row id
 */
public long getRowID(){
  return rowId;
}
Program: 72724
Project: 72724
Buggy source:
public String getCellID(){
  return cellId;
}

Fixed version (ground truth):
/** 
 * cell id in the parent data set.
 * @return cell id
 */
public String getCellID(){
  return cellId;
}
Program: 72725
Project: 72725
Buggy source:
static public DataSetID parse(char[] buffer,int offset,int length){
  int ptr=offset + length - 1;
  while (ptr >= offset && buffer[ptr] != '.') {
    ptr--;
  }
  if (ptr >= offset && buffer[ptr] == '.') {
    String queryName=new String(buffer,ptr + 1,offset + length - ptr - 1);
    ptr--;
    length=ptr - offset + 1;
    while (ptr >= offset && buffer[ptr] != '.') {
      ptr--;
    }
    if (ptr >= offset && buffer[ptr] == '.') {
      String strRowId=new String(buffer,ptr + 1,offset + length - ptr - 1);
      ptr--;
      if (ptr >= offset && buffer[ptr] == '}' && buffer[offset] == '{') {
        ptr--;
        offset++;
        if (ptr >= offset) {
          DataSetID parent=parse(buffer,offset,ptr - offset + 1);
          if (parent != null) {
            try {
              long rowId=Long.parseLong(strRowId);
              return new DataSetID(parent,rowId,queryName);
            }
 catch (            Exception ex) {
            }
            return new DataSetID(parent,strRowId,queryName);
          }
        }
      }
    }
  }
  return new DataSetID(new String(buffer,offset,length));
}

Fixed version (ground truth):
/** 
 * Parse dataSetID.
 * @param buffer
 * @param offset
 * @param length
 * @return DataSetID object
 */
static public DataSetID parse(char[] buffer,int offset,int length){
  int ptr=offset + length - 1;
  while (ptr >= offset && buffer[ptr] != '.') {
    ptr--;
  }
  if (ptr >= offset && buffer[ptr] == '.') {
    String queryName=new String(buffer,ptr + 1,offset + length - ptr - 1);
    ptr--;
    length=ptr - offset + 1;
    while (ptr >= offset && buffer[ptr] != '.') {
      ptr--;
    }
    if (ptr >= offset && buffer[ptr] == '.') {
      String strRowId=new String(buffer,ptr + 1,offset + length - ptr - 1);
      ptr--;
      if (ptr >= offset && buffer[ptr] == '}' && buffer[offset] == '{') {
        ptr--;
        offset++;
        if (ptr >= offset) {
          DataSetID parent=parse(buffer,offset,ptr - offset + 1);
          if (parent != null) {
            try {
              long rowId=Long.parseLong(strRowId);
              return new DataSetID(parent,rowId,queryName);
            }
 catch (            Exception ex) {
            }
            return new DataSetID(parent,strRowId,queryName);
          }
        }
      }
    }
  }
  return new DataSetID(new String(buffer,offset,length));
}
Program: 72726
Project: 72726
Buggy source:
/** 
 * parent data set if any.
 * @return
 */
public DataSetID getParentID(){
  return parent;
}

Fixed version (ground truth):
/** 
 * parent data set if any.
 * @return parent data set
 */
public DataSetID getParentID(){
  return parent;
}
Program: 72727
Project: 72727
Buggy source:
public boolean getWrappingText(){
  return getBooleanOption(WRAPPING_TEXT,true);
}

Fixed version (ground truth):
/** 
 * Get the flag which indicates if text wrapped.
 * @return text if it is wrapped
 */
public boolean getWrappingText(){
  return getBooleanOption(WRAPPING_TEXT,true);
}
Program: 72728
Project: 72728
Buggy source:
public String getOfficeVersion(){
  if (getStringOption(OFFICE_VERSION) == null)   return "String_Node_Str";
  return getStringOption(OFFICE_VERSION);
}

Fixed version (ground truth):
/** 
 * Get office version.
 * @return office version
 */
public String getOfficeVersion(){
  if (getStringOption(OFFICE_VERSION) == null)   return "String_Node_Str";
  return getStringOption(OFFICE_VERSION);
}
Program: 72729
Project: 72729
Buggy source:
public void setOfficeVersion(String officeVersion){
  setOption(OFFICE_VERSION,officeVersion);
}

Fixed version (ground truth):
/** 
 * Set office version.
 * @param officeVersion
 */
public void setOfficeVersion(String officeVersion){
  setOption(OFFICE_VERSION,officeVersion);
}
Program: 72730
Project: 72730
Buggy source:
public void setWrappingText(boolean wrappingText){
  setOption(WRAPPING_TEXT,wrappingText);
}

Fixed version (ground truth):
/** 
 * Set wrapping text.
 * @param wrappingText
 */
public void setWrappingText(boolean wrappingText){
  setOption(WRAPPING_TEXT,wrappingText);
}
Program: 72732
Project: 72732
Buggy source:
protected void setUp() throws Exception {
  super.setUp();
  nodes[0]=new Node("String_Node_Str");
  nodes[1]=new Node("String_Node_Str");
  nodes[2]=new Node("String_Node_Str");
  nodes[3]=new Node("String_Node_Str");
  nodes[4]=new Node("String_Node_Str");
}

Fixed version (ground truth):
protected void setUp() throws Exception {
  super.setUp();
}
Program: 72733
Project: 72733
Buggy source:
/** 
 * compile the expression
 * @param expression
 * @return List contains all column reference
 * @throws BirtException
 */
public static List compileColumnExpression(ExpressionParserUtility util,String expression,boolean rowMode) throws BirtException {
  if (expression == null || expression.trim().length() == 0)   return new ArrayList();
  if (rowMode)   util.ROW_INDICATOR=ROW_COLUMN_INDICATOR;
 else   util.ROW_INDICATOR=DATASETROW_INDICATOR;
  List columnExprList=new ArrayList();
  columnExprList.clear();
  Context context=Context.enter();
  try {
    ScriptOrFnNode tree=util.parse(expression,context);
    util.CompiledExprFromTree(expression,context,tree,columnExprList);
  }
 catch (  Exception ex) {
    throw new CoreException(util.pluginId,ResourceConstants.INVALID_EXPRESSION,ex);
  }
 finally {
    Context.exit();
  }
  return columnExprList;
}

Fixed version (ground truth):
/** 
 * compile the expression
 * @param expression
 * @return List contains all column reference
 * @throws BirtException
 */
public static List compileColumnExpression(ExpressionParserUtility util,String expression,boolean rowMode) throws BirtException {
  if (expression == null || expression.trim().length() == 0)   return new ArrayList();
  if (rowMode)   util.ROW_INDICATOR=ROW_COLUMN_INDICATOR;
 else   util.ROW_INDICATOR=DATASETROW_INDICATOR;
  List columnExprList=new ArrayList();
  columnExprList.clear();
  Context context=Context.enter();
  try {
    ScriptOrFnNode tree=util.parse(expression,context);
    util.CompiledExprFromTree(expression,context,tree,columnExprList);
  }
 catch (  Exception ex) {
    throw new CoreException(ResourceConstants.INVALID_EXPRESSION,expression,ex);
  }
 finally {
    Context.exit();
  }
  return columnExprList;
}
Program: 72734
Project: 72734
Buggy source:
private void saveNamingRelation(NamingRelation relation) throws DataException {
  this.rdSave.saveNamingRelation(relation);
}

Fixed version (ground truth):
private void saveNamingRelation(NamingRelation relation) throws DataException {
  this.getRdSave().saveNamingRelation(relation);
}
Program: 72735
Project: 72735
Buggy source:
protected void endCell(IContent content,boolean finished,IContentEmitter emitter,boolean visible){
  ((AbstractNode)currentNode).setFinished(finished);
  if (currentNode.isStarted()) {
    currentNode.end();
  }
  currentNode=currentNode.getParent();
}

Fixed version (ground truth):
protected void endCell(IContent content,boolean finished,IContentEmitter emitter,boolean visible){
  AbstractNode current=(AbstractNode)currentNode;
  if (!current.isFirst) {
    current.setFinished(false);
  }
 else {
    current.setFinished(finished);
  }
  if (currentNode.isStarted()) {
    currentNode.end();
  }
  currentNode=currentNode.getParent();
}
Program: 72737
Project: 72737
Buggy source:
public boolean hasNextChild(){
  if (currentElement < elements.size()) {
    return true;
  }
  if (hasGroup) {
    if (endGroup) {
      return false;
    }
    try {
      while (!endGroup) {
        int endingGroupIndex=getEndingGroupLevel(rowCursor,groupCursors);
        if (endingGroupIndex <= currentGroupIndex + 1) {
          currentElement=0;
          elements=new ArrayList();
          if (totalMeasureCount > 0 || !IColumnWalker.IGNORE_TOTAL_COLUMN_WITHOUT_MEASURE) {
            if (!isCurrentLevelLeafGroup() && currentLevel != null && currentLevel.getAggregationHeader() != null && AGGREGATION_HEADER_LOCATION_AFTER.equals(currentLevel.getAggregationHeaderLocation())) {
              CrosstabGroupBandExecutor bandExecutor=new CrosstabGroupBandExecutor(this,currentDimensionIndex,currentLevelIndex,IBandContent.BAND_FOOTER);
              elements.add(bandExecutor);
            }
          }
          endGroup=true;
          return currentElement < elements.size();
        }
        if (rowCursor.next()) {
          collectExecutable();
          return currentElement < elements.size();
        }
      }
    }
 catch (    OLAPException e) {
      logger.log(Level.SEVERE,Messages.getString("String_Node_Str"),e);
    }
  }
  return false;
}

Fixed version (ground truth):
public boolean hasNextChild(){
  if (currentElement < elements.size()) {
    return true;
  }
  if (hasGroup) {
    if (endGroup) {
      return false;
    }
    try {
      while (!endGroup) {
        int endingGroupIndex=GroupUtil.getEndingGroupLevel(rowCursor,groupCursors);
        if (endingGroupIndex <= currentGroupIndex + 1) {
          currentElement=0;
          elements=new ArrayList();
          if (totalMeasureCount > 0 || !IColumnWalker.IGNORE_TOTAL_COLUMN_WITHOUT_MEASURE) {
            if (!isCurrentLevelLeafGroup() && currentLevel != null && currentLevel.getAggregationHeader() != null && AGGREGATION_HEADER_LOCATION_AFTER.equals(currentLevel.getAggregationHeaderLocation())) {
              CrosstabGroupBandExecutor bandExecutor=new CrosstabGroupBandExecutor(this,currentDimensionIndex,currentLevelIndex,IBandContent.BAND_FOOTER);
              elements.add(bandExecutor);
            }
          }
          endGroup=true;
          return currentElement < elements.size();
        }
        if (rowCursor.next()) {
          collectExecutable();
          return currentElement < elements.size();
        }
      }
    }
 catch (    OLAPException e) {
      logger.log(Level.SEVERE,Messages.getString("String_Node_Str"),e);
    }
  }
  return false;
}
Program: 72738
Project: 72738
Buggy source:
private void collectExecutable() throws OLAPException {
  endOfGroups=false;
  currentChild=0;
  children=new ArrayList();
  int startingGroupIndex=getStartingGroupLevel(rowCursor,groupCursors);
  if (startingGroupIndex <= 0) {
    if (columnGroups.size() > 0 || GroupUtil.hasMeasureHeader(crosstabItem,COLUMN_AXIS_TYPE) || crosstabItem.getHeader() != null) {
      CrosstabHeaderExecutor headerExecutor=new CrosstabHeaderExecutor(this);
      children.add(headerExecutor);
    }
  }
{
    CrosstabGroupExecutor groupExecutor=new CrosstabGroupExecutor(this,0,rowCursor);
    children.add(groupExecutor);
  }
  int endingGroupIndex=getEndingGroupLevel(rowCursor,groupCursors);
  if (endingGroupIndex <= 0) {
    if (crosstabItem.getGrandTotal(ROW_AXIS_TYPE) != null && (measureCount > 0 || !IColumnWalker.IGNORE_TOTAL_COLUMN_WITHOUT_MEASURE)) {
      CrosstabFooterExecutor totalExecutor=new CrosstabFooterExecutor(this);
      children.add(totalExecutor);
    }
    endOfGroups=true;
  }
}

Fixed version (ground truth):
private void collectExecutable() throws OLAPException {
  endOfGroups=false;
  currentChild=0;
  children=new ArrayList();
  int startingGroupIndex=GroupUtil.getStartingGroupLevel(rowCursor,groupCursors);
  if (startingGroupIndex <= 0) {
    if (columnGroups.size() > 0 || GroupUtil.hasMeasureHeader(crosstabItem,COLUMN_AXIS_TYPE) || crosstabItem.getHeader() != null) {
      CrosstabHeaderExecutor headerExecutor=new CrosstabHeaderExecutor(this);
      children.add(headerExecutor);
    }
  }
{
    CrosstabGroupExecutor groupExecutor=new CrosstabGroupExecutor(this,0,rowCursor);
    children.add(groupExecutor);
  }
  int endingGroupIndex=GroupUtil.getEndingGroupLevel(rowCursor,groupCursors);
  if (endingGroupIndex <= 0) {
    if (crosstabItem.getGrandTotal(ROW_AXIS_TYPE) != null && (measureCount > 0 || !IColumnWalker.IGNORE_TOTAL_COLUMN_WITHOUT_MEASURE)) {
      CrosstabFooterExecutor totalExecutor=new CrosstabFooterExecutor(this);
      children.add(totalExecutor);
    }
    endOfGroups=true;
  }
}
Program: 72739
Project: 72739
Buggy source:
public IContent execute(){
  ITableContent content=context.getReportContent().createTableContent();
  executeQuery(crosstabItem);
  initializeContent(content,crosstabItem);
  processStyle(crosstabItem);
  processVisibility(crosstabItem);
  processBookmark(crosstabItem);
  processAction(crosstabItem);
  content.setCaption(crosstabItem.getCaption());
  content.setCaptionKey(crosstabItem.getCaptionKey());
  content.setSummary(crosstabItem.getSummary());
  content.setHeaderRepeat(crosstabItem.isRepeatColumnHeader());
  if (getCubeCursor() != null) {
    styleCache=new HashMap();
    try {
      rowGroups=GroupUtil.getGroups(crosstabItem,ROW_AXIS_TYPE);
      columnGroups=GroupUtil.getGroups(crosstabItem,COLUMN_AXIS_TYPE);
      walker=new CachedColumnWalker(crosstabItem,getColumnEdgeCursor());
      new TableColumnGenerator(crosstabItem,walker,getCubeResultSet()).generateColumns(context.getReportContent(),content);
      prepareChildren();
    }
 catch (    OLAPException e) {
      logger.log(Level.SEVERE,Messages.getString("String_Node_Str"),e);
    }
  }
 else {
    logger.log(Level.SEVERE,Messages.getString("String_Node_Str"));
  }
  return content;
}

Fixed version (ground truth):
public IContent execute(){
  ITableContent content=context.getReportContent().createTableContent();
  executeQuery(crosstabItem);
  initializeContent(content,crosstabItem);
  processStyle(crosstabItem);
  processVisibility(crosstabItem);
  processBookmark(crosstabItem);
  processAction(crosstabItem);
  content.setCaption(crosstabItem.getCaption());
  content.setCaptionKey(crosstabItem.getCaptionKey());
  content.setSummary(crosstabItem.getSummary());
  content.setHeaderRepeat(crosstabItem.isRepeatColumnHeader());
  if (getCubeCursor() != null) {
    styleCache=new HashMap();
    try {
      rowGroups=GroupUtil.getGroups(crosstabItem,ROW_AXIS_TYPE);
      columnGroups=GroupUtil.getGroups(crosstabItem,COLUMN_AXIS_TYPE);
      walker=new CachedColumnWalker(crosstabItem,getColumnEdgeCursor());
      new TableColumnGenerator(crosstabItem,walker,getCubeResultSet(),getColumnEdgeCursor(),columnGroups).generateColumns(context.getReportContent(),content);
      prepareChildren();
    }
 catch (    OLAPException e) {
      logger.log(Level.SEVERE,Messages.getString("String_Node_Str"),e);
    }
  }
 else {
    logger.log(Level.SEVERE,Messages.getString("String_Node_Str"));
  }
  return content;
}
Program: 72740
Project: 72740
Buggy source:
public boolean hasNextChild(){
  if (children == null) {
    return false;
  }
  if (currentChild < children.size()) {
    return true;
  }
  if (needRowGroups) {
    if (endOfGroups) {
      return false;
    }
    try {
      while (!endOfGroups) {
        int endingGroupIndex=getEndingGroupLevel(rowCursor,groupCursors);
        if (endingGroupIndex <= 0) {
          currentChild=0;
          children=new ArrayList();
          if (crosstabItem.getGrandTotal(ROW_AXIS_TYPE) != null && (measureCount > 0 || !IColumnWalker.IGNORE_TOTAL_COLUMN_WITHOUT_MEASURE)) {
            CrosstabFooterExecutor totalExecutor=new CrosstabFooterExecutor(this);
            children.add(totalExecutor);
          }
          endOfGroups=true;
          return currentChild < children.size();
        }
        if (rowCursor.next()) {
          collectExecutable();
          return currentChild < children.size();
        }
      }
    }
 catch (    OLAPException e) {
      logger.log(Level.SEVERE,Messages.getString("String_Node_Str"),e);
    }
  }
  return false;
}

Fixed version (ground truth):
public boolean hasNextChild(){
  if (children == null) {
    return false;
  }
  if (currentChild < children.size()) {
    return true;
  }
  if (needRowGroups) {
    if (endOfGroups) {
      return false;
    }
    try {
      while (!endOfGroups) {
        int endingGroupIndex=GroupUtil.getEndingGroupLevel(rowCursor,groupCursors);
        if (endingGroupIndex <= 0) {
          currentChild=0;
          children=new ArrayList();
          if (crosstabItem.getGrandTotal(ROW_AXIS_TYPE) != null && (measureCount > 0 || !IColumnWalker.IGNORE_TOTAL_COLUMN_WITHOUT_MEASURE)) {
            CrosstabFooterExecutor totalExecutor=new CrosstabFooterExecutor(this);
            children.add(totalExecutor);
          }
          endOfGroups=true;
          return currentChild < children.size();
        }
        if (rowCursor.next()) {
          collectExecutable();
          return currentChild < children.size();
        }
      }
    }
 catch (    OLAPException e) {
      logger.log(Level.SEVERE,Messages.getString("String_Node_Str"),e);
    }
  }
  return false;
}
Program: 72742
Project: 72742
Buggy source:
void adaptBaseDataSet(DataSetHandle modelDataSet,BaseDataSetDesign dteDataSet) throws BirtException {
  if ((!(modelDataSet instanceof JointDataSetHandle)) && modelDataSet.getDataSource() == null)   throw new EngineException("String_Node_Str");
  if (!(modelDataSet instanceof JointDataSetHandle)) {
    dteDataSet.setDataSource(modelDataSet.getDataSource().getQualifiedName());
    dteDataSet.setBeforeOpenScript(modelDataSet.getBeforeOpen());
    dteDataSet.setAfterOpenScript(modelDataSet.getAfterOpen());
    dteDataSet.setOnFetchScript(modelDataSet.getOnFetch());
    dteDataSet.setBeforeCloseScript(modelDataSet.getBeforeClose());
    dteDataSet.setAfterCloseScript(modelDataSet.getAfterClose());
  }
  populateParameter(modelDataSet,dteDataSet);
  populateComputedColumn(modelDataSet,dteDataSet);
  populateFilter(modelDataSet,dteDataSet);
  dteDataSet.setRowFetchLimit(modelDataSet.getRowFetchLimit());
  mergeHints(modelDataSet,dteDataSet);
}

Fixed version (ground truth):
void adaptBaseDataSet(DataSetHandle modelDataSet,BaseDataSetDesign dteDataSet) throws BirtException {
  if ((!(modelDataSet instanceof JointDataSetHandle)) && modelDataSet.getDataSource() == null)   throw new EngineException(MessageConstants.DATA_SOURCE_ERROR);
  if (!(modelDataSet instanceof JointDataSetHandle)) {
    dteDataSet.setDataSource(modelDataSet.getDataSource().getQualifiedName());
    dteDataSet.setBeforeOpenScript(modelDataSet.getBeforeOpen());
    dteDataSet.setAfterOpenScript(modelDataSet.getAfterOpen());
    dteDataSet.setOnFetchScript(modelDataSet.getOnFetch());
    dteDataSet.setBeforeCloseScript(modelDataSet.getBeforeClose());
    dteDataSet.setAfterCloseScript(modelDataSet.getAfterClose());
  }
  populateParameter(modelDataSet,dteDataSet);
  populateComputedColumn(modelDataSet,dteDataSet);
  populateFilter(modelDataSet,dteDataSet);
  dteDataSet.setRowFetchLimit(modelDataSet.getRowFetchLimit());
  mergeHints(modelDataSet,dteDataSet);
}
Program: 72744
Project: 72744
Buggy source:
public void extract(IDataExtractionOption option) throws BirtException {
  throw new EngineException("String_Node_Str");
}

Fixed version (ground truth):
public void extract(IDataExtractionOption option) throws BirtException {
  throw new EngineException(MessageConstants.UNSUPPORTED_DOCUMENT_VERSION_ERROR);
}
Program: 72745
Project: 72745
Buggy source:
private IDataExtractionExtension getDataExtractionExtension(IDataExtractionOption option) throws EngineException {
  IDataExtractionExtension dataExtraction=null;
  String extension=option.getExtension();
  ExtensionManager extensionManager=ExtensionManager.getInstance();
  if (extension != null) {
    dataExtraction=extensionManager.createDataExtractionExtensionById(extension);
    if (dataExtraction == null) {
      logger.log(Level.WARNING,"String_Node_Str" + extension + "String_Node_Str");
    }
  }
  if (dataExtraction == null) {
    String format=option.getOutputFormat();
    if (format != null) {
      dataExtraction=extensionManager.createDataExtractionExtensionByFormat(format);
      if (dataExtraction == null) {
        logger.log(Level.WARNING,"String_Node_Str" + format + "String_Node_Str");
      }
    }
  }
  if (dataExtraction == null) {
    throw new EngineException("String_Node_Str");
  }
  return dataExtraction;
}

Fixed version (ground truth):
private IDataExtractionExtension getDataExtractionExtension(IDataExtractionOption option) throws EngineException {
  IDataExtractionExtension dataExtraction=null;
  String extension=option.getExtension();
  ExtensionManager extensionManager=ExtensionManager.getInstance();
  if (extension != null) {
    dataExtraction=extensionManager.createDataExtractionExtensionById(extension);
    if (dataExtraction == null) {
      logger.log(Level.WARNING,"String_Node_Str" + extension + "String_Node_Str");
    }
  }
  if (dataExtraction == null) {
    String format=option.getOutputFormat();
    if (format != null) {
      dataExtraction=extensionManager.createDataExtractionExtensionByFormat(format);
      if (dataExtraction == null) {
        logger.log(Level.WARNING,"String_Node_Str" + format + "String_Node_Str");
      }
    }
  }
  if (dataExtraction == null) {
    throw new EngineException(MessageConstants.INVALID_EXTENSION_ERROR);
  }
  return dataExtraction;
}
Program: 72746
Project: 72746
Buggy source:
public Object getValue(int index) throws BirtException {
  if (beforeFirstRow) {
    throw new EngineException("String_Node_Str");
  }
  IResultMetaData metaData=getResultMetaData();
  String columnName=metaData.getColumnName(index);
  return iterator.getValue(columnName);
}

Fixed version (ground truth):
public Object getValue(int index) throws BirtException {
  if (beforeFirstRow) {
    throw new EngineException(MessageConstants.RESULTSET_ITERATOR_ERROR);
  }
  IResultMetaData metaData=getResultMetaData();
  String columnName=metaData.getColumnName(index);
  return iterator.getValue(columnName);
}
Program: 72747
Project: 72747
Buggy source:
public static List parsePageSequence(String pageRange,long totalPage) throws EngineException {
  ArrayList list=new ArrayList();
  if (null == pageRange || "String_Node_Str".equals(pageRange) || pageRange.toUpperCase().indexOf("String_Node_Str") >= 0) {
    list.add(new long[]{1,totalPage});
    return list;
  }
  String[] ps=pageRange.split("String_Node_Str");
  for (int i=0; i < ps.length; i++) {
    try {
      if (ps[i].indexOf("String_Node_Str") > 0) {
        String[] psi=ps[i].split("String_Node_Str");
        if (psi.length == 2) {
          long start=Long.parseLong(psi[0].trim());
          long end=Long.parseLong(psi[1].trim());
          if (start > 0 && end <= totalPage && end >= start) {
            list.add(new long[]{Math.max(start,1),Math.min(end,totalPage)});
          }
 else {
            throw new EngineException("String_Node_Str" + ps[i]);
          }
        }
 else {
          throw new EngineException("String_Node_Str" + ps[i]);
        }
      }
 else {
        long number=Long.parseLong(ps[i].trim());
        if (number > 0 && number <= totalPage) {
          list.add(new long[]{number,number});
        }
 else {
          throw new EngineException("String_Node_Str" + ps[i]);
        }
      }
    }
 catch (    NumberFormatException ex) {
      throw new EngineException("String_Node_Str" + ps[i]);
    }
  }
  return sort(list);
}

Fixed version (ground truth):
public static List parsePageSequence(String pageRange,long totalPage) throws EngineException {
  ArrayList list=new ArrayList();
  if (null == pageRange || "String_Node_Str".equals(pageRange) || pageRange.toUpperCase().indexOf("String_Node_Str") >= 0) {
    list.add(new long[]{1,totalPage});
    return list;
  }
  String[] ps=pageRange.split("String_Node_Str");
  for (int i=0; i < ps.length; i++) {
    try {
      if (ps[i].indexOf("String_Node_Str") > 0) {
        String[] psi=ps[i].split("String_Node_Str");
        if (psi.length == 2) {
          long start=Long.parseLong(psi[0].trim());
          long end=Long.parseLong(psi[1].trim());
          if (start > 0 && end <= totalPage && end >= start) {
            list.add(new long[]{Math.max(start,1),Math.min(end,totalPage)});
          }
 else {
            throw new EngineException(MessageConstants.PAGE_NUMBER_RANGE_ERROR,ps[i]);
          }
        }
 else {
          throw new EngineException(MessageConstants.PAGE_NUMBER_RANGE_ERROR,ps[i]);
        }
      }
 else {
        long number=Long.parseLong(ps[i].trim());
        if (number > 0 && number <= totalPage) {
          list.add(new long[]{number,number});
        }
 else {
          throw new EngineException(MessageConstants.PAGE_NUMBER_RANGE_ERROR,ps[i]);
        }
      }
    }
 catch (    NumberFormatException ex) {
      throw new EngineException(MessageConstants.PAGE_NUMBER_RANGE_ERROR,ps[i]);
    }
  }
  return sort(list);
}
Program: 72748
Project: 72748
Buggy source:
public void setBookmark(String bookmark) throws EngineException {
  long pageNumber=reportDoc.getPageNumber(bookmark);
  if (pageNumber <= 0) {
    throw new EngineException("String_Node_Str",bookmark);
  }
  innerRender=new PageRangeRender(new long[]{pageNumber,pageNumber});
}

Fixed version (ground truth):
public void setBookmark(String bookmark) throws EngineException {
  long pageNumber=reportDoc.getPageNumber(bookmark);
  if (pageNumber <= 0) {
    throw new EngineException(MessageConstants.BOOKMARK_NOT_FOUND_ERROR,bookmark);
  }
  innerRender=new PageRangeRender(new long[]{pageNumber,pageNumber});
}
Program: 72749
Project: 72749
Buggy source:
protected IPageHint getPageHint(ReportPageExecutor executor,long pageNumber){
  try {
    return executor.getLayoutPageHint(pageNumber);
  }
 catch (  IOException ex) {
    executionContext.addException(new EngineException("String_Node_Str",ex));
    return null;
  }
}

Fixed version (ground truth):
protected IPageHint getPageHint(ReportPageExecutor executor,long pageNumber){
  try {
    return executor.getLayoutPageHint(pageNumber);
  }
 catch (  IOException ex) {
    executionContext.addException(new EngineException(MessageConstants.PAGE_HINT_LOADING_ERROR,ex));
    return null;
  }
}
Program: 72750
Project: 72750
Buggy source:
ReportletRender(String bookmark) throws EngineException {
  this.offset=reportDoc.getBookmarkOffset(bookmark);
  if (offset == -1) {
    throw new EngineException("String_Node_Str" + bookmark);
  }
}

Fixed version (ground truth):
ReportletRender(String bookmark) throws EngineException {
  this.offset=reportDoc.getBookmarkOffset(bookmark);
  if (offset == -1) {
    throw new EngineException(MessageConstants.INVALID_BOOKMARK_ERROR,bookmark);
  }
}
Program: 72751
Project: 72751
Buggy source:
public long getPageCount() throws EngineException {
  if (runningStatus != STATUS_SUCCEEDED) {
    throw new EngineException("String_Node_Str");
  }
  return pageCount;
}

Fixed version (ground truth):
public long getPageCount() throws EngineException {
  if (runningStatus != STATUS_SUCCEEDED) {
    throw new EngineException(MessageConstants.RENDERTASK_NOT_FINISHED_ERROR);
  }
  return pageCount;
}
Program: 72752
Project: 72752
Buggy source:
public void setPageNumber(long pageNumber) throws EngineException {
  if (pageNumber <= 0 || pageNumber > totalPage) {
    throw new EngineException("String_Node_Str",new Long(pageNumber));
  }
  innerRender=new PageRangeRender(new long[]{pageNumber,pageNumber});
}

Fixed version (ground truth):
public void setPageNumber(long pageNumber) throws EngineException {
  if (pageNumber <= 0 || pageNumber > totalPage) {
    throw new EngineException(MessageConstants.PAGE_NOT_FOUND_ERROR,new Long(pageNumber));
  }
  innerRender=new PageRangeRender(new long[]{pageNumber,pageNumber});
}
Program: 72753
Project: 72753
Buggy source:
private void loadBasicInfo() throws EngineException {
  try {
    Object lock=archive.lock(CORE_STREAM);
    try {
synchronized (lock) {
        RAInputStream in=archive.getStream(CORE_STREAM);
        try {
          DataInputStream di=new DataInputStream(in);
          checkVersion(di);
          if (coreVersion == -1) {
            loadOldBasicInfo(di);
          }
 else           if (coreVersion == 0) {
            loadBasicInfoV0(di);
          }
 else {
            throw new IOException("String_Node_Str" + coreVersion);
          }
        }
  finally {
          in.close();
        }
      }
    }
  finally {
      archive.unlock(lock);
    }
  }
 catch (  IOException ee) {
    close();
    throw new EngineException("String_Node_Str",ee);
  }
}

Fixed version (ground truth):
private void loadBasicInfo() throws EngineException {
  try {
    Object lock=archive.lock(CORE_STREAM);
    try {
synchronized (lock) {
        RAInputStream in=archive.getStream(CORE_STREAM);
        try {
          DataInputStream di=new DataInputStream(in);
          checkVersion(di);
          if (coreVersion == -1) {
            loadOldBasicInfo(di);
          }
 else           if (coreVersion == 0) {
            loadBasicInfoV0(di);
          }
 else {
            throw new IOException("String_Node_Str" + coreVersion);
          }
        }
  finally {
          in.close();
        }
      }
    }
  finally {
      archive.unlock(lock);
    }
  }
 catch (  IOException ee) {
    close();
    throw new EngineException(MessageConstants.REPORT_DOCUMENT_OPEN_ERROR,ee);
  }
}
Program: 72754
Project: 72754
Buggy source:
private int getColumnIndex(int index) throws BirtException {
  if (selectedColumns == null) {
    return index;
  }
  String name=selectedColumns[index];
  if (null != parentMetaData) {
    for (int i=0; i < parentMetaData.getColumnCount(); i++) {
      String columnName=parentMetaData.getColumnName(i);
      if (columnName.equals(name)) {
        return i;
      }
    }
  }
 else {
    for (int i=0; i < metaEntries.size(); i++) {
      MetaDataEntry entry=(MetaDataEntry)metaEntries.get(i);
      if (entry.name.equals(name)) {
        return i;
      }
    }
  }
  throw new EngineException("String_Node_Str");
}

Fixed version (ground truth):
private int getColumnIndex(int index) throws BirtException {
  if (selectedColumns == null) {
    return index;
  }
  String name=selectedColumns[index];
  if (null != parentMetaData) {
    for (int i=0; i < parentMetaData.getColumnCount(); i++) {
      String columnName=parentMetaData.getColumnName(i);
      if (columnName.equals(name)) {
        return i;
      }
    }
  }
 else {
    for (int i=0; i < metaEntries.size(); i++) {
      MetaDataEntry entry=(MetaDataEntry)metaEntries.get(i);
      if (entry.name.equals(name)) {
        return i;
      }
    }
  }
  throw new EngineException(MessageConstants.INVALID_COLUMN_INDEX_ERROR);
}
Program: 72757
Project: 72757
Buggy source:
private void openReportDocument() throws EngineException {
  try {
    if (archive == null) {
      openArchive();
    }
    writer=new ReportDocumentWriter(engine,archive);
    executionContext.setReportDocWriter(writer);
  }
 catch (  IOException ex) {
    throw new EngineException("String_Node_Str",ex);
  }
}

Fixed version (ground truth):
private void openReportDocument() throws EngineException {
  try {
    if (archive == null) {
      openArchive();
    }
    writer=new ReportDocumentWriter(engine,archive);
    executionContext.setReportDocWriter(writer);
  }
 catch (  IOException ex) {
    throw new EngineException(MessageConstants.REPORT_ARCHIVE_OPEN_ERROR,ex);
  }
}
Program: 72758
Project: 72758
Buggy source:
public IBaseResultSet execute(IBaseResultSet parent,IDataQueryDefinition query,boolean useCache) throws BirtException {
  if (query instanceof ISubqueryDefinition) {
    if (parent == null) {
      return null;
    }
 else     if (parent instanceof ICubeResultSet) {
      throw new EngineException("String_Node_Str" + ((ISubqueryDefinition)query).getName());
    }
    return doExecuteSubQuery((IQueryResultSet)parent,(ISubqueryDefinition)query);
  }
 else   if (query instanceof IQueryDefinition) {
    return doExecuteQuery(parent,(IQueryDefinition)query,useCache);
  }
 else   if (query instanceof ICubeQueryDefinition) {
    return doExecuteCube(parent,(ICubeQueryDefinition)query,useCache);
  }
 else   if (query instanceof ISubCubeQueryDefinition) {
    return doExecuteSubCubeQuery((ICubeResultSet)parent,(ISubCubeQueryDefinition)query);
  }
  throw new EngineException("String_Node_Str" + query.getClass().getName());
}

Fixed version (ground truth):
public IBaseResultSet execute(IBaseResultSet parent,IDataQueryDefinition query,boolean useCache) throws BirtException {
  if (query instanceof ISubqueryDefinition) {
    if (parent == null) {
      return null;
    }
 else     if (parent instanceof ICubeResultSet) {
      throw new EngineException(MessageConstants.INCORRECT_PARENT_RESULSET_ERROR,((ISubqueryDefinition)query).getName());
    }
    return doExecuteSubQuery((IQueryResultSet)parent,(ISubqueryDefinition)query);
  }
 else   if (query instanceof IQueryDefinition) {
    return doExecuteQuery(parent,(IQueryDefinition)query,useCache);
  }
 else   if (query instanceof ICubeQueryDefinition) {
    return doExecuteCube(parent,(ICubeQueryDefinition)query,useCache);
  }
 else   if (query instanceof ISubCubeQueryDefinition) {
    return doExecuteSubCubeQuery((ICubeResultSet)parent,(ISubCubeQueryDefinition)query);
  }
  throw new EngineException(MessageConstants.UNSUPPORTED_QUERY_TYPE_ERROR,query.getClass().getName());
}
Program: 72759
Project: 72759
Buggy source:
public String getCellIndex(){
  try {
    cellId=CubeUtil.getPositionID(cube);
  }
 catch (  OLAPException e) {
    context.addException(new EngineException("String_Node_Str",e));
  }
  return cellId;
}

Fixed version (ground truth):
public String getCellIndex(){
  try {
    cellId=CubeUtil.getPositionID(cube);
  }
 catch (  OLAPException e) {
    context.addException(new EngineException(MessageConstants.CUBE_POSITION_ERROR,e));
  }
  return cellId;
}
Program: 72760
Project: 72760
Buggy source:
public void skipTo(String cellIndex) throws BirtException {
  try {
    CubeUtil.positionCursor(cube,cellIndex);
  }
 catch (  OLAPException e) {
    throw new EngineException("String_Node_Str",e);
  }
}

Fixed version (ground truth):
public void skipTo(String cellIndex) throws BirtException {
  try {
    CubeUtil.positionCursor(cube,cellIndex);
  }
 catch (  OLAPException e) {
    throw new EngineException(MessageConstants.SKIP_ERROR,e);
  }
}
Program: 72761
Project: 72761
Buggy source:
/** 
 * Get cached data set item model. If none is cached, return null;
 * @param ds
 * @param columns
 */
public DataSetViewData[] getCachedDataSetItemModel(DataSetHandle ds){
  DataSetViewData[] result=(DataSetViewData[])this.htColumns.get(ds);
  if (result == null) {
    DataRequestSession session;
    try {
      DataSessionContext context=new DataSessionContext(DataSessionContext.MODE_DIRECT_PRESENTATION,ds.getModuleHandle());
      session=DataRequestSession.newSession(context);
      result=this.populateAllOutputColumns(ds,session);
      return result;
    }
 catch (    BirtException e) {
      result=new DataSetViewData[0];
    }
  }
  return result;
}

Fixed version (ground truth):
/** 
 * Get cached data set item model. If none is cached, return null;
 * @param ds
 * @param columns
 */
public DataSetViewData[] getCachedDataSetItemModel(DataSetHandle ds){
  DataSetViewData[] result=(DataSetViewData[])this.htColumns.get(ds);
  if (result == null) {
    DataRequestSession session;
    try {
      DataSessionContext context=new DataSessionContext(DataSessionContext.MODE_DIRECT_PRESENTATION,ds.getModuleHandle());
      session=DataRequestSession.newSession(context);
      result=this.populateAllOutputColumns(ds,session);
      session.shutdown();
      return result;
    }
 catch (    BirtException e) {
      result=new DataSetViewData[0];
    }
  }
  return result;
}