nus-yam/ex-repair huggingface dataset:
Program: 97817
Project: 97817
Buggy source:
/** 
 * Displaye replace material.
 */
public void replace(){
  if (snipeData.owner().isPrintout()) {
    snipeData.sendMessage(ChatColor.AQUA + "String_Node_Str" + ChatColor.RED+ snipeData.getReplaceId()+ ChatColor.GRAY+ "String_Node_Str"+ Material.getMaterial(snipeData.getReplaceId()).toString()+ "String_Node_Str");
  }
}

Fixed version (ground truth):
/** 
 * Displaye replace material.
 */
@SuppressWarnings("String_Node_Str") public void replace(){
  if (snipeData.owner().isPrintout()) {
    snipeData.sendMessage(ChatColor.AQUA + "String_Node_Str" + ChatColor.RED+ snipeData.getReplaceId()+ ChatColor.GRAY+ "String_Node_Str"+ Material.getMaterial(snipeData.getReplaceId()).toString()+ "String_Node_Str");
  }
}
Program: 97818
Project: 97818
Buggy source:
/** 
 * Display voxel type.
 */
public void voxel(){
  if (snipeData.owner().isPrintout()) {
    snipeData.sendMessage(ChatColor.GOLD + "String_Node_Str" + ChatColor.RED+ snipeData.getVoxelId()+ ChatColor.GRAY+ "String_Node_Str"+ Material.getMaterial(snipeData.getVoxelId()).toString()+ "String_Node_Str");
  }
}

Fixed version (ground truth):
/** 
 * Display voxel type.
 */
@SuppressWarnings("String_Node_Str") public void voxel(){
  if (snipeData.owner().isPrintout()) {
    snipeData.sendMessage(ChatColor.GOLD + "String_Node_Str" + ChatColor.RED+ snipeData.getVoxelId()+ ChatColor.GRAY+ "String_Node_Str"+ Material.getMaterial(snipeData.getVoxelId()).toString()+ "String_Node_Str");
  }
}
Program: 97820
Project: 97820
Buggy source:
/** 
 * @param i
 */
public final void add(final int[] i){
  if (i[1] == -1) {
    if (!col.contains(i)) {
      for (Iterator<int[]> it=col.iterator(); it.hasNext(); ) {
        int[] in=it.next();
        if (in[0] == i[0]) {
          it.remove();
        }
      }
      col.add(i);
    }
  }
 else {
    if (!col.contains(i)) {
      col.add(i);
    }
  }
}

Fixed version (ground truth):
/** 
 * Adds the specified id, data value pair to the VoxelList. A data value of -1 will operate on all data values of that id.
 * @param i
 */
public final void add(final int[] i){
  if (i[1] == -1) {
    if (!col.contains(i)) {
      for (Iterator<int[]> it=col.iterator(); it.hasNext(); ) {
        int[] in=it.next();
        if (in[0] == i[0]) {
          it.remove();
        }
      }
      col.add(i);
    }
  }
 else {
    if (!col.contains(i)) {
      col.add(i);
    }
  }
}
Program: 97821
Project: 97821
Buggy source:
/** 
 * @param i
 * @return
 */
public final boolean contains(final int[] i){
  for (Iterator<int[]> it=col.iterator(); it.hasNext(); ) {
    int[] in=it.next();
    if (in[0] == i[0] && (in[1] == i[1] || in[1] == -1)) {
      return true;
    }
  }
  return false;
}

Fixed version (ground truth):
/** 
 * Checks whether the VoxelList contains the specified id datavalue pair.
 * @param i
 * @return
 */
public final boolean contains(final int[] i){
  for (Iterator<int[]> it=col.iterator(); it.hasNext(); ) {
    int[] in=it.next();
    if (in[0] == i[0] && (in[1] == i[1] || in[1] == -1)) {
      return true;
    }
  }
  return false;
}
Program: 97822
Project: 97822
Buggy source:
/** 
 * @param i
 * @return
 */
public final boolean removeValue(final int[] i){
  if (col.isEmpty()) {
    return false;
  }
 else {
    boolean ret=false;
    if (i[1] == -1) {
      for (Iterator<int[]> it=col.iterator(); it.hasNext(); ) {
        int[] in=it.next();
        if (in[0] == i[0]) {
          it.remove();
          ret=true;
        }
      }
    }
 else {
      ret=col.remove(i);
    }
    return ret;
  }
}

Fixed version (ground truth):
/** 
 * Removes the specified id, data value pair from the VoxelList.
 * @param i
 * @return
 */
public final boolean removeValue(final int[] i){
  if (col.isEmpty()) {
    return false;
  }
 else {
    boolean ret=false;
    if (i[1] == -1) {
      for (Iterator<int[]> it=col.iterator(); it.hasNext(); ) {
        int[] in=it.next();
        if (in[0] == i[0]) {
          it.remove();
          ret=true;
        }
      }
    }
 else {
      ret=col.remove(i);
    }
    return ret;
  }
}
Program: 97823
Project: 97823
Buggy source:
public List<int[]> getList(){
  return col;
}

Fixed version (ground truth):
/** 
 * Returns the current VoxelList
 * @return
 */
public List<int[]> getList(){
  return col;
}
Program: 97824
Project: 97824
Buggy source:
public boolean isEmpty(){
  return col.isEmpty();
}

Fixed version (ground truth):
/** 
 * Checks if the list is empty.
 * @return
 */
public boolean isEmpty(){
  return col.isEmpty();
}
Program: 97825
Project: 97825
Buggy source:
@Override public final void parameters(final String[] args,final SnipeData v){
  if (args[1].equalsIgnoreCase("String_Node_Str")) {
    v.sendMessage(ChatColor.GOLD + "String_Node_Str");
    String _availableBiomes="String_Node_Str";
    for (    final org.bukkit.block.Biome _biome : org.bukkit.block.Biome.values()) {
      if (_availableBiomes.isEmpty()) {
        _availableBiomes=ChatColor.DARK_GREEN + _biome.name();
        continue;
      }
      _availableBiomes+=ChatColor.RED + "String_Node_Str" + ChatColor.DARK_GREEN+ _biome.name();
    }
    v.sendMessage(ChatColor.DARK_BLUE + "String_Node_Str" + _availableBiomes);
  }
 else {
    String biomeName=args[1];
    for (int i=1; i < args.length; i++) {
      biomeName+="String_Node_Str" + args[i];
    }
    for (    final org.bukkit.block.Biome _bio : org.bukkit.block.Biome.values()) {
      if (_bio.name().equalsIgnoreCase(biomeName)) {
        this.selectedBiome=_bio;
        break;
      }
    }
    v.sendMessage(ChatColor.GOLD + "String_Node_Str" + ChatColor.DARK_GREEN+ this.selectedBiome.name());
  }
}

Fixed version (ground truth):
@Override public final void parameters(final String[] args,final SnipeData v){
  if (args[1].equalsIgnoreCase("String_Node_Str")) {
    v.sendMessage(ChatColor.GOLD + "String_Node_Str");
    String _availableBiomes="String_Node_Str";
    for (    final org.bukkit.block.Biome _biome : org.bukkit.block.Biome.values()) {
      if (_availableBiomes.isEmpty()) {
        _availableBiomes=ChatColor.DARK_GREEN + _biome.name();
        continue;
      }
      _availableBiomes+=ChatColor.RED + "String_Node_Str" + ChatColor.DARK_GREEN+ _biome.name();
    }
    v.sendMessage(ChatColor.DARK_BLUE + "String_Node_Str" + _availableBiomes);
  }
 else {
    String biomeName=args[1];
    for (int i=2; i < args.length; i++) {
      biomeName+="String_Node_Str" + args[i];
    }
    for (    final org.bukkit.block.Biome _bio : org.bukkit.block.Biome.values()) {
      if (_bio.name().equalsIgnoreCase(biomeName)) {
        this.selectedBiome=_bio;
        break;
      }
    }
    v.sendMessage(ChatColor.GOLD + "String_Node_Str" + ChatColor.DARK_GREEN+ this.selectedBiome.name());
  }
}
Program: 97826
Project: 97826
Buggy source:
private void overlay(final SnipeData v){
  final int _brushSize=v.getBrushSize();
  final double _bPow=Math.pow(_brushSize + 0.5,2);
  final int[][] _memory=new int[_brushSize * 2 + 1][_brushSize * 2 + 1];
  for (int _z=_brushSize; _z >= -_brushSize; _z--) {
    for (int _x=_brushSize; _x >= -_brushSize; _x--) {
      for (int _y=this.getBlockPositionY(); _y > 0; _y--) {
        if (_memory[_x + _brushSize][_z + _brushSize] != 1) {
          if ((Math.pow(_x,2) + Math.pow(_z,2)) <= _bPow) {
            final int _check=this.getBlockIdAt(this.getBlockPositionX() + _x,_y + 1,this.getBlockPositionZ() + _z);
            if (_check == 0 || _check == 8 || _check == 9) {
              if (!this.allBlocks) {
switch (this.getBlockIdAt(this.getBlockPositionX() + _x,_y,this.getBlockPositionZ() + _z)) {
case 1:
case 2:
case 3:
case 12:
case 13:
case 24:
case 48:
case 82:
case 49:
case 78:
                  for (int _d=0; (_d < this.depth); _d++) {
                    if (this.clampY(this.getBlockPositionX() + _x,_y - _d,this.getBlockPositionZ() + _z).getTypeId() != 0) {
                      this.current.perform(this.clampY(this.getBlockPositionX() + _x,_y - _d,this.getBlockPositionZ() + _z));
                      _memory[_x + _brushSize][_z + _brushSize]=1;
                    }
                  }
                break;
default :
              break;
          }
        }
 else {
          for (int _d=0; (_d < this.depth); _d++) {
            if (this.clampY(this.getBlockPositionX() + _x,_y - _d,this.getBlockPositionZ() + _z).getTypeId() != 0) {
              this.current.perform(this.clampY(this.getBlockPositionX() + _x,_y - _d,this.getBlockPositionZ() + _z));
              _memory[_x + _brushSize][_z + _brushSize]=1;
            }
          }
        }
      }
    }
  }
}
}
}
v.storeUndo(this.current.getUndo());
}

Fixed version (ground truth):
private void overlay(final SnipeData v){
  final int _brushSize=v.getBrushSize();
  final double _bPow=Math.pow(_brushSize + 0.5,2);
  for (int _z=_brushSize; _z >= -_brushSize; _z--) {
    for (int _x=_brushSize; _x >= -_brushSize; _x--) {
      final int materialId=this.getBlockIdAt(this.getBlockPositionX() + _x,this.getBlockPositionY() + 1,this.getBlockPositionZ() + _z);
      if (isColumnValid(materialId)) {
        if ((Math.pow(_x,2) + Math.pow(_z,2)) <= _bPow) {
          for (int _y=this.getBlockPositionY(); _y > 0; _y--) {
            final int layerBlockId=this.getBlockIdAt(this.getBlockPositionX() + _x,_y,this.getBlockPositionZ() + _z);
            if (isColumnValid(layerBlockId)) {
              for (int currentDepth=_y; _y - currentDepth < depth; currentDepth--) {
                final int currentBlockId=this.getBlockIdAt(this.getBlockPositionX() + _x,currentDepth,this.getBlockPositionZ() + _z);
                if (isOverrideableMaterial(currentBlockId)) {
                  this.current.perform(this.clampY(this.getBlockPositionX() + _x,currentDepth,this.getBlockPositionZ() + _z));
                }
              }
              break;
            }
          }
        }
      }
    }
  }
  v.storeUndo(this.current.getUndo());
}
Program: 97829
Project: 97829
Buggy source:
@Override protected final void powder(final SnipeData v){
  if (jockeyType == JockeyType.INVERSE_PLAYER_ONLY || jockeyType == JockeyType.INVERSE_ALL_ENTITIES) {
    v.owner().getPlayer().eject();
    v.owner().getPlayer().sendMessage(ChatColor.GOLD + "String_Node_Str");
  }
 else {
    if (jockeydEntity != null) {
      jockeydEntity.eject();
      jockeydEntity=null;
      v.owner().getPlayer().sendMessage(ChatColor.GOLD + "String_Node_Str");
    }
  }
}

Fixed version (ground truth):
@Override protected final void powder(final SnipeData v){
  if (jockeyType == JockeyType.INVERSE_PLAYER_ONLY || jockeyType == JockeyType.INVERSE_ALL_ENTITIES) {
    v.owner().getPlayer().eject();
    v.owner().getPlayer().sendMessage(ChatColor.GOLD + "String_Node_Str");
  }
 else {
    if (jockeyedEntity != null) {
      jockeyedEntity.eject();
      jockeyedEntity=null;
      v.owner().getPlayer().sendMessage(ChatColor.GOLD + "String_Node_Str");
    }
  }
}
Program: 97830
Project: 97830
Buggy source:
@Override protected final void arrow(final SnipeData v){
  if (originCoords == null) {
    originCoords=new Vector();
  }
  originCoords.setX(this.getTargetBlock().getX() + .5 * this.getTargetBlock().getX() / Math.abs(this.getTargetBlock().getX()));
  originCoords.setY(this.getTargetBlock().getY() + .5);
  originCoords.setZ(this.getTargetBlock().getZ() + .5 * this.getTargetBlock().getZ() / Math.abs(this.getTargetBlock().getZ()));
  v.owner().getPlayer().sendMessage(ChatColor.DARK_PURPLE + "String_Node_Str");
}

Fixed version (ground truth):
@Override protected final void arrow(final SnipeData v){
  this.originCoords=this.getTargetBlock().getLocation().toVector();
  this.targetWorld=this.getTargetBlock().getWorld();
  v.owner().getPlayer().sendMessage(ChatColor.DARK_PURPLE + "String_Node_Str");
}
Program: 97831
Project: 97831
Buggy source:
private final void linePowder(final SnipeData v){
  Vector _previousCoords=new Vector();
  Vector _currentCoords=null;
  final Vector _slope=targetCoords.subtract(originCoords).normalize();
  for (int _t=0; _t <= _slope.length(); _t++) {
    _currentCoords=_slope.multiply(_t).add(originCoords);
    if (_currentCoords != _previousCoords) {
      this.current.perform(this.clampY((int)Math.round(_currentCoords.getX()),(int)Math.round(_currentCoords.getY()),(int)Math.round(_currentCoords.getZ())));
    }
    _previousCoords=_currentCoords;
  }
  v.storeUndo(this.current.getUndo());
}

Fixed version (ground truth):
private void linePowder(final SnipeData v){
  final Vector _originClone=this.originCoords.clone().add(LineBrush.HALF_BLOCK_OFFSET);
  final Vector _targetClone=this.targetCoords.clone().add(LineBrush.HALF_BLOCK_OFFSET);
  final Vector _direction=_targetClone.clone().subtract(_originClone);
  final double _length=this.targetCoords.distance(this.originCoords);
  if (_length == 0) {
    this.current.perform(this.targetCoords.toLocation(this.targetWorld).getBlock());
  }
 else {
    for (final BlockIterator _iterator=new BlockIterator(this.targetWorld,_originClone,_direction,0,NumberConversions.round(_length)); _iterator.hasNext(); ) {
      final Block _block=_iterator.next();
      this.current.perform(_block);
    }
  }
  v.storeUndo(this.current.getUndo());
}
Program: 97832
Project: 97832
Buggy source:
@Override protected final void powder(final SnipeData v){
  if (originCoords == null) {
    v.owner().getPlayer().sendMessage(ChatColor.RED + "String_Node_Str");
    return;
  }
 else {
    targetCoords.setX(this.getTargetBlock().getX() + .5 * this.getTargetBlock().getX() / Math.abs(this.getTargetBlock().getX()));
    targetCoords.setY(this.getTargetBlock().getY() + .5);
    targetCoords.setZ(this.getTargetBlock().getZ() + .5 * this.getTargetBlock().getZ() / Math.abs(this.getTargetBlock().getZ()));
    this.linePowder(v);
  }
}

Fixed version (ground truth):
@Override protected final void powder(final SnipeData v){
  if (this.originCoords == null || !this.getTargetBlock().getWorld().equals(this.targetWorld)) {
    v.owner().getPlayer().sendMessage(ChatColor.RED + "String_Node_Str");
    return;
  }
 else {
    this.targetCoords=this.getTargetBlock().getLocation().toVector();
    this.linePowder(v);
  }
}
Program: 97833
Project: 97833
Buggy source:
@Override public final void parameters(final String[] par,final SnipeData v){
  for (int _i=0; _i < par.length; _i++) {
    final String _param=par[_i];
    try {
      if (_param.equalsIgnoreCase("String_Node_Str")) {
        v.sendMessage(ChatColor.BLUE + "String_Node_Str");
        v.sendMessage(ChatColor.GREEN + "String_Node_Str" + ChatColor.BLUE+ "String_Node_Str");
      }
 else       if (_param.equalsIgnoreCase("String_Node_Str")) {
        if ((_i + 1) >= par.length) {
          v.sendMessage(ChatColor.RED + "String_Node_Str");
          continue;
        }
        int _tmp=Integer.parseInt(par[++_i]);
        if (_tmp < WATER_LEVEL_MIN) {
          v.sendMessage(ChatColor.RED + "String_Node_Str");
          continue;
        }
        this.waterLevel=_tmp;
        v.sendMessage(ChatColor.BLUE + "String_Node_Str" + ChatColor.GREEN+ (waterLevel + 1));
      }
    }
 catch (    Exception _e) {
      v.sendMessage(ChatColor.RED + String.format("String_Node_Str",_param));
      _e.printStackTrace();
    }
  }
}

Fixed version (ground truth):
@Override public final void parameters(final String[] par,final SnipeData v){
  for (int _i=0; _i < par.length; _i++) {
    final String _param=par[_i];
    try {
      if (_param.equalsIgnoreCase("String_Node_Str")) {
        v.sendMessage(ChatColor.BLUE + "String_Node_Str");
        v.sendMessage(ChatColor.GREEN + "String_Node_Str" + ChatColor.BLUE+ "String_Node_Str");
      }
 else       if (_param.equalsIgnoreCase("String_Node_Str")) {
        if ((_i + 1) >= par.length) {
          v.sendMessage(ChatColor.RED + "String_Node_Str");
          continue;
        }
        int _tmp=Integer.parseInt(par[++_i]);
        if (_tmp <= WATER_LEVEL_MIN) {
          v.sendMessage(ChatColor.RED + "String_Node_Str");
          continue;
        }
        this.waterLevel=_tmp - 1;
        v.sendMessage(ChatColor.BLUE + "String_Node_Str" + ChatColor.GREEN+ (waterLevel + 1));
      }
    }
 catch (    Exception _e) {
      v.sendMessage(ChatColor.RED + String.format("String_Node_Str",_param));
      _e.printStackTrace();
    }
  }
}
Program: 97836
Project: 97836
Buggy source:
protected void spawn(vData v){
  for (int x=0; x < v.brushSize; x++) {
    try {
      w.spawnCreature(lb.getLocation(),ct);
    }
 catch (    ClassCastException ex) {
    }
  }
}

Fixed version (ground truth):
protected void spawn(vData v){
  for (int x=0; x < v.brushSize; x++) {
    try {
      Class<? extends Entity> ent=ct.getEntityClass();
      w.spawn(lb.getLocation(),ent);
    }
 catch (    ClassCastException ex) {
      v.sendMessage(ChatColor.RED + "String_Node_Str");
    }
  }
}
Program: 97837
Project: 97837
Buggy source:
@Override public boolean onCommand(CommandSender sender,Command command,String commandLabel,String[] args){
  if (sender instanceof Player) {
    Player p=(Player)sender;
    String comm=command.getName();
    if (args == null) {
      if (!VoxelSniperListener.onCommand(p,new String[0],comm)) {
        if (p.isOp()) {
          p.sendMessage(ChatColor.RED + "String_Node_Str");
          return true;
        }
 else {
          return false;
        }
      }
 else {
        return true;
      }
    }
 else {
      if (!VoxelSniperListener.onCommand(p,args,comm)) {
        if (p.isOp()) {
          p.sendMessage(ChatColor.RED + "String_Node_Str");
          return true;
        }
 else {
          return false;
        }
      }
 else {
        return true;
      }
    }
  }
  System.out.println("String_Node_Str");
  return false;
}

Fixed version (ground truth):
@Override public boolean onCommand(CommandSender sender,Command command,String commandLabel,String[] args){
  String comm=command.getName();
  String[] myArgs=args;
  if (myArgs == null) {
    myArgs=new String[0];
  }
  if (sender instanceof Player) {
    Player p=(Player)sender;
    if (!VoxelSniperListener.onCommand(p,myArgs,comm)) {
      if (p.isOp()) {
        p.sendMessage(ChatColor.RED + "String_Node_Str");
        return true;
      }
 else {
        return false;
      }
    }
 else {
      return true;
    }
  }
 else {
    CommandSender p=sender;
    if (!VoxelSniperListener.onConsoleSafeCommand(p,myArgs,comm)) {
      if (p.isOp()) {
        p.sendMessage(ChatColor.RED + "String_Node_Str");
        return true;
      }
 else {
        return false;
      }
    }
 else {
      return true;
    }
  }
}
Program: 97839
Project: 97839
Buggy source:
@Override public String fetchColumnValueAsString(TypedRow row){
  return null;
}

Fixed version (ground truth):
@Override public String fetchColumnValueAsString(TypedRow row){
  TypedColumn typedCol=row.getColumn(getColumnName());
  Object value=typedCol.getValue();
  return convertTypeToString(value);
}
Program: 97840
Project: 97840
Buggy source:
@SuppressWarnings("String_Node_Str") @Override public Class getClassType(){
  return null;
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") @Override public Class getClassType(){
  return classForName(this.itemType);
}
Program: 97841
Project: 97841
Buggy source:
@SuppressWarnings("String_Node_Str") public void setup(DboTableMeta t,String colPrefix,Class collectionType,Class itemType,Class valueType){
  super.setup(t,colPrefix,false);
  this.collectionType=collectionType.getName();
  Class newType=translateType(itemType);
  this.itemType=newType.getName();
  if (valueType != null) {
    Class newValType=translateType(valueType);
    this.valueType=newValType.getName();
  }
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") public void setup(DboTableMeta t,String colPrefix,Class collectionType,Class itemType,Class valueType,boolean isIndexed){
  super.setup(t,colPrefix,isIndexed);
  this.collectionType=collectionType.getName();
  Class newType=translateType(itemType);
  this.itemType=newType.getName();
  if (valueType != null) {
    Class newValType=translateType(valueType);
    this.valueType=newValType.getName();
  }
}
Program: 97842
Project: 97842
Buggy source:
@Override public String getIndexTableName(){
  return null;
}

Fixed version (ground truth):
@Override public String getIndexTableName(){
  return getStorageType().getIndexTableName();
}
Program: 97843
Project: 97843
Buggy source:
@SuppressWarnings("String_Node_Str") private void translateToColumnMap(OWNER entity,RowToPersist row){
  Map values=(Map)ReflectionUtil.fetchFieldValue(entity,field);
  if (values == null)   values=new HashMap();
  Map toBeAdded=values;
  Collection<T> toBeRemoved=new ArrayList<T>();
  if (values instanceof SimpleMap) {
    SimpleMap coll=(SimpleMap)values;
    toBeRemoved=coll.getToBeRemoved();
    toBeAdded=coll.getToBeAdded();
  }
  translateToColumnMapImpl(toBeAdded,row,toBeRemoved);
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") private void translateToColumnMap(InfoForIndex<OWNER> info){
  OWNER entity=info.getEntity();
  RowToPersist row=info.getRow();
  Map values=(Map)ReflectionUtil.fetchFieldValue(entity,field);
  if (values == null)   values=new HashMap();
  Map toBeAdded=values;
  Collection<T> toBeRemoved=new ArrayList<T>();
  if (values instanceof SimpleMap) {
    SimpleMap coll=(SimpleMap)values;
    toBeRemoved=coll.getToBeRemoved();
    toBeAdded=coll.getToBeAdded();
  }
  translateToColumnMapImpl(toBeAdded,row,toBeRemoved);
}
Program: 97844
Project: 97844
Buggy source:
@SuppressWarnings({"String_Node_Str"}) private Map translateFromColumnMap(Row row,OWNER entity,NoSqlSession session){
  byte[] bytes=StandardConverters.convertToBytes(columnName);
  Collection<Column> columns=row.columnByPrefix(bytes);
  Map<byte[],byte[]> theCols=new HashMap<byte[],byte[]>();
  for (  Column col : columns) {
    byte[] colNameData=col.getName();
    byte[] value=col.getValue();
    int pkLen=colNameData.length - bytes.length;
    byte[] pk=new byte[pkLen];
    for (int i=bytes.length; i < colNameData.length; i++) {
      pk[i - bytes.length]=colNameData[i];
    }
    theCols.put(pk,value);
  }
  return new SimpleMap(converter,valueConverter,theCols);
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") private Map translateFromColumnMap(Row row,OWNER entity,NoSqlSession session){
  byte[] bytes=StandardConverters.convertToBytes(columnName);
  Collection<Column> columns=row.columnByPrefix(bytes);
  Map<byte[],byte[]> theCols=new HashMap<byte[],byte[]>();
  for (  Column col : columns) {
    byte[] colNameData=col.getName();
    byte[] value=col.getValue();
    int pkLen=colNameData.length - bytes.length;
    byte[] pk=new byte[pkLen];
    for (int i=bytes.length; i < colNameData.length; i++) {
      pk[i - bytes.length]=colNameData[i];
    }
    theCols.put(pk,value);
  }
  return new SimpleMap(converter,valueConverter,theCols);
}
Program: 97845
Project: 97845
Buggy source:
@Override public void translateToColumn(InfoForIndex<OWNER> info){
  OWNER entity=info.getEntity();
  RowToPersist row=info.getRow();
  if (field.getType().equals(Map.class))   translateToColumnMap(entity,row);
 else   translateToColumnList(entity,row);
}

Fixed version (ground truth):
@Override public void translateToColumn(InfoForIndex<OWNER> info){
  if (field.getType().equals(Map.class))   translateToColumnMap(info);
 else   translateToColumnList(info);
}
Program: 97846
Project: 97846
Buggy source:
private void translateToColumnImpl(Collection<T> toBeAdded,RowToPersist row,Collection<T> toBeRemoved){
  for (  T p : toBeRemoved) {
    byte[] name=formTheName(p);
    row.addEntityToRemove(name);
  }
  for (  T val : toBeAdded) {
    byte[] name=formTheName(val);
    Column c=new Column();
    c.setName(name);
    row.getColumns().add(c);
  }
}

Fixed version (ground truth):
private void translateToColumnImpl(Collection<T> toBeAdded,InfoForIndex<OWNER> info,Collection<T> toBeRemoved){
  OWNER entity=info.getEntity();
  RowToPersist row=info.getRow();
  for (  T p : toBeRemoved) {
    byte[] name=formTheName(p);
    row.addEntityToRemove(name);
  }
  Object value=ReflectionUtil.fetchFieldValue(entity,field);
  StorageTypeEnum storageType=metaDbo.getStorageType();
  for (  T val : toBeAdded) {
    byte[] name=formTheName(val);
    Column c=new Column();
    c.setName(name);
    row.getColumns().add(c);
    byte[] byteVal=converter.convertToNoSql(val);
    addIndexInfo(info,value,byteVal,storageType);
    removeIndexInfo(info,value,byteVal,storageType);
  }
}
Program: 97847
Project: 97847
Buggy source:
@SuppressWarnings("String_Node_Str") private void translateToColumnList(OWNER entity,RowToPersist row){
  Collection<T> values=(Collection<T>)ReflectionUtil.fetchFieldValue(entity,field);
  if (values == null)   values=new ArrayList<T>();
  Collection<T> toBeAdded=values;
  Collection<T> toBeRemoved=new ArrayList<T>();
  if (values instanceof SimpleAbstractCollection) {
    SimpleAbstractCollection<T> coll=(SimpleAbstractCollection<T>)values;
    toBeRemoved=coll.getToBeRemoved();
    toBeAdded=coll.getToBeAdded();
  }
  translateToColumnImpl(toBeAdded,row,toBeRemoved);
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") private void translateToColumnList(InfoForIndex<OWNER> info){
  OWNER entity=info.getEntity();
  Collection<T> values=(Collection<T>)ReflectionUtil.fetchFieldValue(entity,field);
  if (values == null)   values=new ArrayList<T>();
  Collection<T> toBeAdded=values;
  Collection<T> toBeRemoved=new ArrayList<T>();
  if (values instanceof SimpleAbstractCollection) {
    SimpleAbstractCollection<T> coll=(SimpleAbstractCollection<T>)values;
    toBeRemoved=coll.getToBeRemoved();
    toBeAdded=coll.getToBeAdded();
  }
  translateToColumnImpl(toBeAdded,info,toBeRemoved);
}
Program: 97848
Project: 97848
Buggy source:
@Override protected Object unwrapIfNeeded(Object value){
  throw new UnsupportedOperationException();
}

Fixed version (ground truth):
@Override protected Object unwrapIfNeeded(Object value){
  return value;
}
Program: 97849
Project: 97849
Buggy source:
public void setup(DboTableMeta t,Field field,String colName,Converter converter,Converter valConverter,Class<?> type,Class<?> valueType){
  super.setup(field,colName);
  metaDbo.setup(t,colName,field.getType(),type,valueType);
  this.converter=converter;
  this.valueConverter=valConverter;
}

Fixed version (ground truth):
public void setup(DboTableMeta t,Field field,String colName,EmbedInfo embedInfo,boolean isIndexed){
  super.setup(field,colName);
  metaDbo.setup(t,colName,field.getType(),embedInfo.getType(),embedInfo.getValueType(),isIndexed);
  this.converter=embedInfo.getConverter();
  this.valueConverter=embedInfo.getValConverter();
}
Program: 97850
Project: 97850
Buggy source:
@SuppressWarnings("String_Node_Str") public MetaField processEmbedded(DboTableMeta t,Field field){
  NoSqlEmbedded embedded=field.getAnnotation(NoSqlEmbedded.class);
  Class<?> type=field.getType();
  Class<?> valType=null;
  if (type.equals(List.class) || type.equals(Set.class)) {
    ParameterizedType genType=(ParameterizedType)field.getGenericType();
    type=(Class<?>)genType.getActualTypeArguments()[0];
  }
 else   if (type.equals(Map.class)) {
    ParameterizedType genType=(ParameterizedType)field.getGenericType();
    type=(Class<?>)genType.getActualTypeArguments()[0];
    valType=(Class<?>)genType.getActualTypeArguments()[1];
  }
  String colNameOrig=embedded.columnNamePrefix();
  String colName=field.getName();
  if (!"String_Node_Str".equals(colNameOrig))   colName=colNameOrig;
  MetaField metaField;
  if (type.isAnnotationPresent(NoSqlEmbeddable.class)) {
    MetaAbstractClass<?> fkMeta=metaInfo.findOrCreate(type);
    MetaEmbeddedEntity temp=metaEmbeddedProvider.get();
    temp.setup(t,field,colName,fkMeta);
    metaField=temp;
  }
 else {
    Converter converter=lookupConverter(field,type);
    Converter valConverter=null;
    if (valType != null)     valConverter=lookupConverter(field,valType);
    MetaEmbeddedSimple meta=metaEmbeddedSimpleProvider.get();
    meta.setup(t,field,colName,converter,valConverter,type,valType);
    metaField=meta;
  }
  return metaField;
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") public MetaField processEmbedded(DboTableMeta t,Field field){
  NoSqlEmbedded embedded=field.getAnnotation(NoSqlEmbedded.class);
  Class<?> type=field.getType();
  Class<?> valType=null;
  if (type.equals(List.class) || type.equals(Set.class)) {
    ParameterizedType genType=(ParameterizedType)field.getGenericType();
    type=(Class<?>)genType.getActualTypeArguments()[0];
  }
 else   if (type.equals(Map.class)) {
    ParameterizedType genType=(ParameterizedType)field.getGenericType();
    type=(Class<?>)genType.getActualTypeArguments()[0];
    valType=(Class<?>)genType.getActualTypeArguments()[1];
  }
  boolean isIndexed=false;
  if (field.isAnnotationPresent(NoSqlIndexed.class))   isIndexed=true;
  String colNameOrig=embedded.columnNamePrefix();
  String colName=field.getName();
  if (!"String_Node_Str".equals(colNameOrig))   colName=colNameOrig;
  MetaField metaField;
  if (type.isAnnotationPresent(NoSqlEmbeddable.class)) {
    MetaAbstractClass<?> fkMeta=metaInfo.findOrCreate(type);
    MetaEmbeddedEntity temp=metaEmbeddedProvider.get();
    temp.setup(t,field,colName,fkMeta);
    metaField=temp;
  }
 else {
    Converter converter=lookupConverter(field,type);
    Converter valConverter=null;
    if (valType != null)     valConverter=lookupConverter(field,valType);
    MetaEmbeddedSimple meta=metaEmbeddedSimpleProvider.get();
    EmbedInfo embedInfo=new EmbedInfo();
    embedInfo.setConverter(converter);
    embedInfo.setType(type);
    embedInfo.setValConverter(valConverter);
    embedInfo.setValueType(valType);
    meta.setup(t,field,colName,embedInfo,isIndexed);
    metaField=meta;
  }
  return metaField;
}
Program: 97851
Project: 97851
Buggy source:
@Override public void setup(DboTableMeta owner2,String colName,boolean indexed){
  if (indexed == true)   throw new UnsupportedOperationException("String_Node_Str");
  super.setup(owner2,colName,indexed);
}

Fixed version (ground truth):
@Override public void setup(DboTableMeta owner2,String colName,boolean indexed){
  if (indexed)   throw new UnsupportedOperationException("String_Node_Str");
  super.setup(owner2,colName,indexed);
}
Program: 97852
Project: 97852
Buggy source:
public MetaTTLField processTTL(DboTableMeta t,Field field){
  Class type=field.getType();
  if (Integer.class.equals(type) || (int.class.equals(type))) {
    MetaTTLField rc=ttlMetaProvider.get();
    rc.setup(t,field,field.getName(),field.isAnnotationPresent(NoSqlIndexed.class));
    return rc;
  }
 else   throw new IllegalArgumentException("String_Node_Str");
}

Fixed version (ground truth):
public MetaTTLField processTTL(DboTableMeta t,Field field){
  Class type=field.getType();
  if (Integer.class.equals(type)) {
    MetaTTLField rc=ttlMetaProvider.get();
    rc.setup(t,field,field.getName(),field.isAnnotationPresent(NoSqlIndexed.class));
    return rc;
  }
 else   if (int.class.equals(type)) {
    MetaTTLField rc=ttlMetaProvider.get();
    rc.setup(t,field,field.getName(),field.isAnnotationPresent(NoSqlIndexed.class));
    return rc;
  }
 else   throw new IllegalArgumentException("String_Node_Str");
}
Program: 97853
Project: 97853
Buggy source:
public boolean isExpired(){
  if (expire > 0 && System.currentTimeMillis() >= expire)   return true;
 else   return false;
}

Fixed version (ground truth):
public boolean isExpired(){
  return (expire > 0 && System.currentTimeMillis() >= expire);
}
Program: 97854
Project: 97854
Buggy source:
private <T>void scanSingle(MetaClassSingle<T> classMeta,DboTableMeta metaDbo){
  if (alreadyScanned.contains(classMeta.getMetaClass()))   return;
  Class<? extends T> proxyClass=createTheProxy(classMeta.getMetaClass());
  classMeta.setProxyClass(proxyClass);
  scanFields(classMeta,metaDbo);
  alreadyScanned.add(classMeta.getMetaClass());
}

Fixed version (ground truth):
private <T>void scanSingle(MetaClassSingle<T> classMeta,DboTableMeta metaDbo){
  if (classMeta.getProxyClass() != null)   return;
  Class<? extends T> proxyClass=createTheProxy(classMeta.getMetaClass());
  classMeta.setProxyClass(proxyClass);
  scanFields(classMeta,metaDbo);
}
Program: 97855
Project: 97855
Buggy source:
public CursorColumnSliceMDB(ColumnSliceInfo sliceInfo,BatchListener bListener,Integer batchSize,DB keyspace){
  this.batchListener=bListener;
  this.batchSize=null;
  this.tableName=sliceInfo.getColFamily();
  this.db=keyspace;
  this.from=sliceInfo.getFrom();
  this.to=sliceInfo.getTo();
  this.rowKey=sliceInfo.getRowKey();
  this.columnNameType=sliceInfo.getColumnNameType();
  beforeFirst();
}

Fixed version (ground truth):
public CursorColumnSliceMDB(ColumnSliceInfo sliceInfo,BatchListener bListener,Integer batchSize,DBCollection dbCollection2){
  this.batchListener=bListener;
  this.batchSize=null;
  dbCollection=dbCollection2;
  this.from=sliceInfo.getFrom();
  this.to=sliceInfo.getTo();
  this.rowKey=sliceInfo.getRowKey();
  this.columnNameType=sliceInfo.getColumnNameType();
  beforeFirst();
}
Program: 97856
Project: 97856
Buggy source:
private void fetchMoreResultsImpl(){
  if (subList != null) {
    if (pointer < subList.size() - 1)     return;
 else     if (batchSize == null)     return;
 else     if (subList.size() < batchSize) {
      return;
    }
  }
  System.out.println("String_Node_Str" + pointer);
  pointer=-1;
  if (batchListener != null)   batchListener.beforeFetchingNextBatch();
  DBCollection dbCollection=null;
  if (db != null && db.collectionExists(tableName.getColumnFamily())) {
    dbCollection=db.getCollection(tableName.getColumnFamily());
  }
 else   return;
  DBObject row=dbCollection.findOne(rowKey);
  if (row == null) {
    return;
  }
 else {
    Set<String> fieldSet=row.keySet();
    if (BigInteger.class.equals(columnNameType)) {
      intColumnSlice(fieldSet,row);
    }
 else     if (BigDecimal.class.equals(columnNameType)) {
      decimalColumnSlice(fieldSet,row);
    }
 else     if (String.class.equals(columnNameType)) {
      stringColumSlice(fieldSet,row);
    }
 else     throw new UnsupportedOperationException("String_Node_Str" + columnNameType.getName() + "String_Node_Str");
  }
  if (subList == null) {
    subList=new ArrayList<DBObject>();
  }
  if (batchListener != null)   batchListener.afterFetchingNextBatch(subList.size());
}

Fixed version (ground truth):
private void fetchMoreResultsImpl(){
  if (subList != null) {
    if (pointer < subList.size() - 1)     return;
 else     if (batchSize == null)     return;
 else     if (subList.size() < batchSize) {
      return;
    }
  }
  pointer=-1;
  if (batchListener != null)   batchListener.beforeFetchingNextBatch();
  DBObject row=dbCollection.findOne(rowKey);
  if (row == null) {
    return;
  }
 else {
    Set<String> fieldSet=row.keySet();
    if (BigInteger.class.equals(columnNameType)) {
      intColumnSlice(fieldSet,row);
    }
 else     if (BigDecimal.class.equals(columnNameType)) {
      decimalColumnSlice(fieldSet,row);
    }
 else     if (String.class.equals(columnNameType)) {
      stringColumSlice(fieldSet,row);
    }
 else     throw new UnsupportedOperationException("String_Node_Str" + columnNameType.getName() + "String_Node_Str");
  }
  if (subList == null) {
    subList=new ArrayList<DBObject>();
  }
  if (batchListener != null)   batchListener.afterFetchingNextBatch(subList.size());
}
Program: 97857
Project: 97857
Buggy source:
private void decimalColumnSlice(Set<String> fieldSet,DBObject row){
  subList=new ArrayList<DBObject>();
  Map<BigDecimal,Object> map=new TreeMap<BigDecimal,Object>();
  BigDecimal fromField=StandardConverters.convertFromBytes(BigDecimal.class,from);
  BigDecimal toField=StandardConverters.convertFromBytes(BigDecimal.class,to);
  for (  String field : fieldSet) {
    if (!field.equalsIgnoreCase("String_Node_Str")) {
      BigDecimal name=StandardConverters.convertFromBytes(BigDecimal.class,StandardConverters.convertFromString(byte[].class,field));
      if (name.compareTo(fromField) > 0 && name.compareTo(toField) < 0) {
        Object value=row.get(field);
        map.put(name,value);
      }
    }
  }
  for (  BigDecimal field : map.keySet()) {
    String newField=StandardConverters.convertToString(StandardConverters.convertToBytes(field));
    BasicDBObject dbObject=new BasicDBObject(newField,map.get(field));
    subList.add(dbObject);
  }
}

Fixed version (ground truth):
private void decimalColumnSlice(Set<String> fieldSet,DBObject row){
  subList=new ArrayList<DBObject>();
  Map<BigDecimal,Object> map=new TreeMap<BigDecimal,Object>();
  BigDecimal fromField=StandardConverters.convertFromBytes(BigDecimal.class,from);
  BigDecimal toField=StandardConverters.convertFromBytes(BigDecimal.class,to);
  for (  String field : fieldSet) {
    if (!field.equalsIgnoreCase("String_Node_Str")) {
      BigDecimal name=StandardConverters.convertFromBytes(BigDecimal.class,StandardConverters.convertFromString(byte[].class,field));
      if (name.compareTo(fromField) >= 0 && name.compareTo(toField) <= 0) {
        Object value=row.get(field);
        map.put(name,value);
      }
    }
  }
  for (  BigDecimal field : map.keySet()) {
    String newField=StandardConverters.convertToString(StandardConverters.convertToBytes(field));
    BasicDBObject dbObject=new BasicDBObject(newField,map.get(field));
    subList.add(dbObject);
  }
}
Program: 97858
Project: 97858
Buggy source:
private void intColumnSlice(Set<String> fieldSet,DBObject row){
  subList=new ArrayList<DBObject>();
  Map<BigInteger,Object> map=new TreeMap<BigInteger,Object>();
  BigInteger fromField=StandardConverters.convertFromBytes(BigInteger.class,from);
  BigInteger toField=StandardConverters.convertFromBytes(BigInteger.class,to);
  for (  String field : fieldSet) {
    if (!field.equalsIgnoreCase("String_Node_Str")) {
      BigInteger name=StandardConverters.convertFromBytes(BigInteger.class,StandardConverters.convertFromString(byte[].class,field));
      if (name.compareTo(fromField) > 0 && name.compareTo(toField) < 0) {
        Object value=row.get(field);
        map.put(name,value);
      }
    }
  }
  for (  BigInteger field : map.keySet()) {
    String newField=StandardConverters.convertToString(StandardConverters.convertToBytes(field));
    BasicDBObject dbObject=new BasicDBObject(newField,map.get(field));
    subList.add(dbObject);
  }
}

Fixed version (ground truth):
private void intColumnSlice(Set<String> fieldSet,DBObject row){
  subList=new ArrayList<DBObject>();
  Map<BigInteger,Object> map=new TreeMap<BigInteger,Object>();
  BigInteger fromField=StandardConverters.convertFromBytes(BigInteger.class,from);
  BigInteger toField=StandardConverters.convertFromBytes(BigInteger.class,to);
  for (  String field : fieldSet) {
    if (!field.equalsIgnoreCase("String_Node_Str")) {
      BigInteger name=StandardConverters.convertFromBytes(BigInteger.class,StandardConverters.convertFromString(byte[].class,field));
      if (name.compareTo(fromField) >= 0 && name.compareTo(toField) <= 0) {
        Object value=row.get(field);
        map.put(name,value);
      }
    }
  }
  for (  BigInteger field : map.keySet()) {
    String newField=StandardConverters.convertToString(StandardConverters.convertToBytes(field));
    BasicDBObject dbObject=new BasicDBObject(newField,map.get(field));
    subList.add(dbObject);
  }
}
Program: 97859
Project: 97859
Buggy source:
private void stringColumSlice(Set<String> fieldSet,DBObject row){
  subList=new ArrayList<DBObject>();
  Map<String,Object> map=new TreeMap<String,Object>();
  String fromField=StandardConverters.convertFromBytes(String.class,from);
  String toField=StandardConverters.convertFromBytes(String.class,to);
  for (  String field : fieldSet) {
    if (!field.equalsIgnoreCase("String_Node_Str")) {
      if (field.compareTo(fromField) > 0 && field.compareTo(toField) < 0) {
        Object value=row.get(field);
        map.put(field,value);
      }
    }
  }
  for (  String field : map.keySet()) {
    BasicDBObject dbObject=new BasicDBObject(field,map.get(field));
    subList.add(dbObject);
  }
}

Fixed version (ground truth):
private void stringColumSlice(Set<String> fieldSet,DBObject row){
  subList=new ArrayList<DBObject>();
  Map<String,Object> map=new TreeMap<String,Object>();
  String fromField=StandardConverters.convertFromBytes(String.class,from);
  String toField=StandardConverters.convertFromBytes(String.class,to);
  for (  String field : fieldSet) {
    if (!field.equalsIgnoreCase("String_Node_Str")) {
      if (field.compareTo(fromField) >= 0 && field.compareTo(toField) <= 0) {
        Object value=row.get(field);
        map.put(field,value);
      }
    }
  }
  for (  String field : map.keySet()) {
    BasicDBObject dbObject=new BasicDBObject(field,map.get(field));
    subList.add(dbObject);
  }
}
Program: 97860
Project: 97860
Buggy source:
@SuppressWarnings({"String_Node_Str","String_Node_Str"}) @Override public AbstractCursor<Column> columnSlice(ColumnSliceInfo sliceInfo,Integer batchSize,BatchListener l,MetaLookup mgr){
  Info info=fetchDbCollectionInfo(sliceInfo.getColFamily().getColumnFamily(),mgr);
  if (info == null) {
    return null;
  }
  CursorColumnSliceMDB cursor=new CursorColumnSliceMDB(sliceInfo,l,batchSize,db);
  return cursor;
}

Fixed version (ground truth):
@SuppressWarnings({"String_Node_Str","String_Node_Str"}) @Override public AbstractCursor<Column> columnSlice(ColumnSliceInfo sliceInfo,Integer batchSize,BatchListener l,MetaLookup mgr){
  Info info=fetchDbCollectionInfo(sliceInfo.getColFamily().getColumnFamily(),mgr);
  if (info == null) {
    return null;
  }
  CursorColumnSliceMDB cursor=new CursorColumnSliceMDB(sliceInfo,l,batchSize,info.getDbObj());
  return cursor;
}
Program: 97863
Project: 97863
Buggy source:
@Test public void testAllRowsPolymorphic(){
  if (FactorySingleton.getServerType() != DbTypeEnum.CASSANDRA && FactorySingleton.getServerType() != DbTypeEnum.IN_MEMORY)   return;
  NonVirtSub1 s1=new NonVirtSub1();
  s1.setName("String_Node_Str");
  NonVirtSub2 s2=new NonVirtSub2();
  s2.setNum(5);
  mgr.put(s1);
  mgr.put(s2);
  mgr.flush();
  Cursor<NonVirtSuper> cursor=mgr.allRows(NonVirtSuper.class,"String_Node_Str",500);
  int count=0;
  while (cursor.next()) {
    NonVirtSuper current=cursor.getCurrent();
    count++;
  }
  Assert.assertEquals(2,count);
}

Fixed version (ground truth):
@Test public void testAllRowsPolymorphic(){
  if (FactorySingleton.getServerType() != DbTypeEnum.CASSANDRA)   return;
  NonVirtSub1 s1=new NonVirtSub1();
  s1.setName("String_Node_Str");
  NonVirtSub2 s2=new NonVirtSub2();
  s2.setNum(5);
  mgr.put(s1);
  mgr.put(s2);
  mgr.flush();
  Cursor<NonVirtSuper> cursor=mgr.allRows(NonVirtSuper.class,"String_Node_Str",500);
  int count=0;
  while (cursor.next()) {
    NonVirtSuper current=cursor.getCurrent();
    count++;
  }
  Assert.assertEquals(2,count);
}
Program: 97864
Project: 97864
Buggy source:
private Object translateFromColumnSet(Row row,OWNER entity,NoSqlSession session){
  List<byte[]> values=MetaToManyField.parseColNamePostfix(columnName,row);
  throw new UnsupportedOperationException("String_Node_Str");
}

Fixed version (ground truth):
private Object translateFromColumnSet(Row row,OWNER entity,NoSqlSession session){
  List<byte[]> values=MetaToManyField.parseColNamePostfix(columnName,row);
  Set<T> retVal=new SimpleSet<T>(converter,values);
  return retVal;
}
Program: 97865
Project: 97865
Buggy source:
@Test public void testEmbeddedSimple(){
  Email sub=new Email();
  sub.setId("String_Node_Str");
  sub.setName("String_Node_Str");
  sub.getIds().add("String_Node_Str");
  sub.getIds().add("String_Node_Str");
  sub.getInts().add(5);
  sub.getInts().add(8);
  mgr.put(sub);
  mgr.flush();
  NoSqlEntityManager mgr2=factory.createEntityManager();
  Email email=mgr2.find(Email.class,sub.getId());
  NoSqlEntityManager mgr3=factory.createEntityManager();
  Email email2=mgr3.find(Email.class,sub.getId());
  List<String> ids=email.getIds();
  Assert.assertEquals("String_Node_Str",ids.get(0));
  List<Integer> nums=email.getInts();
  Assert.assertEquals(new Integer(5),nums.get(0));
  email.getInts().remove(0);
  email.getIds().remove("String_Node_Str");
  mgr2.put(email);
  mgr2.flush();
  email2.getInts().add(12);
  email2.getIds().add("String_Node_Str");
  mgr3.put(email2);
  mgr3.flush();
  NoSqlEntityManager mgr4=factory.createEntityManager();
  Email emailF=mgr4.find(Email.class,sub.getId());
  Assert.assertEquals(2,emailF.getInts().size());
  Assert.assertEquals(2,emailF.getIds().size());
  Assert.assertEquals(new Integer(8),emailF.getInts().get(0));
  Assert.assertEquals(new Integer(12),emailF.getInts().get(1));
  Assert.assertEquals("String_Node_Str",emailF.getIds().get(0));
  Assert.assertEquals("String_Node_Str",emailF.getIds().get(1));
}

Fixed version (ground truth):
@Test public void testEmbeddedSimple(){
  Email sub=new Email();
  sub.setId("String_Node_Str");
  sub.setName("String_Node_Str");
  sub.getIds().add("String_Node_Str");
  sub.getIds().add("String_Node_Str");
  sub.getInts().add(5);
  sub.getInts().add(8);
  sub.getSomeSet().add("String_Node_Str");
  sub.getSomeSet().add("String_Node_Str");
  mgr.put(sub);
  mgr.flush();
  NoSqlEntityManager mgr2=factory.createEntityManager();
  Email email=mgr2.find(Email.class,sub.getId());
  NoSqlEntityManager mgr3=factory.createEntityManager();
  Email email2=mgr3.find(Email.class,sub.getId());
  List<String> ids=email.getIds();
  Assert.assertEquals("String_Node_Str",ids.get(0));
  List<Integer> nums=email.getInts();
  Assert.assertEquals(new Integer(5),nums.get(0));
  email.getInts().remove(0);
  email.getIds().remove("String_Node_Str");
  email.getSomeSet().remove("String_Node_Str");
  mgr2.put(email);
  mgr2.flush();
  email2.getInts().add(12);
  email2.getIds().add("String_Node_Str");
  email2.getSomeSet().add("String_Node_Str");
  mgr3.put(email2);
  mgr3.flush();
  NoSqlEntityManager mgr4=factory.createEntityManager();
  Email emailF=mgr4.find(Email.class,sub.getId());
  Assert.assertEquals(2,emailF.getInts().size());
  Assert.assertEquals(2,emailF.getIds().size());
  Assert.assertEquals(2,emailF.getSomeSet().size());
  Assert.assertEquals(new Integer(8),emailF.getInts().get(0));
  Assert.assertEquals(new Integer(12),emailF.getInts().get(1));
  Assert.assertEquals("String_Node_Str",emailF.getIds().get(0));
  Assert.assertEquals("String_Node_Str",emailF.getIds().get(1));
  Assert.assertEquals("String_Node_Str",emailF.getSomeSet().toArray()[0]);
  Assert.assertEquals("String_Node_Str",emailF.getSomeSet().toArray()[1]);
}