nus-yam/ex-repair huggingface dataset:
Program: 180273
Project: 180273
Buggy source:
/** 
 * @return current position as LatLon object.
 */
public LatLon getLatitudeLongitude();

Fixed version (ground truth):
/** 
 * @return current position as LatLon object or null if unable to determine Lat/Long.
 */
public LatLon getLatitudeLongitude();
Program: 180274
Project: 180274
Buggy source:
/** 
 * @param val Set's the intensity of the backlight 0-7.
 */
public int setBlackLight(int val) throws IOException ;

Fixed version (ground truth):
/** 
 * @param val Set's the intensity of the backlight 0-7.
 * @deprecated use setBackLight.
 */
public int setBlackLight(int val) throws IOException ;
Program: 180275
Project: 180275
Buggy source:
public int putCounter(int columnIndex,CounterColor counterColor){
  if (columnIndex < 0 || columnIndex >= NB_COLUMNS || columnIsfull(columnIndex)) {
    return -1;
  }
  if (CounterColor.RED.equals(counterColor)) {
    colorBoards[0]^=1L << columnsMaxValueUsed[columnIndex]++;
  }
 else {
    colorBoards[1]^=1L << columnsMaxValueUsed[columnIndex]++;
  }
  int verticalIndex=(columnsMaxValueUsed[columnIndex] - ((COLUMN_SIZE + 1) * columnIndex)) - 1;
  if (checkWinningMove(colorBoards[0])) {
    winnerCounterColor=CounterColor.RED;
  }
  if (checkWinningMove(colorBoards[1])) {
    winnerCounterColor=CounterColor.RED;
  }
  numberOfCounters++;
  return verticalIndex;
}

Fixed version (ground truth):
public int putCounter(int columnIndex,CounterColor counterColor){
  if (columnIndex < 0 || columnIndex >= NB_COLUMNS || columnIsfull(columnIndex)) {
    return -1;
  }
  if (CounterColor.RED.equals(counterColor)) {
    colorBoards[0]^=1L << columnsMaxValueUsed[columnIndex]++;
  }
 else {
    colorBoards[1]^=1L << columnsMaxValueUsed[columnIndex]++;
  }
  int verticalIndex=(columnsMaxValueUsed[columnIndex] - ((COLUMN_SIZE + 1) * columnIndex)) - 1;
  if (checkWinningMove(colorBoards[0])) {
    winnerCounterColor=CounterColor.RED;
  }
  if (checkWinningMove(colorBoards[1])) {
    winnerCounterColor=CounterColor.YELLOW;
  }
  numberOfCounters++;
  return verticalIndex;
}
Program: 180276
Project: 180276
Buggy source:
public boolean putCounter(int columnIndex){
  int verticalIndex=board.putCounter(columnIndex,currentCounterColor);
  if (verticalIndex != -1) {
    currentCounterColor=getNotCurrentCounterColor();
    winnerCounterColor=board.getWinnerCounterColor();
    return true;
  }
  return false;
}

Fixed version (ground truth):
public boolean putCounter(int columnIndex){
  int verticalIndex=board.putCounter(columnIndex,currentCounterColor);
  if (verticalIndex != -1) {
    currentCounterColor=getNotCurrentCounterColor();
    winnerCounterColor=board.getWinnerCounterColor();
    lastValidVerticalIndex=verticalIndex;
    return true;
  }
  return false;
}
Program: 180277
Project: 180277
Buggy source:
public Component createComponents(){
  initPlayers();
  JPanel panel=new JPanel();
  panel.setBorder(BorderFactory.createEmptyBorder(30,30,10,30));
  panel.setLayout(new GridLayout(0,1));
  DefaultTableModel defaultTableModel=buildTableModel();
  JTable jtable=buildJTable(defaultTableModel);
  panel.add(jtable);
  return panel;
}

Fixed version (ground truth):
public Component createComponents(){
  initPlayers();
  JPanel panel=new JPanel();
  panel.setBorder(BorderFactory.createEmptyBorder(30,30,10,30));
  panel.setLayout(new GridLayout(0,1));
  defaultTableModel=buildTableModel();
  JTable jtable=buildJTable(defaultTableModel);
  panel.add(jtable);
  resetGame();
  return panel;
}
Program: 180279
Project: 180279
Buggy source:
/** 
 * get available monomes
 * @return a map<name, info> with the monomes attached to this computer
 */
public String[] getDevices(){
  return (String[])monomesMap.keySet().toArray();
}

Fixed version (ground truth):
/** 
 * get available monomes
 * @return a map<name, info> with the monomes attached to this computer
 */
public String[] getDevices(){
  return monomesMap.keySet().toArray(new String[0]);
}
Program: 180280
Project: 180280
Buggy source:
/** 
 * Gives income to online players
 */
@SuppressWarnings("String_Node_Str") protected void handleOnlineIncome(){
  if (playersActivities.size() == 0)   return;
  if (iConomy == null) {
    logger.warning("String_Node_Str");
    return;
  }
  for (  Player player : getServer().getOnlinePlayers()) {
    final int activity=getActivity(player);
    if ((int)activity >= config.incomeMinActivity) {
      Holdings balance=iConomy.getAccount(player.getName()).getHoldings();
      Double amount=config.incomeBaseValue + (((double)(activity - config.incomeTargetActivity) / (double)config.incomeActivityModifier) * config.incomeBaseValue) + (balance.balance() * config.incomeBalanceMultiplier);
      if (amount > 0.0 || config.incomeAllowNegative) {
        balance.add(amount);
        sendMessage(player,"String_Node_Str" + activityColor(activity) + iConomy.format(amount)+ ChatColor.GRAY+ "String_Node_Str"+ activityColor(activity)+ activity+ "String_Node_Str"+ ChatColor.GRAY+ "String_Node_Str");
        sendMessage(player,"String_Node_Str" + ChatColor.WHITE + iConomy.format(balance.balance()));
        return;
      }
    }
    sendMessage(player,ChatColor.RED + "String_Node_Str");
  }
}

Fixed version (ground truth):
/** 
 * Gives income to online players
 */
@SuppressWarnings("String_Node_Str") protected void handleOnlineIncome(){
  if (playersActivities.size() == 0)   return;
  if (iConomy == null) {
    logger.warning("String_Node_Str");
    return;
  }
  for (  Player player : getServer().getOnlinePlayers()) {
    final int activity=getActivity(player);
    if ((int)activity >= config.incomeMinActivity) {
      Holdings balance=iConomy.getAccount(player.getName()).getHoldings();
      Double amount=config.incomeBaseValue + (((double)(activity - config.incomeTargetActivity) / (double)config.incomeActivityModifier) * config.incomeBaseValue) + (balance.balance() * config.incomeBalanceMultiplier);
      if (amount > 0.0 || config.incomeAllowNegative) {
        balance.add(amount);
        sendMessage(player,"String_Node_Str" + activityColor(activity) + iConomy.format(amount)+ ChatColor.GRAY+ "String_Node_Str"+ activityColor(activity)+ activity+ "String_Node_Str"+ ChatColor.GRAY+ "String_Node_Str");
        sendMessage(player,"String_Node_Str" + ChatColor.WHITE + iConomy.format(balance.balance()));
        continue;
      }
    }
    sendMessage(player,ChatColor.RED + "String_Node_Str");
  }
}
Program: 180281
Project: 180281
Buggy source:
public void onEnable(){
  new VanillaPlayerListener(this);
  loadConfig();
  getCommand("String_Node_Str").setExecutor(new VanillaCommand(this));
  pluginsCommand=new PluginsCommand(this);
  versionCommand=new VersionCommand(this);
}

Fixed version (ground truth):
public void onEnable(){
  new VanillaPlayerListener(this);
  getDataFolder().mkdirs();
  loadConfig();
  getCommand("String_Node_Str").setExecutor(new VanillaCommand(this));
  pluginsCommand=new PluginsCommand(this);
  versionCommand=new VersionCommand(this);
}
Program: 180282
Project: 180282
Buggy source:
public boolean onCommand(CommandSender sender,Command cmd,String commandLabel,String[] args){
  if (args.length == 0) {
    sender.sendMessage("String_Node_Str" + Bukkit.getName() + "String_Node_Str"+ Bukkit.getVersion()+ "String_Node_Str"+ Bukkit.getBukkitVersion()+ "String_Node_Str");
  }
 else {
    StringBuilder name=new StringBuilder();
    for (    String arg : args) {
      if (name.length() > 0) {
        name.append(' ');
      }
      name.append(arg);
    }
    Plugin plugin=Bukkit.getPluginManager().getPlugin(name.toString());
    if (plugin == null || vanillaPlugin.getConfigHandler().getHiddenPlugins().contains(plugin.getDescription().getName())) {
      sender.sendMessage("String_Node_Str");
      sender.sendMessage("String_Node_Str");
    }
 else {
      PluginDescriptionFile desc=plugin.getDescription();
      sender.sendMessage(ChatColor.GREEN + desc.getName() + ChatColor.WHITE+ "String_Node_Str"+ ChatColor.GREEN+ desc.getVersion());
      if (desc.getDescription() != null) {
        sender.sendMessage(desc.getDescription());
      }
      if (desc.getWebsite() != null) {
        sender.sendMessage("String_Node_Str" + ChatColor.GREEN + desc.getWebsite());
      }
      if (!desc.getAuthors().isEmpty()) {
        if (desc.getAuthors().size() == 1) {
          sender.sendMessage("String_Node_Str" + getAuthors(desc));
        }
 else {
          sender.sendMessage("String_Node_Str" + getAuthors(desc));
        }
      }
    }
  }
  return true;
}

Fixed version (ground truth):
public boolean onCommand(CommandSender sender,Command cmd,String commandLabel,String[] args){
  if (args.length == 0) {
    sender.sendMessage("String_Node_Str" + Bukkit.getName() + "String_Node_Str"+ Bukkit.getVersion()+ "String_Node_Str"+ Bukkit.getBukkitVersion()+ "String_Node_Str");
  }
 else {
    StringBuilder name=new StringBuilder();
    for (    String arg : args) {
      if (name.length() > 0) {
        name.append(' ');
      }
      name.append(arg);
    }
    Plugin plugin=Bukkit.getPluginManager().getPlugin(name.toString());
    if (plugin == null || vanillaPlugin.getConfigHandler().getHiddenPlugins().contains(plugin.getDescription().getName().toLowerCase())) {
      sender.sendMessage("String_Node_Str");
      sender.sendMessage("String_Node_Str");
    }
 else {
      PluginDescriptionFile desc=plugin.getDescription();
      sender.sendMessage(ChatColor.GREEN + desc.getName() + ChatColor.WHITE+ "String_Node_Str"+ ChatColor.GREEN+ desc.getVersion());
      if (desc.getDescription() != null) {
        sender.sendMessage(desc.getDescription());
      }
      if (desc.getWebsite() != null) {
        sender.sendMessage("String_Node_Str" + ChatColor.GREEN + desc.getWebsite());
      }
      if (!desc.getAuthors().isEmpty()) {
        if (desc.getAuthors().size() == 1) {
          sender.sendMessage("String_Node_Str" + getAuthors(desc));
        }
 else {
          sender.sendMessage("String_Node_Str" + getAuthors(desc));
        }
      }
    }
  }
  return true;
}
Program: 180283
Project: 180283
Buggy source:
@EventHandler() public void onPlayerCommandPreprocess(PlayerCommandPreprocessEvent event){
  Player player=event.getPlayer();
  String[] split=event.getMessage().split("String_Node_Str");
  String cmdName=split[0].substring(1).toLowerCase();
  String[] realArgs;
  if (split.length < 2) {
    realArgs=new String[0];
  }
 else {
    realArgs=new String[split.length - 2];
    for (int i=2; i < split.length; i++) {
      realArgs[i - 2]=split[i];
    }
  }
  boolean handled=true;
  ConfigHandler configHandler=plugin.getConfigHandler();
  if (pluginsCommandAliases.contains(cmdName) && !player.hasPermission("String_Node_Str")) {
    if (!configHandler.isHidingPluginsCommand()) {
      plugin.getPluginsCommand().onCommand(player,null,null,realArgs);
    }
  }
 else   if (versionCommandAliases.contains(cmdName) && !player.hasPermission("String_Node_Str")) {
    if (!configHandler.isHidingVersionCommand()) {
      plugin.getVersionCommand().onCommand(player,null,null,realArgs);
    }
  }
 else {
    handled=false;
  }
  if (handled) {
    event.setCancelled(true);
  }
}

Fixed version (ground truth):
@EventHandler() public void onPlayerCommandPreprocess(PlayerCommandPreprocessEvent event){
  Player player=event.getPlayer();
  String[] split=event.getMessage().split("String_Node_Str");
  String cmdName=split[0].substring(1).toLowerCase();
  String[] realArgs;
  realArgs=new String[split.length - 1];
  for (int i=1; i < split.length; i++) {
    realArgs[i - 1]=split[i];
  }
  boolean handled=true;
  ConfigHandler configHandler=plugin.getConfigHandler();
  if (pluginsCommandAliases.contains(cmdName) && !player.hasPermission("String_Node_Str")) {
    if (!configHandler.isHidingPluginsCommand()) {
      plugin.getPluginsCommand().onCommand(player,null,null,realArgs);
    }
  }
 else   if (versionCommandAliases.contains(cmdName) && !player.hasPermission("String_Node_Str")) {
    if (!configHandler.isHidingVersionCommand()) {
      plugin.getVersionCommand().onCommand(player,null,null,realArgs);
    }
  }
 else {
    handled=false;
  }
  if (handled) {
    event.setCancelled(true);
  }
}
Program: 180284
Project: 180284
Buggy source:
public Object unmarshal(HierarchicalStreamReader reader,UnmarshallingContext context){
  String className=reader.getAttribute("String_Node_Str");
  RubyClass c=runtime.getClass(className);
  if (c == null)   throw new IllegalArgumentException("String_Node_Str" + className);
  Class r=c.getReifiedClass();
  if (r != null) {
    Converter cnv=xs.getConverterLookup().lookupConverterForType(r);
    if (cnv != this)     return cnv.unmarshal(reader,context);
  }
  IRubyObject o=c.allocate();
  while (reader.hasMoreChildren()) {
    reader.moveDown();
    String fieldName=reader.getNodeName();
    Class valueType;
    className=reader.getAttribute("String_Node_Str");
    if (className != null) {
      valueType=mapper.realClass(className);
    }
 else {
      valueType=IRubyObject.class;
    }
    IRubyObject value=(IRubyObject)context.convertAnother(o,valueType);
    c.getVariableAccessorForWrite('@' + fieldName).set(o,value);
    reader.moveUp();
  }
  return o;
}

Fixed version (ground truth):
public Object unmarshal(HierarchicalStreamReader reader,UnmarshallingContext context){
  String className=reader.getAttribute("String_Node_Str");
  RubyClass c=resolveClass(className);
  if (c == null)   throw new IllegalArgumentException("String_Node_Str" + className);
  Class r=c.getReifiedClass();
  if (r != null) {
    Converter cnv=xs.getConverterLookup().lookupConverterForType(r);
    if (cnv != this)     return cnv.unmarshal(reader,context);
  }
  IRubyObject o=c.allocate();
  while (reader.hasMoreChildren()) {
    reader.moveDown();
    String fieldName=reader.getNodeName();
    Class valueType;
    className=reader.getAttribute("String_Node_Str");
    if (className != null) {
      valueType=mapper.realClass(className);
    }
 else {
      valueType=IRubyObject.class;
    }
    IRubyObject value=(IRubyObject)context.convertAnother(o,valueType);
    c.getVariableAccessorForWrite('@' + fieldName).set(o,value);
    reader.moveUp();
  }
  return o;
}
Program: 180285
Project: 180285
Buggy source:
@Override protected void setUp() throws Exception {
  super.setUp();
  jruby=new ScriptingContainer();
  xs=new XStream(){
    @Override protected MapperWrapper wrapMapper(    MapperWrapper next){
      return new JRubyMapper(next);
    }
  }
;
  JRubyXStream.register(xs,jruby.getProvider().getRuntime());
}

Fixed version (ground truth):
@Override protected void setUp() throws Exception {
  super.setUp();
  jruby=new ScriptingContainer(LocalContextScope.SINGLETHREAD);
  xs=new XStream(){
    @Override protected MapperWrapper wrapMapper(    MapperWrapper next){
      return new JRubyMapper(next);
    }
  }
;
  JRubyXStream.register(xs,jruby.getProvider().getRuntime());
}
Program: 180286
Project: 180286
Buggy source:
public Object unmarshal(HierarchicalStreamReader reader,UnmarshallingContext context){
  String className=reader.getAttribute("String_Node_Str");
  RubyClass c=runtime.getClass(className);
  IRubyObject o=c.allocate();
  while (reader.hasMoreChildren()) {
    reader.moveDown();
    String fieldName=reader.getNodeName();
    Class valueType;
    className=reader.getAttribute("String_Node_Str");
    if (className != null) {
      valueType=mapper.realClass(className);
    }
 else {
      valueType=IRubyObject.class;
    }
    IRubyObject value=(IRubyObject)context.convertAnother(o,valueType);
    c.getVariableAccessorForWrite('@' + fieldName).set(o,value);
    reader.moveUp();
  }
  return o;
}

Fixed version (ground truth):
public Object unmarshal(HierarchicalStreamReader reader,UnmarshallingContext context){
  String className=reader.getAttribute("String_Node_Str");
  RubyClass c=runtime.getClass(className);
  Class r=c.getReifiedClass();
  if (r != null) {
    return xs.getConverterLookup().lookupConverterForType(r).unmarshal(reader,context);
  }
  IRubyObject o=c.allocate();
  while (reader.hasMoreChildren()) {
    reader.moveDown();
    String fieldName=reader.getNodeName();
    Class valueType;
    className=reader.getAttribute("String_Node_Str");
    if (className != null) {
      valueType=mapper.realClass(className);
    }
 else {
      valueType=IRubyObject.class;
    }
    IRubyObject value=(IRubyObject)context.convertAnother(o,valueType);
    c.getVariableAccessorForWrite('@' + fieldName).set(o,value);
    reader.moveUp();
  }
  return o;
}
Program: 180287
Project: 180287
Buggy source:
public boolean canConvert(Class type){
  return RubyBasicObject.class.isAssignableFrom(type);
}

Fixed version (ground truth):
public boolean canConvert(Class type){
  return IRubyObject.class.isAssignableFrom(type);
}
Program: 180288
Project: 180288
Buggy source:
public JRubyXStreamConverter(Ruby runtime,Mapper mapper){
  this.runtime=runtime;
  this.mapper=mapper;
}

Fixed version (ground truth):
public JRubyXStreamConverter(XStream xs,Ruby runtime){
  this.xs=xs;
  this.runtime=runtime;
  this.mapper=xs.getMapper();
}
Program: 180289
Project: 180289
Buggy source:
public void test1(){
  ScriptingContainer jruby=new ScriptingContainer();
  RubyObject o=(RubyObject)jruby.runScriptlet("String_Node_Str");
  XStream xs=new XStream(){
    @Override protected MapperWrapper wrapMapper(    MapperWrapper next){
      return new JRubyMapper(next);
    }
  }
;
  Ruby runtime=jruby.getProvider().getRuntime();
  xs.registerConverter(new RubyStringConverter(runtime));
  xs.registerConverter(new RubyFixnumConverter(runtime));
  xs.registerConverter(new JRubyXStreamConverter(runtime,xs.getMapper()),XStream.PRIORITY_LOW);
  System.out.println(xs.toXML(o));
}

Fixed version (ground truth):
public void test1(){
  RubyObject o=(RubyObject)jruby.runScriptlet("String_Node_Str");
  String xml=xs.toXML(o);
  System.out.println(xml);
  Object r=xs.fromXML(xml);
}
Program: 180290
Project: 180290
Buggy source:
/** 
 * Filterung der Liste anhand von gegebenen Filterelementen
 * @param mainList  Die Liste mit allen Elementen
 */
public List filter(List mainList){
  List<Object> temp=new ArrayList<Object>();
  for (  Object o : mainList) {
    boolean isValid=true;
    for (    XFilter filter : filterList) {
      if (filter.getFilterValue() != null && !filter.getFilterValue().isEmpty()) {
        try {
          Method om=null;
          Object oc=o;
          for (          String method : XHelper.getMethodPath(filter.getFilterPath())) {
            om=oc.getClass().getMethod(method,new Class[]{});
            oc=om.invoke(oc,new Object[]{});
          }
          if (!oc.toString().toUpperCase().matches("String_Node_Str" + filter.getFilterValue().toUpperCase() + "String_Node_Str")) {
            isValid=false;
            break;
          }
        }
 catch (        IllegalAccessException ex) {
        }
catch (        IllegalArgumentException ex) {
        }
catch (        InvocationTargetException ex) {
        }
catch (        NoSuchMethodException ex) {
        }
catch (        SecurityException ex) {
        }
      }
    }
    if (isValid) {
      temp.add(o);
    }
  }
  return temp;
}

Fixed version (ground truth):
/** 
 * Filterung der Liste anhand von gegebenen Filterelementen
 * @param mainList  Die Liste mit allen Elementen
 */
public List filter(List mainList){
  List<Object> temp=new ArrayList<Object>();
  String objValue=null;
  for (  Object o : mainList) {
    boolean isValid=true;
    for (    XFilter filter : filterList) {
      if (filter.getFilterValue() != null && !filter.getFilterValue().isEmpty()) {
        try {
          Method om=null;
          Object oc=o;
          for (          String method : XHelper.getMethodPath(filter.getFilterPath())) {
            om=oc.getClass().getMethod(method,new Class[]{});
            oc=om.invoke(oc,new Object[]{});
          }
          objValue=oc.toString();
switch (filter.getFilterType()) {
case INPUT:
{
              if (!objValue.toUpperCase().matches("String_Node_Str" + filter.getFilterValue().toUpperCase() + "String_Node_Str")) {
                isValid=false;
                break;
              }
              break;
            }
case SELECTONE:
{
            if (!objValue.equals(filter.getFilterValue())) {
              isValid=false;
              break;
            }
            break;
          }
case SELECTMULTIPLE:
{
          break;
        }
    }
  }
 catch (  IllegalAccessException ex) {
  }
catch (  IllegalArgumentException ex) {
  }
catch (  InvocationTargetException ex) {
  }
catch (  NoSuchMethodException ex) {
  }
catch (  SecurityException ex) {
  }
}
}
if (isValid) {
temp.add(o);
}
}
return temp;
}
Program: 180291
Project: 180291
Buggy source:
public List<Object> getValues(List subList){
  List<Object> temp=new ArrayList<Object>();
  for (  XFilter filter : filterList) {
    Object filterData=null;
switch (filter.getFilterType()) {
case INPUT:
case SUGGEST:
      filterData=new Object[]{filter.getElementId(),filter.getFilterType().toString(),filter.getFilterValue()};
    break;
case SELECTONE:
  filterData=new Object[]{filter.getElementId(),filter.getFilterType().toString(),getOptions(filter,subList),filter.getFilterValue()};
break;
case SELECTMULTIPLE:
filterData=new Object[]{filter.getElementId(),filter.getFilterType().toString(),getOptions(filter,subList),filter.getFilterValue()};
break;
}
temp.add(filterData);
}
return temp;
}

Fixed version (ground truth):
public List<Object> getValues(List subList){
  List<Object> temp=new ArrayList<Object>();
  for (  XFilter filter : filterList) {
    Object filterData=null;
switch (filter.getFilterType()) {
case INPUT:
case SUGGEST:
      filterData=new Object[]{filter.getElementId(),filter.getFilterType().toString(),filter.getFilterValue()};
    break;
case SELECTONE:
  filterData=new Object[]{filter.getElementId(),filter.getFilterType().toString(),getOptions(filter,subList),filter.getFilterValue()};
break;
case SELECTMULTIPLE:
break;
}
temp.add(filterData);
}
return temp;
}
Program: 180292
Project: 180292
Buggy source:
public static VerificationResult launch(Manager manager,Experiment experiment) throws Exception {
  ApplicationConfiguration configuration=new ApplicationConfiguration();
  ExtensionDescriptor descriptor=manager.resolve(ParasimDescriptor.class,Default.class).getExtensionDescriptor("String_Node_Str");
  if (descriptor != null) {
    manager.resolve(ExtensionDescriptorMapper.class,Default.class).map(descriptor,configuration);
  }
  ComputationContainer container=manager.resolve(ComputationContainer.class,Default.class);
  for (  OdeSystemVariable variable : experiment.getOdeSystem()) {
    LOGGER.info(variable.getName() + "String_Node_Str" + variable.getRightSideExpression().toFormula());
  }
  LOGGER.info(getFormulaInfo(experiment.getFormula()));
  Future<VerificationResult> result=container.compute(new ValidityRegionsComputation(configuration,experiment.getOdeSystem(),experiment.getPrecisionConfiguration(),experiment.getSimulationSpace(),experiment.getInitialSpace(),experiment.getFormula(),experiment.getIterationLimit()));
  try {
    return result.get(experiment.getTimeoutAmount(),experiment.getTimeoutUnit());
  }
 catch (  TimeoutException e) {
    LOGGER.error("String_Node_Str");
    result.cancel(true);
    return result.getPartial();
  }
}

Fixed version (ground truth):
public static VerificationResult launch(Manager manager,Experiment experiment) throws Exception {
  ApplicationConfiguration configuration=manager.resolve(ApplicationConfiguration.class,Default.class);
  ComputationContainer container=manager.resolve(ComputationContainer.class,Default.class);
  for (  OdeSystemVariable variable : experiment.getOdeSystem()) {
    LOGGER.info(variable.getName() + "String_Node_Str" + variable.getRightSideExpression().toFormula());
  }
  LOGGER.info(getFormulaInfo(experiment.getFormula()));
  Future<VerificationResult> result=container.compute(new ValidityRegionsComputation(experiment.getOdeSystem(),experiment.getPrecisionConfiguration(),experiment.getSimulationSpace(),experiment.getInitialSpace(),experiment.getFormula(),experiment.getIterationLimit()));
  try {
    return result.get(experiment.getTimeoutAmount(),experiment.getTimeoutUnit());
  }
 catch (  TimeoutException e) {
    LOGGER.error("String_Node_Str");
    result.cancel(true);
    return result.getPartial();
  }
}
Program: 180293
Project: 180293
Buggy source:
public ValidityRegionsComputation(ApplicationConfiguration configuration,OdeSystem odeSystem,PrecisionConfiguration precisionConfiguration,OrthogonalSpace simulationSpace,OrthogonalSpace initialSpace,Formula property,int iterationLimit){
  if (configuration == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  if (odeSystem == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  if (precisionConfiguration == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  if (simulationSpace == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  if (initialSpace == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  if (property == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  this.odeSystem=odeSystem;
  this.precisionConfiguration=precisionConfiguration;
  this.simulationSpace=new OrthogonalSpaceImpl(simulationSpace.getMinBounds(),new ArrayPoint(property.getTimeNeeded(),simulationSpace.getMaxBounds().toArray()),simulationSpace.getOdeSystem());
  this.originalSimulationSpace=simulationSpace;
  this.initialSpace=initialSpace;
  this.property=property;
  this.iterationLimit=iterationLimit;
  this.configuration=configuration;
  if (new FormulaStarInfo(property).getStarNumber() == 0) {
    LOGGER.debug("String_Node_Str");
    useFrozenVerifier=false;
  }
 else {
    LOGGER.debug("String_Node_Str");
    useFrozenVerifier=true;
  }
}

Fixed version (ground truth):
public ValidityRegionsComputation(OdeSystem odeSystem,PrecisionConfiguration precisionConfiguration,OrthogonalSpace simulationSpace,OrthogonalSpace initialSpace,Formula property,int iterationLimit){
  if (odeSystem == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  if (precisionConfiguration == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  if (simulationSpace == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  if (initialSpace == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  if (property == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  this.odeSystem=odeSystem;
  this.precisionConfiguration=precisionConfiguration;
  this.simulationSpace=new OrthogonalSpaceImpl(simulationSpace.getMinBounds(),new ArrayPoint(property.getTimeNeeded(),simulationSpace.getMaxBounds().toArray()),simulationSpace.getOdeSystem());
  this.originalSimulationSpace=simulationSpace;
  this.initialSpace=initialSpace;
  this.property=property;
  this.iterationLimit=iterationLimit;
  if (new FormulaStarInfo(property).getStarNumber() == 0) {
    LOGGER.debug("String_Node_Str");
    useFrozenVerifier=false;
  }
 else {
    LOGGER.debug("String_Node_Str");
    useFrozenVerifier=true;
  }
}
Program: 180294
Project: 180294
Buggy source:
public Computation<VerificationResult> cloneComputation(){
  ValidityRegionsComputation computation=new ValidityRegionsComputation(configuration,odeSystem,precisionConfiguration,originalSimulationSpace,initialSpace,property,iterationLimit);
  computation.currentIteration=this.currentIteration;
  computation.spawned=this.spawned;
  return computation;
}

Fixed version (ground truth):
public Computation<VerificationResult> cloneComputation(){
  ValidityRegionsComputation computation=new ValidityRegionsComputation(odeSystem,precisionConfiguration,originalSimulationSpace,initialSpace,property,iterationLimit);
  computation.currentIteration=this.currentIteration;
  computation.spawned=this.spawned;
  return computation;
}
Program: 180295
Project: 180295
Buggy source:
@Test(enabled=false) public void testComputation2() throws ExecutionException, InterruptedException, TimeoutException {
  ValidityRegionsComputation computation=new ValidityRegionsComputation(new ApplicationConfiguration(),createOdeSystem(),createPrecisionConfiguration(),createSimulationSpace(),createInitialSpace(),createFutureFormula(2),0);
  ComputationContainer container=getManager().resolve(ComputationContainer.class,Default.class);
  VerificationResult result=container.compute(computation).get(40,TimeUnit.SECONDS);
  for (int i=0; i < result.size(); i++) {
    assertEquals(result.getPoint(i).getTime(),0f);
    if (result.getPoint(i).getValue(0) > 2) {
      assertTrue(result.getRobustness(i).getValue() > 0,"String_Node_Str" + i + "String_Node_Str"+ result.getPoint(i)+ "String_Node_Str"+ result.getRobustness(i).getValue());
    }
 else {
      assertTrue(result.getRobustness(i).getValue() <= 0,"String_Node_Str" + i + "String_Node_Str"+ result.getPoint(i)+ "String_Node_Str"+ result.getRobustness(i).getValue());
    }
  }
}

Fixed version (ground truth):
@Test(enabled=false) public void testComputation2() throws ExecutionException, InterruptedException, TimeoutException {
  ValidityRegionsComputation computation=new ValidityRegionsComputation(createOdeSystem(),createPrecisionConfiguration(),createSimulationSpace(),createInitialSpace(),createFutureFormula(2),0);
  ComputationContainer container=getManager().resolve(ComputationContainer.class,Default.class);
  VerificationResult result=container.compute(computation).get(40,TimeUnit.SECONDS);
  for (int i=0; i < result.size(); i++) {
    assertEquals(result.getPoint(i).getTime(),0f);
    if (result.getPoint(i).getValue(0) > 2) {
      assertTrue(result.getRobustness(i).getValue() > 0,"String_Node_Str" + i + "String_Node_Str"+ result.getPoint(i)+ "String_Node_Str"+ result.getRobustness(i).getValue());
    }
 else {
      assertTrue(result.getRobustness(i).getValue() <= 0,"String_Node_Str" + i + "String_Node_Str"+ result.getPoint(i)+ "String_Node_Str"+ result.getRobustness(i).getValue());
    }
  }
}
Program: 180296
Project: 180296
Buggy source:
@Test public void testComputation() throws ExecutionException, InterruptedException, TimeoutException {
  ValidityRegionsComputation computation=new ValidityRegionsComputation(new ApplicationConfiguration(),createOdeSystem(),createPrecisionConfiguration(),createSimulationSpace(),createInitialSpace(),createFutureFormula(-1f),0);
  ComputationContainer container=getManager().resolve(ComputationContainer.class,Default.class);
  VerificationResult result=container.compute(computation).get(40,TimeUnit.SECONDS);
  for (int i=0; i < result.size(); i++) {
    assertTrue(result.getRobustness(i).getValue() > 0,"String_Node_Str" + i + "String_Node_Str"+ result.getPoint(i)+ "String_Node_Str"+ result.getRobustness(i).getValue());
    assertEquals(result.getPoint(i).getTime(),0f);
  }
}

Fixed version (ground truth):
@Test public void testComputation() throws ExecutionException, InterruptedException, TimeoutException {
  ValidityRegionsComputation computation=new ValidityRegionsComputation(createOdeSystem(),createPrecisionConfiguration(),createSimulationSpace(),createInitialSpace(),createFutureFormula(-1f),0);
  ComputationContainer container=getManager().resolve(ComputationContainer.class,Default.class);
  VerificationResult result=container.compute(computation).get(40,TimeUnit.SECONDS);
  for (int i=0; i < result.size(); i++) {
    assertTrue(result.getRobustness(i).getValue() > 0,"String_Node_Str" + i + "String_Node_Str"+ result.getPoint(i)+ "String_Node_Str"+ result.getRobustness(i).getValue());
    assertEquals(result.getPoint(i).getTime(),0f);
  }
}
Program: 180297
Project: 180297
Buggy source:
public static void main(String[] args) throws Exception {
  Experiment experiment=null;
  VerificationResult result=null;
  ParasimOptions options=ParasimOptions.create(args);
  if (options.getConfigFile() != null) {
    System.setProperty("String_Node_Str",options.getConfigFile());
  }
  Manager manager=ManagerImpl.create().start();
  Actions actions=new Actions(manager,options);
  try {
    if (actions.help().isEnabled()) {
      actions.help().call();
    }
    if (actions.loadExperiment().isEnabled()) {
      experiment=actions.loadExperiment().call();
    }
    if (actions.compute(experiment).isEnabled()) {
      result=actions.compute(experiment).call();
    }
    if (actions.loadResults(experiment).isEnabled()) {
      result=actions.loadResults(experiment).call();
    }
    if (actions.plotResults(result,experiment).isEnabled()) {
      actions.plotResults(result,experiment).call();
    }
    if (actions.exportToCsv(result,experiment).isEnabled()) {
      actions.exportToCsv(result,experiment).call();
    }
    if (actions.startServer().isEnabled()) {
      actions.startServer().call();
    }
    if (actions.startGuiManager().isEnabled()) {
      actions.startGuiManager().call();
    }
  }
 catch (  ParseException e) {
    actions.help().call();
  }
 finally {
    if (actions.shutdown().isEnabled()) {
      actions.shutdown().call();
    }
  }
}

Fixed version (ground truth):
public static void main(String[] args) throws Exception {
  Experiment experiment=null;
  VerificationResult result=null;
  ParasimOptions options=ParasimOptions.create(args);
  if (options.getConfigFile() != null) {
    System.setProperty("String_Node_Str",options.getConfigFile());
  }
  Manager manager=ManagerImpl.create().start();
  if (options.getConfigFile() != null) {
    LOGGER.info("String_Node_Str" + options.getConfigFile());
  }
  Actions actions=new Actions(manager,options);
  try {
    if (actions.help().isEnabled()) {
      actions.help().call();
    }
    if (actions.loadExperiment().isEnabled()) {
      experiment=actions.loadExperiment().call();
    }
    if (actions.compute(experiment).isEnabled()) {
      result=actions.compute(experiment).call();
    }
    if (actions.loadResults(experiment).isEnabled()) {
      result=actions.loadResults(experiment).call();
    }
    if (actions.plotResults(result,experiment).isEnabled()) {
      actions.plotResults(result,experiment).call();
    }
    if (actions.exportToCsv(result,experiment).isEnabled()) {
      actions.exportToCsv(result,experiment).call();
    }
    if (actions.startServer().isEnabled()) {
      actions.startServer().call();
    }
    if (actions.startGuiManager().isEnabled()) {
      actions.startGuiManager().call();
    }
  }
 catch (  ParseException e) {
    actions.help().call();
  }
 finally {
    if (actions.shutdown().isEnabled()) {
      actions.shutdown().call();
    }
  }
}
Program: 180298
Project: 180298
Buggy source:
public ValidityRegionsComputation(OdeSystem odeSystem,PrecisionConfiguration precisionConfiguration,OrthogonalSpace simulationSpace,OrthogonalSpace initialSpace,Formula property,int iterationLimit){
  if (odeSystem == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  if (precisionConfiguration == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  if (simulationSpace == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  if (initialSpace == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  if (property == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  this.odeSystem=odeSystem;
  this.precisionConfiguration=precisionConfiguration;
  this.simulationSpace=new OrthogonalSpaceImpl(simulationSpace.getMinBounds(),new ArrayPoint(Math.min(property.getTimeNeeded(),simulationSpace.getMaxBounds().getTime()),simulationSpace.getMaxBounds().toArray()),simulationSpace.getOdeSystem());
  this.originalSimulationSpace=simulationSpace;
  this.initialSpace=initialSpace;
  this.property=property;
  this.iterationLimit=iterationLimit;
}

Fixed version (ground truth):
public ValidityRegionsComputation(OdeSystem odeSystem,PrecisionConfiguration precisionConfiguration,OrthogonalSpace simulationSpace,OrthogonalSpace initialSpace,Formula property,int iterationLimit){
  if (odeSystem == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  if (precisionConfiguration == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  if (simulationSpace == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  if (initialSpace == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  if (property == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  this.odeSystem=odeSystem;
  this.precisionConfiguration=precisionConfiguration;
  this.simulationSpace=new OrthogonalSpaceImpl(simulationSpace.getMinBounds(),new ArrayPoint(property.getTimeNeeded(),simulationSpace.getMaxBounds().toArray()),simulationSpace.getOdeSystem());
  this.originalSimulationSpace=simulationSpace;
  this.initialSpace=initialSpace;
  this.property=property;
  this.iterationLimit=iterationLimit;
}
Program: 180300
Project: 180300
Buggy source:
@Override public void setIterationLimit(int iterationLimit){
  if (iterationLimit != iterationLimit) {
    content.setIterationLimit(iterationLimit);
    saved=false;
  }
}

Fixed version (ground truth):
@Override public void setIterationLimit(int iterationLimit){
  if (iterationLimit != getIterationLimit()) {
    content.setIterationLimit(iterationLimit);
    saved=false;
  }
}
Program: 180302
Project: 180302
Buggy source:
@Override public Monitor createMonitor(Trajectory trajectory,Formula property){
  if (trajectory.getLastPoint().getTime() < property.getTimeNeeded()) {
    throw new IllegalArgumentException("String_Node_Str" + property + "String_Node_Str"+ property.getTimeNeeded()+ "String_Node_Str"+ trajectory.getLastPoint().getTime()+ "String_Node_Str");
  }
switch (property.getType()) {
case AND:
    return new AndMonitor(property,createMonitor(trajectory,property.getSubformula(0)),createMonitor(trajectory,property.getSubformula(1)));
case FUTURE:
  return new FutureMonitor(property,createMonitor(trajectory,property.getSubformula(0)),((FutureFormula)property).getInterval());
case GLOBALLY:
return new GloballyMonitor(property,createMonitor(trajectory,property.getSubformula(0)),((GloballyFormula)property).getInterval());
case NOT:
return new NotMonitor(property,createMonitor(trajectory,property.getSubformula(0)));
case OR:
return new OrMonitor(property,createMonitor(trajectory,property.getSubformula(0)),createMonitor(trajectory,property.getSubformula(1)));
case PREDICATE:
return new PredicateMonitor(property,trajectory,(Predicate)property);
case UNTIL:
return new UntilMonitor(property,createMonitor(trajectory,property.getSubformula(0)),createMonitor(trajectory,property.getSubformula(1)),((UntilFormula)property).getInterval());
default :
throw new UnsupportedOperationException("String_Node_Str" + property.getType() + "String_Node_Str");
}
}

Fixed version (ground truth):
@Override public Monitor createMonitor(Trajectory trajectory,Formula property){
  if (trajectory.getLastPoint().getTime() < property.getTimeNeeded()) {
    throw new IllegalArgumentException("String_Node_Str" + property + "String_Node_Str"+ property.getTimeNeeded()+ "String_Node_Str"+ trajectory.getLastPoint().getTime()+ "String_Node_Str"+ trajectory.getFirstPoint()+ "String_Node_Str");
  }
switch (property.getType()) {
case AND:
    return new AndMonitor(property,createMonitor(trajectory,property.getSubformula(0)),createMonitor(trajectory,property.getSubformula(1)));
case FUTURE:
  return new FutureMonitor(property,createMonitor(trajectory,property.getSubformula(0)),((FutureFormula)property).getInterval());
case GLOBALLY:
return new GloballyMonitor(property,createMonitor(trajectory,property.getSubformula(0)),((GloballyFormula)property).getInterval());
case NOT:
return new NotMonitor(property,createMonitor(trajectory,property.getSubformula(0)));
case OR:
return new OrMonitor(property,createMonitor(trajectory,property.getSubformula(0)),createMonitor(trajectory,property.getSubformula(1)));
case PREDICATE:
return new PredicateMonitor(property,trajectory,(Predicate)property);
case UNTIL:
return new UntilMonitor(property,createMonitor(trajectory,property.getSubformula(0)),createMonitor(trajectory,property.getSubformula(1)),((UntilFormula)property).getInterval());
default :
throw new UnsupportedOperationException("String_Node_Str" + property.getType() + "String_Node_Str");
}
}
Program: 180303
Project: 180303
Buggy source:
@Override public TrajectoryReference getReference(){
  if (reference == null) {
    final Trajectory thisTrajectory=this;
    reference=new TrajectoryReference(){
      private volatile Trajectory referencedTrajectory=thisTrajectory;
      @Override public Trajectory getTrajectory(){
        return referencedTrajectory;
      }
      @Override public void setTrajectory(      Trajectory trajectory){
        referencedTrajectory=trajectory;
      }
    }
;
  }
  return reference;
}

Fixed version (ground truth):
@Override public TrajectoryReference getReference(){
  return reference;
}
Program: 180304
Project: 180304
Buggy source:
@Override public Trajectory withoutNeighbors(){
  List<Point> points=new ArrayList<>(getLength());
  for (  Point p : this) {
    points.add(p);
  }
  return new ListTrajectory(points);
}

Fixed version (ground truth):
@Override public Trajectory withoutNeighbors(){
  List<Point> points=new ArrayList<>(getLength());
  for (  Point p : this.getReference().getTrajectory()) {
    points.add(p);
  }
  return new ListTrajectory(points);
}
Program: 180307
Project: 180307
Buggy source:
@Override public String toFormula(VariableRenderer renderer){
  StringBuilder builder=new StringBuilder();
  if (getLeft() instanceof BinaryOperator && ((BinaryOperator)getLeft()).getPriority() < getPriority()) {
    builder.append("String_Node_Str").append(getLeft().toFormula(renderer)).append("String_Node_Str");
  }
 else {
    builder.append(getLeft().toFormula(renderer));
  }
  builder.append("String_Node_Str").append(getSymbol()).append("String_Node_Str");
  if (getRight() instanceof BinaryOperator && ((BinaryOperator)getRight()).getPriority() < getPriority()) {
    builder.append("String_Node_Str").append(getRight().toFormula(renderer)).append("String_Node_Str");
  }
 else {
    builder.append(getRight().toFormula(renderer));
  }
  return builder.toString();
}

Fixed version (ground truth):
@Override public StringBuilder toFormula(StringBuilder builder,VariableRenderer renderer){
  if ((getLeft() instanceof BinaryOperator && ((BinaryOperator)getLeft()).getPriority() > getPriority()) || getLeft().getClass().equals(getClass()) || !(getLeft() instanceof BinaryOperator)) {
    getLeft().toFormula(builder,renderer);
  }
 else {
    builder.append("String_Node_Str");
    getLeft().toFormula(builder,renderer).append("String_Node_Str");
  }
  builder.append("String_Node_Str").append(getSymbol()).append("String_Node_Str");
  if ((getRight() instanceof BinaryOperator && ((BinaryOperator)getRight()).getPriority() > getPriority()) || getRight().getClass().equals(getClass()) || !(getRight() instanceof BinaryOperator)) {
    getRight().toFormula(builder,renderer);
  }
 else {
    builder.append("String_Node_Str");
    getRight().toFormula(builder,renderer).append("String_Node_Str");
  }
  return builder;
}
Program: 180308
Project: 180308
Buggy source:
@Override public String toFormula(VariableRenderer renderer){
  StringBuilder builder=new StringBuilder();
  if (getLeft() instanceof BinaryOperator) {
    builder.append("String_Node_Str").append(getLeft().toFormula(renderer)).append("String_Node_Str");
  }
 else {
    builder.append(getLeft().toFormula(renderer));
  }
  builder.append("String_Node_Str").append(getSymbol()).append("String_Node_Str");
  if (getRight() instanceof BinaryOperator) {
    builder.append("String_Node_Str").append(getRight().toFormula(renderer)).append("String_Node_Str");
  }
 else {
    builder.append(getRight().toFormula(renderer));
  }
  return builder.toString();
}

Fixed version (ground truth):
@Override public StringBuilder toFormula(StringBuilder builder,VariableRenderer renderer){
  if (getLeft() instanceof BinaryOperator) {
    builder.append("String_Node_Str");
    getLeft().toFormula(builder,renderer).append("String_Node_Str");
  }
 else {
    getLeft().toFormula(builder,renderer);
  }
  builder.append("String_Node_Str").append(getSymbol()).append("String_Node_Str");
  if (getRight() instanceof BinaryOperator) {
    builder.append("String_Node_Str");
    getRight().toFormula(builder,renderer).append("String_Node_Str");
  }
 else {
    getRight().toFormula(builder,renderer);
  }
  return builder;
}
Program: 180309
Project: 180309
Buggy source:
String toFormula(VariableRenderer renderer);

Fixed version (ground truth):
StringBuilder toFormula(StringBuilder builder,VariableRenderer renderer);
Program: 180310
Project: 180310
Buggy source:
@Override public String toFormula(VariableRenderer renderer){
  return "String_Node_Str" + expression.toFormula(renderer) + "String_Node_Str";
}

Fixed version (ground truth):
@Override public StringBuilder toFormula(StringBuilder builder,VariableRenderer renderer){
  builder.append("String_Node_Str");
  return expression.toFormula(builder,renderer).append("String_Node_Str");
}
Program: 180311
Project: 180311
Buggy source:
@Override public Parameter substitute(Collection<SubstitutionValue> substitutionValues){
  int indexBefore=0;
  SubstitutionValue toSubstitute=null;
  for (  SubstitutionValue v : substitutionValues) {
    if (!(v instanceof ParameterValue)) {
      if (v.getExpression() instanceof Indexable && ((Indexable)v.getExpression()).getIndex() < index) {
        indexBefore++;
      }
      continue;
    }
    ParameterValue paramValue=(ParameterValue)v;
    if (paramValue.getExpression().equals(this)) {
      toSubstitute=paramValue;
    }
    if (paramValue.getExpression().getIndex() < index) {
      indexBefore++;
    }
  }
  if (toSubstitute != null) {
    return new Parameter(name,index - indexBefore,originalIndex,toSubstitute);
  }
 else   if (indexBefore != 0) {
    if (this.substitution == null) {
      return new Parameter(name,index - indexBefore,originalIndex);
    }
 else {
      return new Parameter(name,index - indexBefore,originalIndex,substitution);
    }
  }
 else {
    return this;
  }
}

Fixed version (ground truth):
@Override public Parameter substitute(Collection<SubstitutionValue> substitutionValues){
  int indexBefore=0;
  SubstitutionValue toSubstitute=null;
  for (  SubstitutionValue v : substitutionValues) {
    if (v.getExpression() instanceof Indexable && ((Indexable)v.getExpression()).getOriginalIndex() < originalIndex) {
      indexBefore++;
    }
    if (v.getExpression().equals(this)) {
      toSubstitute=(ParameterValue)v;
    }
  }
  if (toSubstitute != null) {
    return new Parameter(name,index - indexBefore,originalIndex,toSubstitute);
  }
 else   if (indexBefore != 0) {
    if (this.substitution == null) {
      return new Parameter(name,index - indexBefore,originalIndex);
    }
 else {
      return new Parameter(name,index - indexBefore,originalIndex,substitution);
    }
  }
 else {
    return this;
  }
}
Program: 180312
Project: 180312
Buggy source:
@Override public String toFormula(VariableRenderer renderer){
  return substitution == null ? name : (substitution.getValue() >= 0 ? Float.toString(substitution.getValue()) : "String_Node_Str" + Float.toString(substitution.getValue()) + "String_Node_Str");
}

Fixed version (ground truth):
@Override public StringBuilder toFormula(StringBuilder builder,VariableRenderer renderer){
  return toFormula(builder);
}