nus-yam/ex-repair huggingface dataset:
Program: 94436
Project: 94436
Buggy source:
private static void writeAttributes(final DataOutput out,final Geometry g) throws IOException {
  out.writeInt(g.getAllAttributes().size());
  for (  Map.Entry attr : g.getAllAttributesSorted().entrySet()) {
    out.writeUTF(attr.getKey().toString());
    byte[] attrBytes=attr.getValue().toString().getBytes(CHAR_ENCODING);
    out.writeInt(attrBytes.length);
    out.write(attrBytes);
  }
}

Fixed version (ground truth):
private static void writeAttributes(final DataOutput out,final Geometry g) throws IOException {
  out.writeInt(g.getAllAttributes().size());
  for (  Map.Entry attr : g.getAllAttributesSorted().entrySet()) {
    out.writeUTF(attr.getKey().toString());
    StringUtils.write(attr.getValue().toString(),out);
  }
}
Program: 94437
Project: 94437
Buggy source:
public static Bounds getBounds(final Dataset image){
  final double[] xform=image.GetGeoTransform();
  SpatialReference srs=new SpatialReference(image.GetProjection());
  SpatialReference dst=new SpatialReference(EPSG4326);
  CoordinateTransformation tx=osr.CreateCoordinateTransformation(srs,dst);
  double w=image.GetRasterXSize();
  double h=image.GetRasterYSize();
  double[] c1;
  double[] c2;
  double[] c3;
  double[] c4;
  if (tx != null) {
    c1=tx.TransformPoint(xform[0],xform[3]);
    c2=tx.TransformPoint(xform[0] + xform[1] * w,xform[3] + xform[5] * h);
    c3=tx.TransformPoint(xform[0] + xform[1] * w,xform[3]);
    c4=tx.TransformPoint(xform[0],xform[3] + xform[5] * h);
  }
 else {
    c1=new double[]{xform[0],xform[3]};
    c2=new double[]{xform[0] + xform[1] * w,xform[3] + xform[5] * h};
    c3=new double[]{xform[0] + xform[1] * w,xform[3]};
    c4=new double[]{xform[0],xform[3] + xform[5] * h};
  }
  return new Bounds(Math.min(Math.min(c1[0],c2[0]),Math.min(c3[0],c4[0])),Math.min(Math.min(c1[1],c2[1]),Math.min(c3[1],c4[1])),Math.max(Math.max(c1[0],c2[0]),Math.max(c3[0],c4[0])),Math.max(Math.max(c1[1],c2[1]),Math.max(c3[1],c4[1])));
}

Fixed version (ground truth):
public static Bounds getBounds(final Dataset image){
  final double[] xform=image.GetGeoTransform();
  SpatialReference srs=new SpatialReference(image.GetProjection());
  SpatialReference dst=new SpatialReference(EPSG4326);
  CoordinateTransformation tx=new CoordinateTransformation(srs,dst);
  double w=image.GetRasterXSize();
  double h=image.GetRasterYSize();
  double[] c1;
  double[] c2;
  double[] c3;
  double[] c4;
  if (tx != null) {
    c1=tx.TransformPoint(xform[0],xform[3]);
    c2=tx.TransformPoint(xform[0] + xform[1] * w,xform[3] + xform[5] * h);
    c3=tx.TransformPoint(xform[0] + xform[1] * w,xform[3]);
    c4=tx.TransformPoint(xform[0],xform[3] + xform[5] * h);
  }
 else {
    c1=new double[]{xform[0],xform[3]};
    c2=new double[]{xform[0] + xform[1] * w,xform[3] + xform[5] * h};
    c3=new double[]{xform[0] + xform[1] * w,xform[3]};
    c4=new double[]{xform[0],xform[3] + xform[5] * h};
  }
  return new Bounds(Math.min(Math.min(c1[0],c2[0]),Math.min(c3[0],c4[0])),Math.min(Math.min(c1[1],c2[1]),Math.min(c3[1],c4[1])),Math.max(Math.max(c1[0],c2[0]),Math.max(c3[0],c4[0])),Math.max(Math.max(c1[1],c2[1]),Math.max(c3[1],c4[1])));
}
Program: 94438
Project: 94438
Buggy source:
/** 
 * Return an instance of a RecordWriter class to be used in map/reduce jobs for writing vector data.
 * @return
 */
public abstract RecordWriter<LongWritable,Geometry> getRecordWriter();

Fixed version (ground truth):
/** 
 * Return an instance of a RecordWriter class to be used in map/reduce jobs for writing vector data.
 * @return
 */
public abstract RecordWriter<FeatureIdWritable,Geometry> getRecordWriter();
Program: 94439
Project: 94439
Buggy source:
/** 
 * Return an instance of a RecordReader class to be used in map/reduce jobs for reading vector data.
 * @return
 */
public abstract RecordReader<LongWritable,Geometry> getRecordReader() throws IOException ;

Fixed version (ground truth):
/** 
 * Return an instance of a RecordReader class to be used in map/reduce jobs for reading vector data.
 * @return
 */
public abstract RecordReader<FeatureIdWritable,Geometry> getRecordReader() throws IOException ;
Program: 94440
Project: 94440
Buggy source:
@Override public RecordReader<LongWritable,Geometry> createRecordReader(InputSplit split,TaskAttemptContext context) throws IOException, InterruptedException {
  return new VectorRecordReader();
}

Fixed version (ground truth):
@Override public RecordReader<FeatureIdWritable,Geometry> createRecordReader(InputSplit split,TaskAttemptContext context) throws IOException, InterruptedException {
  return new VectorRecordReader();
}
Program: 94441
Project: 94441
Buggy source:
/** 
 * Returns an instance of an InputFormat for the data provider that is responsible for translating the keys and values from the native InputFormat to LongWritable keys and Geometry values.
 * @return
 */
public abstract InputFormat<LongWritable,Geometry> getInputFormat(String input);

Fixed version (ground truth):
/** 
 * Returns an instance of an InputFormat for the data provider that is responsible for translating the keys and values from the native InputFormat to FeatureIdWritable keys and Geometry values.
 * @return
 */
public abstract InputFormat<FeatureIdWritable,Geometry> getInputFormat(String input);
Program: 94442
Project: 94442
Buggy source:
/** 
 * Returns an instance of an OutputFormat for the data provider that is responsible for translating the keys and values from the native InputFormat to LongWritable keys and Geometry values.
 * @return
 */
public OutputFormat<LongWritable,Geometry> getOutputFormat(String input);

Fixed version (ground truth):
/** 
 * Returns an instance of an OutputFormat for the data provider that is responsible for translating the keys and values from the native InputFormat to FeatureIdWritable keys and Geometry values.
 * @return
 */
public OutputFormat<FeatureIdWritable,Geometry> getOutputFormat(String input);
Program: 94443
Project: 94443
Buggy source:
/** 
 * Return an iterator that allows the caller to visit all geometries within this reader that fall within the specified bounds. The caller is responsible for calling the close() method on the returned iterator when they are done with it. It is possible that the last call to the next() method of the returned iterator could give back a null value, so the caller should test for that.
 * @return
 */
public abstract CloseableKVIterator<LongWritable,Geometry> get(final Bounds bounds) throws IOException ;

Fixed version (ground truth):
/** 
 * Return an iterator that allows the caller to visit all geometries within this reader that fall within the specified bounds. The caller is responsible for calling the close() method on the returned iterator when they are done with it. It is possible that the last call to the next() method of the returned iterator could give back a null value, so the caller should test for that.
 * @return
 */
public abstract CloseableKVIterator<FeatureIdWritable,Geometry> get(final Bounds bounds) throws IOException ;
Program: 94444
Project: 94444
Buggy source:
/** 
 * Returns true if there is a feature with the specified featureId. For non-indexed data sources (like delimited text), this method will iterate through all of the features until it finds the one that matches the specified featureId.
 * @param featureId
 * @return
 * @throws IOException
 */
public abstract boolean exists(LongWritable featureId) throws IOException ;

Fixed version (ground truth):
/** 
 * Returns true if there is a feature with the specified featureId. For non-indexed data sources (like delimited text), this method will iterate through all of the features until it finds the one that matches the specified featureId.
 * @param featureId
 * @return
 * @throws IOException
 */
public abstract boolean exists(FeatureIdWritable featureId) throws IOException ;
Program: 94445
Project: 94445
Buggy source:
@Override public LongWritable getCurrentKey() throws IOException, InterruptedException {
  return delegate.getCurrentKey();
}

Fixed version (ground truth):
@Override public FeatureIdWritable getCurrentKey() throws IOException, InterruptedException {
  return delegate.getCurrentKey();
}
Program: 94446
Project: 94446
Buggy source:
public abstract void append(final LongWritable key,final Geometry value) throws IOException ;

Fixed version (ground truth):
public abstract void append(final FeatureIdWritable key,final Geometry value) throws IOException ;
Program: 94447
Project: 94447
Buggy source:
@Override public RecordWriter<LongWritable,Geometry> getRecordWriter(TaskAttemptContext context) throws IOException, InterruptedException {
  String baseOut=getOutputPath(context).toString();
  String extension=baseOut.substring(baseOut.length() - 4);
  Path output=getDefaultWorkFile(context,extension);
  CsvRecordWriter result=new CsvRecordWriter(new Path(baseOut + "String_Node_Str"),output);
  return result;
}

Fixed version (ground truth):
@Override public RecordWriter<FeatureIdWritable,Geometry> getRecordWriter(TaskAttemptContext context) throws IOException, InterruptedException {
  String baseOut=getOutputPath(context).toString();
  String extension=baseOut.substring(baseOut.length() - 4);
  Path output=getDefaultWorkFile(context,extension);
  CsvRecordWriter result=new CsvRecordWriter(new Path(baseOut + "String_Node_Str"),output);
  return result;
}
Program: 94448
Project: 94448
Buggy source:
@Override public void write(LongWritable key,Geometry value) throws IOException {
  if (first) {
    first=false;
    writeColumns(value);
  }
  boolean useDelim=false;
  if (writeGeometry) {
    if (value.isValid() && !value.isEmpty()) {
      writeCell(value.toJTS().toString());
    }
    useDelim=true;
  }
  for (  String attribute : attributes) {
    if (useDelim) {
      writer.append(delimiter);
    }
    useDelim=true;
    Object cell=value.getAttribute(attribute);
    if (cell != null) {
      writeCell(cell.toString());
    }
  }
  writer.append("String_Node_Str");
}

Fixed version (ground truth):
@Override public void write(FeatureIdWritable key,Geometry value) throws IOException {
  if (first) {
    first=false;
    writeColumns(value);
  }
  boolean useDelim=false;
  if (writeGeometry) {
    if (value.isValid() && !value.isEmpty()) {
      writeCell(value.toJTS().toString());
    }
    useDelim=true;
  }
  for (  String attribute : attributes) {
    if (useDelim) {
      writer.append(delimiter);
    }
    useDelim=true;
    Object cell=value.getAttribute(attribute);
    if (cell != null) {
      writeCell(cell.toString());
    }
  }
  writer.append("String_Node_Str");
}
Program: 94449
Project: 94449
Buggy source:
@Override public LongWritable currentKey(){
  return key;
}

Fixed version (ground truth):
@Override public FeatureIdWritable currentKey(){
  return key;
}
Program: 94450
Project: 94450
Buggy source:
@Test @Category(IntegrationTest.class) public void testDestPtOutsideCostSurface() throws IOException, ParserException, JobCancelledException {
  String exp="String_Node_Str" + "String_Node_Str" + costSurface + "String_Node_Str"+ "String_Node_Str";
  try {
    LeastCostPathMapOpIntegrationTest.runLeastCostPath(HadoopUtils.createConfiguration(),testUtils.getOutputHdfs(),"String_Node_Str",exp,true,50000f,0f,0d,0d,0d);
  }
 catch (  JobFailedException e) {
    boolean ret=e.getMessage().contains("String_Node_Str");
    Assert.assertEquals(true,ret);
  }
}

Fixed version (ground truth):
@Test @Category(IntegrationTest.class) public void testDestPtOutsideCostSurface() throws IOException, ParserException, JobCancelledException {
  String exp="String_Node_Str" + "String_Node_Str" + costSurface + "String_Node_Str"+ "String_Node_Str";
  try {
    LeastCostPathMapOpIntegrationTest.runLeastCostPath(conf,testUtils.getOutputHdfs(),"String_Node_Str",exp,true,50000f,0f,0d,0d,0d);
  }
 catch (  JobFailedException e) {
    boolean ret=e.getMessage().contains("String_Node_Str");
    Assert.assertEquals(true,ret);
  }
}
Program: 94451
Project: 94451
Buggy source:
@Test @Category(IntegrationTest.class) public void testLeastCostPath() throws IOException, ParserException, JobFailedException, JobCancelledException {
  String exp="String_Node_Str" + "String_Node_Str" + costSurface + "String_Node_Str"+ "String_Node_Str";
  LeastCostPathMapOpIntegrationTest.runLeastCostPath(HadoopUtils.createConfiguration(),testUtils.getOutputHdfs(),"String_Node_Str",exp,true,48064f,62920.9f,0.9d,2.0d,1.3d);
}

Fixed version (ground truth):
@Test @Category(IntegrationTest.class) public void testLeastCostPath() throws IOException, ParserException, JobFailedException, JobCancelledException {
  String exp="String_Node_Str" + "String_Node_Str" + costSurface + "String_Node_Str"+ "String_Node_Str";
  LeastCostPathMapOpIntegrationTest.runLeastCostPath(conf,testUtils.getOutputHdfs(),"String_Node_Str",exp,true,48064f,62920.9f,0.9d,2.0d,1.3d);
}
Program: 94452
Project: 94452
Buggy source:
@Test @Category(IntegrationTest.class) public void testLeastCostPathWithZoom() throws IOException, ParserException, JobFailedException, JobCancelledException {
  String exp="String_Node_Str" + "String_Node_Str" + costSurface + "String_Node_Str"+ "String_Node_Str"+ LOWER_ZOOM_LEVEL+ "String_Node_Str";
  try {
    LeastCostPathMapOpIntegrationTest.runLeastCostPath(HadoopUtils.createConfiguration(),testUtils.getOutputHdfs(),"String_Node_Str",exp,true,48064f,62920.9f,0.9d,2.0d,1.3d);
  }
 catch (  JobFailedException e) {
    Assert.assertTrue(e.getMessage().indexOf("String_Node_Str") >= 0);
  }
}

Fixed version (ground truth):
@Test @Category(IntegrationTest.class) public void testLeastCostPathWithZoom() throws IOException, ParserException, JobFailedException, JobCancelledException {
  String exp="String_Node_Str" + "String_Node_Str" + costSurface + "String_Node_Str"+ "String_Node_Str"+ LOWER_ZOOM_LEVEL+ "String_Node_Str";
  try {
    LeastCostPathMapOpIntegrationTest.runLeastCostPath(conf,testUtils.getOutputHdfs(),"String_Node_Str",exp,true,48064f,62920.9f,0.9d,2.0d,1.3d);
  }
 catch (  JobFailedException e) {
    Assert.assertTrue(e.getMessage().indexOf("String_Node_Str") >= 0);
  }
}
Program: 94453
Project: 94453
Buggy source:
@Test @Category(IntegrationTest.class) public void testCostDistance() throws Exception {
  String exp="String_Node_Str" + "String_Node_Str" + frictionSurface + "String_Node_Str"+ "String_Node_Str"+ TOBLER_MEDIUM_ZOOM+ "String_Node_Str";
  if (GEN_BASELINE_DATA_ONLY) {
    testUtils.generateBaselineTif(conf,testname.getMethodName(),exp,-9999);
  }
 else {
    testUtils.runRasterExpression(conf,testname.getMethodName(),exp);
    MrsImageDataProvider dp=DataProviderFactory.getMrsImageDataProvider(new Path(testUtils.getOutputHdfs(),testname.getMethodName()).toUri().toString(),AccessMode.READ,(ProviderProperties)null);
    MrsImagePyramidMetadata metadata=dp.getMetadataReader().read();
    ImageStats[] stats=metadata.getStats();
    ImageStats[] imageStats=metadata.getImageStats(metadata.getMaxZoomLevel());
    ImageStats bandStats=metadata.getStats(0);
    Assert.assertArrayEquals(stats,imageStats);
    Assert.assertEquals(bandStats,imageStats[0]);
    double epsilon=0.5;
    Assert.assertEquals(0,bandStats.min,epsilon);
    Assert.assertEquals(50000,bandStats.max,epsilon);
    Assert.assertEquals(33113.35,bandStats.mean,epsilon);
    Assert.assertEquals(1852001,bandStats.count);
  }
}

Fixed version (ground truth):
@Test @Category(IntegrationTest.class) public void testCostDistance() throws Exception {
  String exp="String_Node_Str" + "String_Node_Str" + frictionSurface + "String_Node_Str"+ "String_Node_Str"+ TOBLER_MEDIUM_ZOOM+ "String_Node_Str";
  if (GEN_BASELINE_DATA_ONLY) {
    testUtils.generateBaselineTif(conf,testname.getMethodName(),exp,-9999);
  }
 else {
    testUtils.runRasterExpression(conf,testname.getMethodName(),exp);
    MrsImageDataProvider dp=DataProviderFactory.getMrsImageDataProvider(new Path(testUtils.getOutputHdfs(),testname.getMethodName()).toUri().toString(),AccessMode.READ,(ProviderProperties)null);
    MrsImagePyramidMetadata metadata=dp.getMetadataReader().read();
    ImageStats[] stats=metadata.getStats();
    ImageStats[] imageStats=metadata.getImageStats(metadata.getMaxZoomLevel());
    ImageStats bandStats=metadata.getStats(0);
    Assert.assertArrayEquals(stats,imageStats);
    Assert.assertEquals(bandStats,imageStats[0]);
    double epsilon=0.5;
    Assert.assertEquals(0,bandStats.min,epsilon);
    Assert.assertEquals(50000,bandStats.max,epsilon);
    Assert.assertEquals(33112.808371797866,bandStats.mean,epsilon);
    Assert.assertEquals(1852051,bandStats.count);
  }
}
Program: 94454
Project: 94454
Buggy source:
public static void setOutputInfo(final Configuration conf,final Job job,final String output){
  setInfo(conf,job);
  if (job != null) {
    FileOutputFormat.setOutputPath(job,new Path(output));
  }
 else {
    conf.set(HdfsMrsPyramidOutputFormat.OUTDIR,output);
  }
}

Fixed version (ground truth):
public static void setOutputInfo(final Configuration conf,final Job job,final String output){
  setInfo(conf,job);
  if (job != null) {
    FileOutputFormat.setOutputPath(job,new Path(output));
  }
 else {
    conf.set("String_Node_Str",output);
    conf.set("String_Node_Str",output);
  }
}
Program: 94456
Project: 94456
Buggy source:
/** 
 * This method will Get a MapFile.Reader for the partition specified
 * @param partition is the particular reader being accessed
 * @return the reader for the partition specified
 * @throws IOException
 */
public MapFile.Reader getReader(final int partition) throws IOException {
  try {
    return readerCache.get(partition);
  }
 catch (  ExecutionException e) {
    if (e.getCause() instanceof IOException) {
      throw (IOException)e.getCause();
    }
    throw new IOException(e);
  }
}

Fixed version (ground truth):
/** 
 * This method will get a MapFile.Reader for the partition specified. Before closing the returned reader, the caller should make sure it is not cached in this class by calling isCachingEnabled(). If that method returns true, the caller should not close the reader. It will be automatically closed when it drops out of the cache.
 * @param partition is the particular reader being accessed
 * @return the reader for the partition specified
 * @throws IOException
 */
public MapFile.Reader getReader(final int partition) throws IOException {
  try {
    if (cachingEnabled) {
      log.info("String_Node_Str" + partition + "String_Node_Str");
      return readerCache.get(partition);
    }
 else {
      log.info("String_Node_Str" + partition + "String_Node_Str");
      return loadReader(partition);
    }
  }
 catch (  ExecutionException e) {
    if (e.getCause() instanceof IOException) {
      throw (IOException)e.getCause();
    }
    throw new IOException(e);
  }
}
Program: 94457
Project: 94457
Buggy source:
/** 
 * The HdfsReader constructor will instantiate the connection to HDFS
 * @param path is the location of the data in HDFS
 * @throws IOException 
 */
public HdfsMrsTileReader(final String path,final int zoom) throws IOException {
  String modifiedPath=path;
  final File file=new File(path);
  if (file.exists()) {
    modifiedPath="String_Node_Str" + file.getAbsolutePath();
  }
  imagePath=new Path(modifiedPath);
  FileSystem fs=HadoopFileUtils.getFileSystem(conf,imagePath);
  if (!fs.exists(imagePath)) {
    throw new IOException("String_Node_Str" + modifiedPath + "String_Node_Str");
  }
  readSplits(modifiedPath);
  if (System.getProperty("String_Node_Str","String_Node_Str").compareToIgnoreCase("String_Node_Str") == 0) {
    profile=true;
  }
 else {
    profile=false;
  }
}

Fixed version (ground truth):
/** 
 * The HdfsReader constructor will instantiate the connection to HDFS
 * @param path is the location of the data in HDFS
 * @throws IOException 
 */
public HdfsMrsTileReader(final String path,final int zoom) throws IOException {
  String modifiedPath=path;
  final File file=new File(path);
  if (file.exists()) {
    modifiedPath="String_Node_Str" + file.getAbsolutePath();
  }
  imagePath=new Path(modifiedPath);
  FileSystem fs=HadoopFileUtils.getFileSystem(conf,imagePath);
  if (!fs.exists(imagePath)) {
    throw new IOException("String_Node_Str" + modifiedPath + "String_Node_Str");
  }
  Path qualifiedImagePath=imagePath.makeQualified(fs);
  URI imagePathUri=qualifiedImagePath.toUri();
  String imageScheme=imagePathUri.getScheme().toLowerCase();
  if (imageScheme.equals("String_Node_Str") || imageScheme.equals("String_Node_Str")) {
    cachingEnabled=false;
  }
  readSplits(modifiedPath);
  if (System.getProperty("String_Node_Str","String_Node_Str").compareToIgnoreCase("String_Node_Str") == 0) {
    profile=true;
  }
 else {
    profile=false;
  }
}
Program: 94458
Project: 94458
Buggy source:
@Override public MapFile.Reader load(final Integer partition) throws IOException {
  final FileSplit.FileSplitInfo part=(FileSplit.FileSplitInfo)splits.getSplits()[partition];
  final Path path=new Path(imagePath,part.getName());
  final FileSystem fs=path.getFileSystem(conf);
  MapFile.Reader reader=new MapFile.Reader(path,conf);
  if (profile) {
    LeakChecker.instance().add(reader,ExceptionUtils.getFullStackTrace(new Throwable("String_Node_Str")));
  }
  LOG.debug("String_Node_Str",partition,part);
  return reader;
}

Fixed version (ground truth):
@Override public MapFile.Reader load(final Integer partition) throws IOException {
  return loadReader(partition);
}
Program: 94459
Project: 94459
Buggy source:
@SuppressWarnings("String_Node_Str") private void primeScanner(final long startTileId,final long endTileId){
  try {
    curPartition=-1;
    int partition=reader.getPartition(new TileIdWritable(startTileId));
    TileIdWritable startKey=null;
    while (curPartition == -1 && partition < reader.getMaxPartitions()) {
      mapfile=reader.getReader(partition);
      try {
        if (startKey == null) {
          startKey=(TileIdWritable)mapfile.getKeyClass().newInstance();
          startKey.set(startTileId);
          endKey=(TileIdWritable)mapfile.getKeyClass().newInstance();
          endKey.set(endTileId);
          currentValue=(TWritable)mapfile.getValueClass().newInstance();
        }
      }
 catch (      InstantiationException e) {
        throw new MrsImageException(e);
      }
catch (      IllegalAccessException e) {
        throw new MrsImageException(e);
      }
      currentKey=(TileIdWritable)mapfile.getClosest(startKey,currentValue);
      if (currentKey != null && inRange(currentKey)) {
        readFirstKey=true;
        curPartition=partition;
      }
 else {
        partition++;
      }
    }
  }
 catch (  Splits.SplitException se) {
    currentKey=null;
  }
catch (  final IOException e) {
    throw new MrsImageException(e);
  }
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") private void primeScanner(final long startTileId,final long endTileId){
  try {
    curPartition=-1;
    int partition=reader.getPartition(new TileIdWritable(startTileId));
    TileIdWritable startKey=null;
    while (curPartition == -1 && partition < reader.getMaxPartitions()) {
      if (!reader.isCachingEnabled() && mapfile != null) {
        mapfile.close();
      }
      mapfile=reader.getReader(partition);
      try {
        if (startKey == null) {
          startKey=(TileIdWritable)mapfile.getKeyClass().newInstance();
          startKey.set(startTileId);
          endKey=(TileIdWritable)mapfile.getKeyClass().newInstance();
          endKey.set(endTileId);
          currentValue=(TWritable)mapfile.getValueClass().newInstance();
        }
      }
 catch (      InstantiationException e) {
        throw new MrsImageException(e);
      }
catch (      IllegalAccessException e) {
        throw new MrsImageException(e);
      }
      currentKey=(TileIdWritable)mapfile.getClosest(startKey,currentValue);
      if (currentKey != null && inRange(currentKey)) {
        readFirstKey=true;
        curPartition=partition;
      }
 else {
        partition++;
      }
    }
  }
 catch (  Splits.SplitException se) {
    currentKey=null;
  }
catch (  final IOException e) {
    throw new MrsImageException(e);
  }
}
Program: 94460
Project: 94460
Buggy source:
/** 
 * Keeping track of what is being sent back and possibly finish using one MapFile and then opening another MapFile if needed.
 */
@Override public boolean hasNext(){
  try {
    if (currentKey == null) {
      return false;
    }
    if (readFirstKey) {
      readFirstKey=false;
      if (currentKey.compareTo(endKey) <= 0) {
        return true;
      }
      return false;
    }
    while (true) {
      final boolean found=mapfile.next(currentKey,currentValue);
      if (found) {
        if (currentKey.compareTo(endKey) <= 0) {
          if (zoom > 0) {
            final TMSUtils.Tile t=TMSUtils.tileid(currentKey.get(),zoom);
            if (t.tx >= rowStart && t.tx <= rowEnd) {
              return true;
            }
            System.out.println("String_Node_Str" + t.toString());
          }
 else {
            return true;
          }
        }
 else {
          return false;
        }
      }
 else {
        if (++curPartition >= reader.getMaxPartitions()) {
          return false;
        }
        mapfile=reader.getReader(curPartition);
      }
    }
  }
 catch (  final IOException e) {
    throw new MrsImageException(e);
  }
}

Fixed version (ground truth):
/** 
 * Keeping track of what is being sent back and possibly finish using one MapFile and then opening another MapFile if needed.
 */
@Override public boolean hasNext(){
  try {
    if (currentKey == null) {
      return false;
    }
    if (readFirstKey) {
      readFirstKey=false;
      if (currentKey.compareTo(endKey) <= 0) {
        return true;
      }
      return false;
    }
    while (true) {
      final boolean found=mapfile.next(currentKey,currentValue);
      if (found) {
        if (currentKey.compareTo(endKey) <= 0) {
          if (zoom > 0) {
            final TMSUtils.Tile t=TMSUtils.tileid(currentKey.get(),zoom);
            if (t.tx >= rowStart && t.tx <= rowEnd) {
              return true;
            }
          }
 else {
            return true;
          }
        }
 else {
          return false;
        }
      }
 else {
        if (++curPartition >= reader.getMaxPartitions()) {
          return false;
        }
        if (!reader.isCachingEnabled() && mapfile != null) {
          mapfile.close();
        }
        mapfile=reader.getReader(curPartition);
      }
    }
  }
 catch (  final IOException e) {
    throw new MrsImageException(e);
  }
}
Program: 94461
Project: 94461
Buggy source:
private void setTile(final String k,final MrsTileReader<T> reader,final long tileid){
  if (zoomLevel > reader.getZoomlevel()) {
    int zl=reader.getZoomlevel();
    TMSUtils.Tile t=TMSUtils.calculateTile(TMSUtils.tileid(tileid,zoomLevel),zoomLevel,zl,tilesize);
    TileIdWritable id=new TileIdWritable(TMSUtils.tileid(t.tx,t.ty,zl));
    T r=getTileFromCache(k,reader,id);
    T split=splitTile(r,id.get(),zl,tileid,zoomLevel,tilesize);
    value.set(k,tileid,split);
  }
 else   if (zoomLevel < splitZoomLevel) {
  }
 else {
    System.err.println("String_Node_Str" + tileid + "String_Node_Str"+ TMSUtils.tileid(tileid,zoomLevel)+ "String_Node_Str");
    T r=readerTileCache.getIfPresent(tileid);
    if (value == null) {
      System.err.println("String_Node_Str" + tileid);
      r=reader.get(new TileIdWritable(tileid));
    }
 else {
      System.err.println("String_Node_Str" + tileid);
    }
    if (r != null) {
      value.set(k,tileid,r);
    }
  }
}

Fixed version (ground truth):
private void setTile(final String k,final MrsTileReader<T> reader,final long tileid){
  if (zoomLevel > reader.getZoomlevel()) {
    int zl=reader.getZoomlevel();
    TMSUtils.Tile t=TMSUtils.calculateTile(TMSUtils.tileid(tileid,zoomLevel),zoomLevel,zl,tilesize);
    TileIdWritable id=new TileIdWritable(TMSUtils.tileid(t.tx,t.ty,zl));
    T r=getTileFromCache(k,reader,id);
    T split=splitTile(r,id.get(),zl,tileid,zoomLevel,tilesize);
    value.set(k,tileid,split);
  }
 else   if (zoomLevel < splitZoomLevel) {
  }
 else {
    System.err.println("String_Node_Str" + k + "String_Node_Str"+ tileid+ "String_Node_Str"+ TMSUtils.tileid(tileid,zoomLevel)+ "String_Node_Str");
    String key=buildReaderTileCacheKey(k,tileid);
    T r=readerTileCache.getIfPresent(key);
    if (r == null) {
      System.err.println("String_Node_Str" + tileid);
      r=reader.get(new TileIdWritable(tileid));
      readerTileCache.put(key,r);
    }
 else {
      System.err.println("String_Node_Str" + tileid);
    }
    if (r != null) {
      value.set(k,tileid,r);
    }
  }
}
Program: 94462
Project: 94462
Buggy source:
@SuppressWarnings("String_Node_Str") private T getTileFromCache(final String k,final MrsTileReader<T> reader,TileIdWritable id){
  if (!tilecache.containsKey(k)) {
    tilecache.put(k,new LRUMap(4));
  }
  Map<TileIdWritable,T> cache=tilecache.get(k);
  if (cache.containsKey(id)) {
    System.err.println("String_Node_Str" + id.get());
    return cache.get(id);
  }
  System.err.println("String_Node_Str" + id.get() + "String_Node_Str");
  T r=reader.get(id);
  cache.put(id,r);
  return r;
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") private T getTileFromCache(final String k,final MrsTileReader<T> reader,TileIdWritable id){
  if (!tilecache.containsKey(k)) {
    tilecache.put(k,new LRUMap(4));
  }
  Map<TileIdWritable,T> cache=tilecache.get(k);
  if (cache.containsKey(id)) {
    System.err.println("String_Node_Str" + id.get());
    return cache.get(id);
  }
  System.err.println("String_Node_Str" + id.get() + "String_Node_Str");
  String key=buildReaderTileCacheKey(k,id.get());
  T r=readerTileCache.getIfPresent(key);
  if (r == null) {
    r=reader.get(id);
    readerTileCache.put(key,r);
  }
  cache.put(id,r);
  return r;
}
Program: 94463
Project: 94463
Buggy source:
private void setNextKeyValue(final long tileid,final T tileValue) throws IOException {
  key.set(tileid);
  value.clear();
  value.setTileid(tileid);
  readerTileCache.put(tileid,tileValue);
  value.set(scannedInput,tileid,tileValue);
  int neighborCountForTile=0;
  if (tileClusterInfo != null && neighborTileIds != null) {
    neighborCountForTile=tileClusterInfo.getNeighbors(tileid,zoomLevel,tilesize,inputBounds,neighborTileIds);
    if (tileClusterInfo != null && neighborTileIds != null) {
      for (int index=0; index < neighborCountForTile; index++) {
        setTile(scannedInput,primaryReader,neighborTileIds[index]);
      }
    }
  }
  for (  final String inputPyramidName : secondaryPyramidNames) {
    MrsTileReader<T> inputReader=readers.get(inputPyramidName);
    if (inputReader == null) {
      inputReader=getMrsTileReader(inputPyramidName,ifContext.getZoomLevel(),myconf);
    }
    setTile(inputPyramidName,inputReader,tileid);
    if (tileClusterInfo != null && neighborTileIds != null) {
      for (int index=0; index < neighborCountForTile; index++) {
        setTile(inputPyramidName,inputReader,neighborTileIds[index]);
      }
    }
  }
}

Fixed version (ground truth):
private void setNextKeyValue(final long tileid,final T tileValue) throws IOException {
  key.set(tileid);
  value.clear();
  value.setTileid(tileid);
  readerTileCache.put(buildReaderTileCacheKey(scannedInput,tileid),tileValue);
  value.set(scannedInput,tileid,tileValue);
  int neighborCountForTile=0;
  if (tileClusterInfo != null && neighborTileIds != null) {
    neighborCountForTile=tileClusterInfo.getNeighbors(tileid,zoomLevel,tilesize,inputBounds,neighborTileIds);
    if (tileClusterInfo != null && neighborTileIds != null) {
      for (int index=0; index < neighborCountForTile; index++) {
        setTile(scannedInput,primaryReader,neighborTileIds[index]);
      }
    }
  }
  for (  final String inputPyramidName : secondaryPyramidNames) {
    MrsTileReader<T> inputReader=readers.get(inputPyramidName);
    if (inputReader == null) {
      inputReader=getMrsTileReader(inputPyramidName,ifContext.getZoomLevel(),myconf);
    }
    setTile(inputPyramidName,inputReader,tileid);
    if (tileClusterInfo != null && neighborTileIds != null) {
      for (int index=0; index < neighborCountForTile; index++) {
        setTile(inputPyramidName,inputReader,neighborTileIds[index]);
      }
    }
  }
}
Program: 94465
Project: 94465
Buggy source:
private void setTile(final String k,final MrsTileReader<T> reader,final long tileid){
  if (zoomLevel > reader.getZoomlevel()) {
    int zl=reader.getZoomlevel();
    TMSUtils.Tile t=TMSUtils.calculateTile(TMSUtils.tileid(tileid,zoomLevel),zoomLevel,zl,tilesize);
    TileIdWritable id=new TileIdWritable(TMSUtils.tileid(t.tx,t.ty,zl));
    T r=getTileFromCache(k,reader,id);
    T split=splitTile(r,id.get(),zl,tileid,zoomLevel,tilesize);
    value.set(k,tileid,split);
  }
 else   if (zoomLevel < splitZoomLevel) {
  }
 else {
    System.err.println("String_Node_Str" + k + "String_Node_Str"+ tileid+ "String_Node_Str"+ TMSUtils.tileid(tileid,zoomLevel)+ "String_Node_Str");
    String key=buildReaderTileCacheKey(k,tileid);
    T r=readerTileCache.getIfPresent(key);
    if (r == null) {
      System.err.println("String_Node_Str" + tileid);
      r=reader.get(new TileIdWritable(tileid));
      readerTileCache.put(key,r);
    }
 else {
      System.err.println("String_Node_Str" + tileid);
    }
    if (r != null) {
      value.set(k,tileid,r);
    }
  }
}

Fixed version (ground truth):
private void setTile(final String k,final MrsTileReader<T> reader,final long tileid){
  if (zoomLevel > reader.getZoomlevel()) {
    int zl=reader.getZoomlevel();
    TMSUtils.Tile t=TMSUtils.calculateTile(TMSUtils.tileid(tileid,zoomLevel),zoomLevel,zl,tilesize);
    TileIdWritable id=new TileIdWritable(TMSUtils.tileid(t.tx,t.ty,zl));
    T r=getTileFromCache(k,reader,id);
    T split=splitTile(r,id.get(),zl,tileid,zoomLevel,tilesize);
    value.set(k,tileid,split);
  }
 else   if (zoomLevel < splitZoomLevel) {
  }
 else {
    String key=buildReaderTileCacheKey(k,tileid);
    T r=readerTileCache.getIfPresent(key);
    if (r == null) {
      r=reader.get(new TileIdWritable(tileid));
      if (r != null) {
        readerTileCache.put(key,r);
      }
    }
    if (r != null) {
      value.set(k,tileid,r);
    }
  }
}
Program: 94466
Project: 94466
Buggy source:
@SuppressWarnings("String_Node_Str") private T getTileFromCache(final String k,final MrsTileReader<T> reader,TileIdWritable id){
  if (!tilecache.containsKey(k)) {
    tilecache.put(k,new LRUMap(4));
  }
  Map<TileIdWritable,T> cache=tilecache.get(k);
  if (cache.containsKey(id)) {
    System.err.println("String_Node_Str" + id.get());
    return cache.get(id);
  }
  System.err.println("String_Node_Str" + id.get() + "String_Node_Str");
  String key=buildReaderTileCacheKey(k,id.get());
  T r=readerTileCache.getIfPresent(key);
  if (r == null) {
    r=reader.get(id);
    readerTileCache.put(key,r);
  }
  cache.put(id,r);
  return r;
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") private T getTileFromCache(final String k,final MrsTileReader<T> reader,TileIdWritable id){
  if (!tilecache.containsKey(k)) {
    tilecache.put(k,new LRUMap(4));
  }
  Map<TileIdWritable,T> cache=tilecache.get(k);
  if (cache.containsKey(id)) {
    return cache.get(id);
  }
  String key=buildReaderTileCacheKey(k,id.get());
  T r=readerTileCache.getIfPresent(key);
  if (r == null) {
    r=reader.get(id);
    if (r != null) {
      readerTileCache.put(key,r);
    }
  }
  cache.put(id,r);
  return r;
}
Program: 94469
Project: 94469
Buggy source:
final public SplitInfo getSplitByName(String name) throws SplitException {
  if (splits == null) {
    throw new SplitException("String_Node_Str");
  }
  for (  SplitInfo split : splits) {
    if (((FileSplitInfo)split).getName().equals(name)) {
      return split;
    }
  }
  throw new SplitException("String_Node_Str" + name + "String_Node_Str");
}

Fixed version (ground truth):
final public SplitInfo getSplitByName(String name) throws SplitException, SplitNotFoundException {
  if (splits == null) {
    throw new SplitException("String_Node_Str");
  }
  for (  SplitInfo split : splits) {
    if (((FileSplitInfo)split).getName().equals(name)) {
      return split;
    }
  }
  throw new SplitNotFoundException("String_Node_Str" + name + "String_Node_Str");
}
Program: 94470
Project: 94470
Buggy source:
/** 
 * This method will get a MapFile.Reader for the partition specified. Before closing the returned reader, the caller should make sure it is not cached in this class by calling isCachingEnabled(). If that method returns true, the caller should not close the reader. It will be automatically closed when it drops out of the cache.
 * @param partition is the particular reader being accessed
 * @return the reader for the partition specified
 * @throws IOException
 */
public MapFile.Reader getReader(final int partition) throws IOException {
  try {
    if (canBeCached) {
      log.info("String_Node_Str" + partition + "String_Node_Str");
      return readerCache.get(partition);
    }
 else {
      log.info("String_Node_Str" + partition + "String_Node_Str");
      return loadReader(partition);
    }
  }
 catch (  ExecutionException e) {
    if (e.getCause() instanceof IOException) {
      throw (IOException)e.getCause();
    }
    throw new IOException(e);
  }
}

Fixed version (ground truth):
/** 
 * This method will get a MapFile.Reader for the partition specified. Before closing the returned reader, the caller should make sure it is not cached in this class by calling isCachingEnabled(). If that method returns true, the caller should not close the reader. It will be automatically closed when it drops out of the cache.
 * @param partitionIndex is the particular reader being accessed
 * @return the reader for the partition specified
 * @throws IOException
 */
public MapFile.Reader getReader(final int partitionIndex) throws IOException {
  try {
    if (canBeCached) {
      log.info("String_Node_Str" + partitionIndex + "String_Node_Str");
      return readerCache.get(partitionIndex);
    }
 else {
      log.info("String_Node_Str" + partitionIndex + "String_Node_Str");
      return loadReader(partitionIndex);
    }
  }
 catch (  ExecutionException e) {
    if (e.getCause() instanceof IOException) {
      throw (IOException)e.getCause();
    }
    throw new IOException(e);
  }
}
Program: 94471
Project: 94471
Buggy source:
@Override public MapFile.Reader load(final Integer partition) throws IOException {
  return loadReader(partition);
}

Fixed version (ground truth):
@Override public MapFile.Reader load(final Integer partitionIndex) throws IOException {
  return loadReader(partitionIndex);
}
Program: 94472
Project: 94472
Buggy source:
private MapFile.Reader loadReader(int partition) throws IOException {
  final FileSplit.FileSplitInfo part=(FileSplit.FileSplitInfo)splits.getSplits()[partition];
  final Path path=new Path(imagePath,part.getName());
  MapFile.Reader reader=new MapFile.Reader(path,conf);
  if (profile) {
    LeakChecker.instance().add(reader,ExceptionUtils.getFullStackTrace(new Throwable("String_Node_Str")));
  }
  return reader;
}

Fixed version (ground truth):
private MapFile.Reader loadReader(int partitionIndex) throws IOException {
  final FileSplit.FileSplitInfo part=(FileSplit.FileSplitInfo)splits.getSplits()[partitionIndex];
  final Path path=new Path(imagePath,part.getName());
  MapFile.Reader reader=new MapFile.Reader(path,conf);
  if (profile) {
    LeakChecker.instance().add(reader,ExceptionUtils.getFullStackTrace(new Throwable("String_Node_Str")));
  }
  return reader;
}
Program: 94473
Project: 94473
Buggy source:
@SuppressWarnings("String_Node_Str") private void primeScanner(final long startTileId,final long endTileId){
  try {
    curPartition=-1;
    int partition=reader.getPartition(new TileIdWritable(startTileId));
    TileIdWritable startKey=null;
    while (curPartition == -1 && partition < reader.getMaxPartitions()) {
      if (!reader.canBeCached() && mapfile != null) {
        mapfile.close();
      }
      mapfile=reader.getReader(partition);
      try {
        if (startKey == null) {
          startKey=(TileIdWritable)mapfile.getKeyClass().newInstance();
          startKey.set(startTileId);
          endKey=(TileIdWritable)mapfile.getKeyClass().newInstance();
          endKey.set(endTileId);
          currentValue=(TWritable)mapfile.getValueClass().newInstance();
        }
      }
 catch (      InstantiationException e) {
        throw new MrsImageException(e);
      }
catch (      IllegalAccessException e) {
        throw new MrsImageException(e);
      }
      currentKey=(TileIdWritable)mapfile.getClosest(startKey,currentValue);
      if (currentKey != null && inRange(currentKey)) {
        readFirstKey=true;
        curPartition=partition;
      }
 else {
        partition++;
      }
    }
  }
 catch (  Splits.SplitException se) {
    currentKey=null;
  }
catch (  final IOException e) {
    throw new MrsImageException(e);
  }
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") private void primeScanner(final long startTileId,final long endTileId){
  try {
    curPartitionIndex=-1;
    int partitionIndex=reader.getPartitionIndex(new TileIdWritable(startTileId));
    TileIdWritable startKey=null;
    while (curPartitionIndex == -1 && partitionIndex < reader.getMaxPartitions()) {
      if (!reader.canBeCached() && mapfile != null) {
        mapfile.close();
      }
      mapfile=reader.getReader(partitionIndex);
      try {
        if (startKey == null) {
          startKey=(TileIdWritable)mapfile.getKeyClass().newInstance();
          startKey.set(startTileId);
          endKey=(TileIdWritable)mapfile.getKeyClass().newInstance();
          endKey.set(endTileId);
          currentValue=(TWritable)mapfile.getValueClass().newInstance();
        }
      }
 catch (      InstantiationException e) {
        throw new MrsImageException(e);
      }
catch (      IllegalAccessException e) {
        throw new MrsImageException(e);
      }
      currentKey=(TileIdWritable)mapfile.getClosest(startKey,currentValue);
      if (currentKey != null && inRange(currentKey)) {
        readFirstKey=true;
        curPartitionIndex=partitionIndex;
      }
 else {
        partitionIndex++;
      }
    }
  }
 catch (  Splits.SplitException se) {
    currentKey=null;
  }
catch (  final IOException e) {
    throw new MrsImageException(e);
  }
}
Program: 94474
Project: 94474
Buggy source:
/** 
 * Keeping track of what is being sent back and possibly finish using one MapFile and then opening another MapFile if needed.
 */
@Override public boolean hasNext(){
  try {
    if (currentKey == null) {
      return false;
    }
    if (readFirstKey) {
      readFirstKey=false;
      if (currentKey.compareTo(endKey) <= 0) {
        return true;
      }
      return false;
    }
    while (true) {
      final boolean found=mapfile.next(currentKey,currentValue);
      if (found) {
        if (currentKey.compareTo(endKey) <= 0) {
          if (zoom > 0) {
            final TMSUtils.Tile t=TMSUtils.tileid(currentKey.get(),zoom);
            if (t.tx >= rowStart && t.tx <= rowEnd) {
              return true;
            }
          }
 else {
            return true;
          }
        }
 else {
          return false;
        }
      }
 else {
        if (++curPartition >= reader.getMaxPartitions()) {
          return false;
        }
        if (!reader.canBeCached() && mapfile != null) {
          mapfile.close();
        }
        mapfile=reader.getReader(curPartition);
      }
    }
  }
 catch (  final IOException e) {
    throw new MrsImageException(e);
  }
}

Fixed version (ground truth):
/** 
 * Keeping track of what is being sent back and possibly finish using one MapFile and then opening another MapFile if needed.
 */
@Override public boolean hasNext(){
  try {
    if (currentKey == null) {
      return false;
    }
    if (readFirstKey) {
      readFirstKey=false;
      if (currentKey.compareTo(endKey) <= 0) {
        return true;
      }
      return false;
    }
    while (true) {
      final boolean found=mapfile.next(currentKey,currentValue);
      if (found) {
        if (currentKey.compareTo(endKey) <= 0) {
          if (zoom > 0) {
            final TMSUtils.Tile t=TMSUtils.tileid(currentKey.get(),zoom);
            if (t.tx >= rowStart && t.tx <= rowEnd) {
              return true;
            }
          }
 else {
            return true;
          }
        }
 else {
          return false;
        }
      }
 else {
        if (++curPartitionIndex >= reader.getMaxPartitions()) {
          return false;
        }
        if (!reader.canBeCached() && mapfile != null) {
          mapfile.close();
        }
        mapfile=reader.getReader(curPartitionIndex);
      }
    }
  }
 catch (  final IOException e) {
    throw new MrsImageException(e);
  }
}
Program: 94475
Project: 94475
Buggy source:
@Test @Category(UnitTest.class) public void testGetRasterPngLargerThanTileSize() throws Exception {
  testIslandsElevationFor("String_Node_Str",MrGeoConstants.MRGEO_MRS_TILESIZE_DEFAULT,MrGeoConstants.MRGEO_MRS_TILESIZE_DEFAULT,ISLANDS_ELEVATION_V2_IN_BOUNDS_SINGLE_TILE,islandsElevation_unqualified,getDefaultColorScale(),"String_Node_Str","String_Node_Str",ImageUtils.createImageReader("String_Node_Str"));
}

Fixed version (ground truth):
@Test @Category(UnitTest.class) public void testGetRasterPngLargerThanTileSize() throws Exception {
  testIslandsElevationFor("String_Node_Str","String_Node_Str","String_Node_Str",ISLANDS_ELEVATION_V2_IN_BOUNDS_SINGLE_TILE,islandsElevation_unqualified,getDefaultColorScale(),"String_Node_Str","String_Node_Str",ImageUtils.createImageReader("String_Node_Str"));
}
Program: 94476
Project: 94476
Buggy source:
public void paintGeometry(Geometry g){
  final Bounds featureBounds=g.getBounds();
  if (inputBounds == null) {
    inputBounds=featureBounds;
  }
 else {
    inputBounds.expand(featureBounds);
  }
  if (valueColumn == null || aggregationType == AggregationType.MASK) {
    rasterPainter.paint(g);
  }
 else {
    final String sv=g.getAttribute(valueColumn);
    if (sv != null) {
      final double v=Double.parseDouble(sv);
      composite.setWeight(v);
      rasterPainter.paint(g);
    }
 else {
      log.info("String_Node_Str" + valueColumn);
    }
  }
}

Fixed version (ground truth):
public void paintGeometry(Geometry g){
  final Bounds featureBounds=g.getBounds();
  if (inputBounds == null) {
    inputBounds=featureBounds;
  }
 else {
    inputBounds.expand(featureBounds);
  }
  if (valueColumn == null || aggregationType == AggregationType.MASK) {
    rasterPainter.paint(g);
  }
 else {
    final String sv=g.getAttribute(valueColumn);
    if (sv != null) {
      final double v=Double.parseDouble(sv);
      ((WeightedComposite)composite).setWeight(v);
      rasterPainter.paint(g);
    }
 else {
      log.info("String_Node_Str" + valueColumn);
    }
  }
}