nus-yam/ex-repair huggingface dataset:
Program: 90781
Project: 90781
Buggy source:
public void setParameters(Map parameters){
  if (parameters == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  for (Iterator iter=parameters.entrySet().iterator(); iter.hasNext(); ) {
    Map.Entry entry=(Map.Entry)iter.next();
    if (!(entry.getKey() instanceof String)) {
      throw new IllegalArgumentException("String_Node_Str");
    }
    if (!(entry.getValue() instanceof String[])) {
      throw new IllegalArgumentException("String_Node_Str");
    }
  }
  this.parameters=new HashMap(parameters);
}

Fixed version (ground truth):
public void setParameters(Map parameters){
  if (parameters == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  for (Iterator iter=parameters.entrySet().iterator(); iter.hasNext(); ) {
    Map.Entry entry=(Map.Entry)iter.next();
    if (!(entry.getKey() instanceof String)) {
      throw new IllegalArgumentException("String_Node_Str");
    }
    if (!(entry.getValue() instanceof String[])) {
      throw new IllegalArgumentException("String_Node_Str");
    }
  }
  this.parameters=StringUtils.copyParameters(parameters);
}
Program: 90782
Project: 90782
Buggy source:
public void setParameter(String name,String[] values){
  if (name == null || values == null || values.length == 0) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  parameters.put(name,values);
}

Fixed version (ground truth):
public void setParameter(String name,String[] values){
  if (name == null || values == null || values.length == 0) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  parameters.put(name,StringUtils.copy(values));
}
Program: 90783
Project: 90783
Buggy source:
private boolean isValidContentType(String type){
  return true;
}

Fixed version (ground truth):
private boolean isValidContentType(String type){
  type=stripCharacterEncoding(type);
  String wildcard=null;
  int index=type.indexOf("String_Node_Str");
  if (index > -1) {
    wildcard=type.substring(0,index);
  }
  PortletEntity entity=portletWindow.getPortletEntity();
  PortletDefinition def=entity.getPortletDefinition();
  ContentTypeSet contentTypes=def.getContentTypeSet();
  Iterator it=contentTypes.iterator();
  while (it.hasNext()) {
    ContentType ct=(ContentType)it.next();
    if (ct.getContentType().equals(type)) {
      return true;
    }
 else     if (ct.getContentType().equals(wildcard)) {
      return true;
    }
  }
  return false;
}
Program: 90785
Project: 90785
Buggy source:
public void doGet(HttpServletRequest servletRequest,HttpServletResponse servletResponse) throws IOException, ServletException {
  servletResponse.setContentType("String_Node_Str");
  PortalEnvironment env=new PortalEnvironment(servletRequest,servletResponse,getServletConfig());
  PortalURL currentURL=env.getRequestedPortalURL();
  PortalControlParameter control=new PortalControlParameter(currentURL);
  PortletWindow actionWindow=control.getPortletWindowOfAction();
  if (actionWindow != null) {
    try {
      PortletContainerFactory.getPortletContainer().processPortletAction(actionWindow,ServletObjectAccess.getServletRequest(servletRequest,actionWindow),ServletObjectAccess.getServletResponse(servletResponse));
    }
 catch (    PortletException e) {
      e.printStackTrace(System.err);
    }
catch (    PortletContainerException e) {
      e.printStackTrace(System.err);
    }
catch (    Exception e) {
      e.printStackTrace(System.err);
    }
    return;
  }
  try {
    RootFragment root=PageRegistry.getRootFragment();
    root.service(servletRequest,servletResponse);
  }
 catch (  Throwable t) {
    ;
  }
 finally {
  }
}

Fixed version (ground truth):
public void doGet(HttpServletRequest servletRequest,HttpServletResponse servletResponse) throws IOException, ServletException {
  servletResponse.setContentType(CONTENT_TYPE);
  PortalEnvironment env=new PortalEnvironment(servletRequest,servletResponse,getServletConfig());
  PortalURL currentURL=env.getRequestedPortalURL();
  PortalControlParameter control=new PortalControlParameter(currentURL);
  PortletWindow actionWindow=control.getPortletWindowOfAction();
  if (actionWindow != null) {
    try {
      PortletContainerFactory.getPortletContainer().processPortletAction(actionWindow,ServletObjectAccess.getServletRequest(servletRequest,actionWindow),ServletObjectAccess.getServletResponse(servletResponse));
    }
 catch (    PortletException e) {
      e.printStackTrace(System.err);
    }
catch (    PortletContainerException e) {
      e.printStackTrace(System.err);
    }
catch (    Exception e) {
      e.printStackTrace(System.err);
    }
    return;
  }
  try {
    RootFragment root=PageRegistry.getRootFragment();
    root.service(servletRequest,servletResponse);
  }
 catch (  Throwable t) {
    ;
  }
 finally {
  }
}
Program: 90787
Project: 90787
Buggy source:
public void postLoad(Object parameter) throws Exception {
  locales.addAll((Collection)parameter);
  initInlinedInfos();
}

Fixed version (ground truth):
public void postLoad(Object parameter) throws Exception {
  locales.addAll((Collection)parameter);
  initInlinedInfos();
  if (resources != null)   initResourceBundle();
}
Program: 90789
Project: 90789
Buggy source:
public void addProperty(String key,String value){
  if (key == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  Map map=PropertyManager.getRequestProperties(portletWindow,this.getHttpServletRequest());
  if (map == null) {
    map=new HashMap();
  }
  String[] properties=(String[])map.get(key);
  if (properties == null) {
    properties=new String[]{value};
  }
 else {
    properties[properties.length]=value;
  }
  map.put(key,properties);
  PropertyManager.setResponseProperties(portletWindow,this.getHttpServletRequest(),_getHttpServletResponse(),map);
}

Fixed version (ground truth):
public void addProperty(String key,String value){
  if (key == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  Map props=getProperties();
  String[] oldValues=(String[])props.get(key);
  String[] newValues=null;
  if (oldValues == null) {
    newValues=new String[]{value};
  }
 else {
    int len=oldValues.length;
    newValues=new String[len + 1];
    System.arraycopy(oldValues,0,newValues,0,len);
    newValues[len]=value;
  }
  props.put(key,newValues);
  PropertyManager.setResponseProperties(portletWindow,this.getHttpServletRequest(),_getHttpServletResponse(),props);
}
Program: 90790
Project: 90790
Buggy source:
public void setProperty(String key,String value){
  if (key == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  Map map=PropertyManager.getRequestProperties(portletWindow,this.getHttpServletRequest());
  if (map == null) {
    map=new HashMap();
  }
  String[] properties=new String[]{value};
  map.put(key,properties);
  PropertyManager.setResponseProperties(portletWindow,getHttpServletRequest(),_getHttpServletResponse(),map);
}

Fixed version (ground truth):
public void setProperty(String key,String value){
  if (key == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  Map props=getProperties();
  String[] newValues=new String[]{value};
  props.put(key,newValues);
  PropertyManager.setResponseProperties(portletWindow,this.getHttpServletRequest(),_getHttpServletResponse(),props);
}
Program: 90791
Project: 90791
Buggy source:
/** 
 * Returns the elements of this set
 * @return An iterator containg all elements
 */
public java.util.Iterator iterator(){
  return windows.entrySet().iterator();
}

Fixed version (ground truth):
/** 
 * Returns the elements of this set
 * @return An iterator containg all elements
 */
public java.util.Iterator iterator(){
  return windows.values().iterator();
}
Program: 90792
Project: 90792
Buggy source:
public String evaluateOldValue() throws ExpressionEvaluationException {
  try {
    String value=oldValueEvaluator.evaluate();
    logger.info("String_Node_Str" + expression + "String_Node_Str"+ value);
    return value;
  }
 catch (  EvaluationException e) {
    throw new ExpressionEvaluationException("String_Node_Str" + expression + "String_Node_Str",e);
  }
}

Fixed version (ground truth):
public String evaluateOldValue() throws ExpressionEvaluationException {
  try {
    String value=oldValueEvaluator.evaluate();
    logger.log(Level.INFO,"String_Node_Str",new Object[]{expression,value,value.startsWith("String_Node_Str") ? "String_Node_Str" : "String_Node_Str"});
    return value;
  }
 catch (  EvaluationException e) {
    throw new ExpressionEvaluationException("String_Node_Str" + expression + "String_Node_Str",e);
  }
}
Program: 90793
Project: 90793
Buggy source:
public String evaluateValue() throws ExpressionEvaluationException {
  try {
    String value=valueEvaluator.evaluate();
    logger.info("String_Node_Str" + expression + "String_Node_Str"+ value);
    return value;
  }
 catch (  EvaluationException e) {
    throw new ExpressionEvaluationException("String_Node_Str" + expression + "String_Node_Str",e);
  }
}

Fixed version (ground truth):
public String evaluateValue() throws ExpressionEvaluationException {
  try {
    String value=valueEvaluator.evaluate();
    logger.log(Level.INFO,"String_Node_Str",new Object[]{expression,value,value.startsWith("String_Node_Str") ? "String_Node_Str" : "String_Node_Str"});
    return value;
  }
 catch (  EvaluationException e) {
    throw new ExpressionEvaluationException("String_Node_Str" + expression + "String_Node_Str",e);
  }
}
Program: 90794
Project: 90794
Buggy source:
public Object evaluateOldValue() throws ExpressionEvaluationException {
  try {
    FunctionElementArgument<?> evaluate=this.oldEval.evaluate();
    logger.info("String_Node_Str" + expression + "String_Node_Str"+ evaluate.getValue());
    return evaluate.getValue();
  }
 catch (  RuntimeException e) {
    throw new ExpressionEvaluationException("String_Node_Str" + expression + "String_Node_Str",e);
  }
}

Fixed version (ground truth):
public Object evaluateOldValue() throws ExpressionEvaluationException {
  try {
    FunctionElementArgument<?> evaluate=this.oldEval.evaluate();
    logger.log(Level.INFO,"String_Node_Str",new Object[]{expression,evaluate.getValue(),evaluate.getType()});
    return evaluate.getValue();
  }
 catch (  RuntimeException e) {
    throw new ExpressionEvaluationException("String_Node_Str" + expression + "String_Node_Str",e);
  }
}
Program: 90795
Project: 90795
Buggy source:
public Object evaluateValue() throws ExpressionEvaluationException {
  try {
    FunctionElementArgument<?> evaluate=this.newEval.evaluate();
    logger.info("String_Node_Str" + expression + "String_Node_Str"+ evaluate.getValue());
    return evaluate.getValue();
  }
 catch (  RuntimeException e) {
    throw new ExpressionEvaluationException("String_Node_Str" + expression + "String_Node_Str",e);
  }
}

Fixed version (ground truth):
public Object evaluateValue() throws ExpressionEvaluationException {
  try {
    FunctionElementArgument<?> evaluate=this.newEval.evaluate();
    logger.log(Level.INFO,"String_Node_Str",new Object[]{expression,evaluate.getValue(),evaluate.getType()});
    return evaluate.getValue();
  }
 catch (  RuntimeException e) {
    throw new ExpressionEvaluationException("String_Node_Str" + expression + "String_Node_Str",e);
  }
}
Program: 90796
Project: 90796
Buggy source:
@Override public Object getValue() throws ExpressionEvaluationException {
  try {
    return this.expression.evaluateValue();
  }
 catch (  Exception e) {
    logger.log(Level.SEVERE,"String_Node_Str" + expression.getExpression(),e);
    throw new ExpressionEvaluationException(e);
  }
}

Fixed version (ground truth):
@Override public Object getValue() throws ExpressionEvaluationException {
  try {
    return doCast(this.expression.evaluateValue());
  }
 catch (  Exception e) {
    logger.log(Level.SEVERE,"String_Node_Str" + expression.getExpression(),e);
    throw new ExpressionEvaluationException(e);
  }
}
Program: 90797
Project: 90797
Buggy source:
@Override public Object getOldValue() throws ExpressionEvaluationException {
  try {
    return this.expression.evaluateOldValue();
  }
 catch (  Exception e) {
    logger.log(Level.SEVERE,"String_Node_Str" + expression.getExpression(),e);
    throw new ExpressionEvaluationException(e);
  }
}

Fixed version (ground truth):
@Override public Object getOldValue() throws ExpressionEvaluationException {
  try {
    return doCast(this.expression.evaluateOldValue());
  }
 catch (  Exception e) {
    logger.log(Level.SEVERE,"String_Node_Str" + expression.getExpression(),e);
    throw new ExpressionEvaluationException(e);
  }
}
Program: 90798
Project: 90798
Buggy source:
@Override protected FunctionElementArgument<String> execute(FunctionElementArgument<String> a,FunctionElementArgument<String> b) throws IllegalArgumentException {
  SimpleDateFormat dateFormat=new SimpleDateFormat("String_Node_Str");
  Date d=null;
  try {
    d=dateFormat.parse(b.getValue());
  }
 catch (  ParseException e) {
    throw new IllegalArgumentException(e);
  }
  Long date=d.getTime();
  Calendar calendar=Calendar.getInstance();
  calendar.setTimeInMillis(date);
  int year=calendar.get(Calendar.YEAR);
  int month=calendar.get(Calendar.MONTH);
  calendar.clear();
  calendar.set(Calendar.YEAR,year);
  if (a.getValue().equalsIgnoreCase(MODE_MONTH)) {
    calendar.set(Calendar.MONTH,month);
  }
  date=calendar.getTimeInMillis();
  return FunctionArgumentFactory.createString(date.toString());
}

Fixed version (ground truth):
@Override protected FunctionElementArgument<Date> execute(FunctionElementArgument<String> a,FunctionElementArgument<Date> b) throws IllegalArgumentException {
  Long date=b.getValue().getTime();
  Calendar calendar=Calendar.getInstance();
  calendar.setTimeInMillis(date);
  int year=calendar.get(Calendar.YEAR);
  int month=calendar.get(Calendar.MONTH);
  calendar.clear();
  calendar.set(Calendar.YEAR,year);
  if (a.getValue().equalsIgnoreCase(MODE_MONTH)) {
    calendar.set(Calendar.MONTH,month);
  }
  date=calendar.getTimeInMillis();
  return FunctionArgumentFactory.createObject(new Date(date));
}
Program: 90799
Project: 90799
Buggy source:
private FunctionElementArgument<?> replaceVariable(Object value){
  if (value instanceof Integer) {
    return FunctionArgumentFactory.createObject((Integer)value);
  }
  if (value instanceof Double) {
    return FunctionArgumentFactory.createObject((Double)value);
  }
  if (value instanceof String) {
    return FunctionArgumentFactory.createString((String)value);
  }
  if (value instanceof Boolean) {
    return FunctionArgumentFactory.createObject((Boolean)value);
  }
  if (value instanceof Object) {
    return FunctionArgumentFactory.createObject(value);
  }
  return new NullArgument();
}

Fixed version (ground truth):
private FunctionElementArgument<?> replaceVariable(Object value){
  if (value instanceof Integer) {
    return FunctionArgumentFactory.createObject((Integer)value);
  }
  if (value instanceof Double) {
    return FunctionArgumentFactory.createObject((Double)value);
  }
  if (value instanceof Long) {
    return FunctionArgumentFactory.createObject((Long)value);
  }
  if (value instanceof Date) {
    return FunctionArgumentFactory.createObject((Date)value);
  }
  if (value instanceof String) {
    return FunctionArgumentFactory.createString((String)value);
  }
  if (value instanceof Boolean) {
    return FunctionArgumentFactory.createObject((Boolean)value);
  }
  if (value instanceof Object) {
    return FunctionArgumentFactory.createObject(value);
  }
  return new NullArgument();
}
Program: 90801
Project: 90801
Buggy source:
public Evaluator(){
  this.variables=new HashMap<String,Variable>();
  this.expression=null;
}

Fixed version (ground truth):
public Evaluator(){
  this.boundVariables=new HashMap<String,Variable>();
  this.functions=new HashMap<String,Function>();
  this.huntingYardParser=null;
  this.expression=null;
}
Program: 90802
Project: 90802
Buggy source:
public void bindVariable(Variable variable){
  variables.put(variable.getName(),variable);
}

Fixed version (ground truth):
public void bindVariable(Variable variable){
  boundVariables.put(variable.getName(),variable);
}
Program: 90803
Project: 90803
Buggy source:
BooleanArgument(Boolean booleanValue){
  this.booleanValue=booleanValue;
}

Fixed version (ground truth):
public BooleanArgument(Boolean booleanValue){
  this.booleanValue=booleanValue;
}
Program: 90804
Project: 90804
Buggy source:
protected ObjectArgument(Object objectValue){
  super();
  this.objectValue=objectValue;
}

Fixed version (ground truth):
ObjectArgument(Object objectValue){
  super();
  this.objectValue=objectValue;
}
Program: 90805
Project: 90805
Buggy source:
@Override public Object getValue(){
  return value;
}

Fixed version (ground truth):
@Override public Object getValue(){
  throw new NotImplementedException();
}
Program: 90806
Project: 90806
Buggy source:
@Override public ArgumentType getType(){
  if (value instanceof Integer) {
    return ArgumentType.INTEGER;
  }
  if (value instanceof Double) {
    return ArgumentType.DOUBLE;
  }
  if (value instanceof String) {
    return ArgumentType.STRING;
  }
  if (value instanceof Object) {
    return ArgumentType.OBJECT;
  }
  if (value instanceof Boolean) {
    return ArgumentType.BOOLEAN;
  }
  return ArgumentType.NULL;
}

Fixed version (ground truth):
@Override public ArgumentType getType(){
  throw new NotImplementedException();
}
Program: 90807
Project: 90807
Buggy source:
VariableArgument(String variableName){
  super();
  this.variableName=variableName;
}

Fixed version (ground truth):
public VariableArgument(String variableName){
  super();
  this.variableName=variableName;
}
Program: 90808
Project: 90808
Buggy source:
private String exportJsonDataSource() throws Exception {
  return getExporter(DESIGN_REPORT_JSON,"String_Node_Str","String_Node_Str").addSubreport("String_Node_Str","String_Node_Str").addJSONParams("String_Node_Str","String_Node_Str",Locale.ENGLISH,Locale.US).exportPdf();
}

Fixed version (ground truth):
private String exportJsonDataSource() throws Exception {
  return getExporter(DESIGN_REPORT_JSON,"String_Node_Str","String_Node_Str").addSubreport("String_Node_Str","String_Node_Str").addJSONParams("String_Node_Str","String_Node_Str",Locale.ENGLISH,Locale.US).setJsonSource().exportPdf();
}
Program: 90809
Project: 90809
Buggy source:
@Test public void exportJsonDataSource() throws Exception {
  getExporter(DESIGN_REPORT_JSON_CUSTOMERS,"String_Node_Str","String_Node_Str").addSubreport("String_Node_Str","String_Node_Str").addJSONParams("String_Node_Str","String_Node_Str",Locale.ENGLISH,Locale.US).exportPdf();
}

Fixed version (ground truth):
@Test public void exportJsonDataSource() throws Exception {
  getExporter(DESIGN_REPORT_JSON_CUSTOMERS,"String_Node_Str","String_Node_Str").addSubreport("String_Node_Str","String_Node_Str").addJSONParams("String_Node_Str","String_Node_Str",Locale.ENGLISH,Locale.US).setJsonSource().exportPdf();
}
Program: 90810
Project: 90810
Buggy source:
@Override public FunctionResult execute(Evaluator evaluator,String arguments) throws FunctionException {
  Object[] params=arguments.split("String_Node_Str");
  String text=(String)params[0];
  text=text.substring(1,text.length() - 2);
  Object[] args=Arrays.copyOfRange(params,1,params.length);
  String result=MessageFormat.format(text,args);
  return new FunctionResult(result,FunctionConstants.FUNCTION_RESULT_TYPE_STRING);
}

Fixed version (ground truth):
@Override public FunctionResult execute(Evaluator evaluator,String arguments) throws FunctionException {
  Object[] params=arguments.split("String_Node_Str");
  String text=(String)params[0];
  if (text.length() == 2) {
    text="String_Node_Str";
  }
 else {
    text=text.substring(1,text.length() - 2);
  }
  Object[] args=Arrays.copyOfRange(params,1,params.length);
  String result=MessageFormat.format(text,args);
  return new FunctionResult(result,FunctionConstants.FUNCTION_RESULT_TYPE_STRING);
}
Program: 90811
Project: 90811
Buggy source:
private void registerPdfInternalFonts(){
  List<IFont> base14Fonts=Base14Font.getList(this);
  for (  IFont font : base14Fonts) {
    addFont(new FontKey(font),font);
  }
  Set<Entry<String,String>> fontEntrySet=Base14Font.getLogicalFontNames().entrySet();
  for (  Map.Entry<String,String> logicalFontEntry : fontEntrySet) {
    String fontName=logicalFontEntry.getValue();
    String alias=logicalFontEntry.getKey();
    addFontAlias(fontName,alias,FontStyle.PLAIN);
    addFontAlias(fontName,alias,FontStyle.BOLD);
    addFontAlias(fontName,alias,FontStyle.OBLIQUE);
    addFontAlias(fontName,alias,FontStyle.BOLD_OBLIQUE);
  }
}

Fixed version (ground truth):
private void registerPdfInternalFonts(){
  List<IFont> base14Fonts=Base14Font.getList(this);
  for (  IFont font : base14Fonts) {
    addFont(new FontKey(font),font);
  }
  Map<String,String> fontsByName=Base14Font.getLogicalFontNames();
  for (  Map.Entry<String,String> logicalFontEntry : fontsByName.entrySet()) {
    String fontName=logicalFontEntry.getValue();
    String alias=logicalFontEntry.getKey();
    addFontAlias(fontName,alias,FontStyle.PLAIN);
    addFontAlias(fontName,alias,FontStyle.BOLD);
    addFontAlias(fontName,alias,FontStyle.OBLIQUE);
    addFontAlias(fontName,alias,FontStyle.BOLD_OBLIQUE);
  }
}
Program: 90812
Project: 90812
Buggy source:
public static <V extends Vertex<E> & HasTimepoint,E extends Edge<V>>void installActionBindings(final Behaviours behaviours,final TrackSchemePanel panel){
  final TrackSchemeZoom<V,E> zoom=new TrackSchemeZoom<>(panel);
  zoom.transformChanged(panel.getDisplay().getTransformEventHandler().getTransform());
  zoom.updateHeadersVisibility(panel.getOffsetDecorations().isVisibleX(),panel.getOffsetDecorations().getWidth(),panel.getOffsetDecorations().isVisibleY(),panel.getOffsetDecorations().getHeight());
  panel.getDisplay().addOverlayRenderer(zoom.overlay);
  panel.getDisplay().addTransformListener(zoom);
  panel.getOffsetDecorations().addOffsetHeadersListener(zoom);
  behaviours.namedBehaviour(zoom,TOGGLE_ZOOM_KEYS);
}

Fixed version (ground truth):
public static <V extends Vertex<E> & HasTimepoint,E extends Edge<V>>void installActionBindings(final Behaviours behaviours,final TrackSchemePanel panel){
  final TrackSchemeZoom<V,E> zoom=new TrackSchemeZoom<>(panel);
  zoom.transformChanged(panel.getDisplay().getTransformEventHandler().getTransform());
  zoom.updateHeaderSize(panel.getOffsetHeaders().getWidth(),panel.getOffsetHeaders().getHeight());
  panel.getDisplay().addOverlayRenderer(zoom.overlay);
  panel.getDisplay().addTransformListener(zoom);
  panel.getOffsetHeaders().listeners().add(zoom);
  behaviours.namedBehaviour(zoom,TOGGLE_ZOOM_KEYS);
}
Program: 90813
Project: 90813
Buggy source:
@Override public void click(final int x,final int y){
  final V ref=overlayGraph.vertexRef();
  lock.readLock().lock();
  try {
    final V vertex=renderer.getVertexAt(x,y,POINT_SELECT_DISTANCE_TOLERANCE,ref);
    if (vertex != null) {
      vertex.getCovariance(mat);
      LinAlgHelpers.scale(mat,1 + factor,mat);
      eig.decomposeSymmetric(mat);
      final double[] eigVals=eig.getRealEigenvalues();
      for (      final double eigVal : eigVals)       if (eigVal < MIN_RADIUS)       return;
      vertex.setCovariance(mat);
      lastRadius=Math.max(MIN_RADIUS,vertex.getBoundingSphereRadiusSquared());
      overlayGraph.notifyGraphChanged();
      undo.setUndoPoint();
    }
  }
  finally {
    lock.readLock().unlock();
    overlayGraph.releaseRef(ref);
  }
}

Fixed version (ground truth):
@Override public void click(final int x,final int y){
  final V ref=overlayGraph.vertexRef();
  lock.readLock().lock();
  try {
    final V vertex=renderer.getVertexAt(x,y,POINT_SELECT_DISTANCE_TOLERANCE,ref);
    if (vertex != null) {
      vertex.getCovariance(mat);
      LinAlgHelpers.scale(mat,1 + factor,mat);
      eig.decomposeSymmetric(mat);
      final double[] eigVals=eig.getRealEigenvalues();
      for (      final double eigVal : eigVals)       if (eigVal < MIN_RADIUS)       return;
      vertex.setCovariance(mat);
      lastRadius=Math.max(MIN_RADIUS,Math.sqrt(vertex.getBoundingSphereRadiusSquared()));
      overlayGraph.notifyGraphChanged();
      undo.setUndoPoint();
    }
  }
  finally {
    lock.readLock().unlock();
    overlayGraph.releaseRef(ref);
  }
}
Program: 90815
Project: 90815
Buggy source:
@Override public void run(){
  if (mode != Mode.INACTIVE)   return;
  inputMap.clear();
  actionMap.clear();
  final KeyStroke abortKey=KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE,0);
  final Action abortAction=new AbstractAction("String_Node_Str"){
    @Override public void actionPerformed(    final ActionEvent e){
      abort();
    }
    private static final long serialVersionUID=1L;
  }
;
  inputMap.put(abortKey,"String_Node_Str");
  actionMap.put("String_Node_Str",abortAction);
  int i=1;
  for (  final TagSet tagSet : tagModel.getTagSetStructure().getTagSets()) {
    final String actionName="String_Node_Str" + i;
    final KeyStroke tagKeyStroke=KeyStroke.getKeyStroke((char)('0' + i));
    final AbstractAction action=new AbstractAction(actionName){
      @Override public void actionPerformed(      final ActionEvent e){
        selectTagSet(tagSet);
      }
      private static final long serialVersionUID=1L;
    }
;
    inputMap.put(tagKeyStroke,actionName);
    actionMap.put(actionName,action);
    i++;
  }
  bindings.addInputMap("String_Node_Str",inputMap);
  bindings.addActionMap("String_Node_Str",actionMap);
  mode=Mode.PICK_TAGSET;
  renderer.addOverlayRenderer(overlay);
  panel.repaint();
}

Fixed version (ground truth):
@Override public void run(){
  if (mode != Mode.INACTIVE)   return;
  inputMap.clear();
  actionMap.clear();
  final KeyStroke abortKey=KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE,0);
  final Action abortAction=new AbstractAction("String_Node_Str"){
    @Override public void actionPerformed(    final ActionEvent e){
      abort();
    }
    private static final long serialVersionUID=1L;
  }
;
  inputMap.put(abortKey,"String_Node_Str");
  actionMap.put("String_Node_Str",abortAction);
  int i=1;
  for (  final TagSet tagSet : tagModel.getTagSetStructure().getTagSets()) {
    final String actionName="String_Node_Str" + i;
    final KeyStroke tagKeyStroke=KeyStroke.getKeyStroke((char)('0' + i));
    final AbstractAction action=new AbstractAction(actionName){
      @Override public void actionPerformed(      final ActionEvent e){
        selectTagSet(tagSet);
      }
      private static final long serialVersionUID=1L;
    }
;
    inputMap.put(tagKeyStroke,actionName);
    actionMap.put(actionName,action);
    i++;
  }
  bindings.addInputMap(PICK_TAGS_MAP,inputMap);
  bindings.addActionMap(PICK_TAGS_MAP,actionMap);
  mode=Mode.PICK_TAGSET;
  renderer.addOverlayRenderer(overlay);
  panel.repaint();
}
Program: 90817
Project: 90817
Buggy source:
private synchronized void done(){
  mode=Mode.INACTIVE;
  bindings.removeActionMap(PICK_TAGS);
  bindings.removeInputMap(PICK_TAGS);
  renderer.removeOverlayRenderer(overlay);
  panel.repaint();
}

Fixed version (ground truth):
private synchronized void done(){
  mode=Mode.INACTIVE;
  bindings.removeActionMap(PICK_TAGS_MAP);
  bindings.removeInputMap(PICK_TAGS_MAP);
  renderer.removeOverlayRenderer(overlay);
  panel.repaint();
}
Program: 90818
Project: 90818
Buggy source:
public TagSetDialog(final Frame owner,final TagSetManager manager){
  super(owner,"String_Node_Str",false);
  this.manager=manager;
  tagSetPanel=new TagSetPanel();
  tagSetPanel.setTagSetStructure(manager.getTagSetStructure());
  final SimpleSettingsPage page=new SimpleSettingsPage("String_Node_Str",tagSetPanel);
  tagSetPanel.updateListeners().add(() -> page.notifyModified());
  page.onApply(() -> manager.setTagSetStructure(tagSetPanel.getTagSetStructure()));
  page.onCancel(() -> tagSetPanel.setTagSetStructure(manager.getTagSetStructure()));
  final SingleSettingsPanel settingsPanel=new SingleSettingsPanel(page);
  settingsPanel.onOk(() -> setVisible(false));
  settingsPanel.onCancel(() -> setVisible(false));
  setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);
  addWindowListener(new WindowAdapter(){
    @Override public void windowClosing(    final WindowEvent e){
      settingsPanel.cancel();
    }
  }
);
  getContentPane().add(settingsPanel,BorderLayout.CENTER);
  pack();
}

Fixed version (ground truth):
public TagSetDialog(final Frame owner,final TagSetManager manager){
  super(owner,"String_Node_Str",false);
  this.manager=manager;
  tagSetPanel=new TagSetPanel();
  tagSetPanel.setTagSetStructure(manager.getTagSetStructure());
  final SimpleSettingsPage page=new SimpleSettingsPage("String_Node_Str",tagSetPanel);
  tagSetPanel.updateListeners().add(() -> page.notifyModified());
  page.onApply(() -> {
    tagSetPanel.stopEditing();
    manager.setTagSetStructure(tagSetPanel.getTagSetStructure());
  }
);
  page.onCancel(() -> {
    tagSetPanel.cancelEditing();
    tagSetPanel.setTagSetStructure(manager.getTagSetStructure());
  }
);
  final SingleSettingsPanel settingsPanel=new SingleSettingsPanel(page);
  settingsPanel.onOk(() -> setVisible(false));
  settingsPanel.onCancel(() -> setVisible(false));
  setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);
  addWindowListener(new WindowAdapter(){
    @Override public void windowClosing(    final WindowEvent e){
      settingsPanel.cancel();
    }
  }
);
  getContentPane().add(settingsPanel,BorderLayout.CENTER);
  pack();
}
Program: 90819
Project: 90819
Buggy source:
public TagSetPanel(final TagSetStructure tagSetStructure){
  super(new BorderLayout(0,0));
  this.tagSetStructure=tagSetStructure;
  updateListeners=new Listeners.SynchronizedList<>();
  tagSetTable=new TagTable<>(tagSetStructure,tss -> tss.createTagSet(makeNewName("String_Node_Str")),tss -> tss.getTagSets().size(),TagSetStructure::remove,(tss,i) -> tss.getTagSets().get(i),TagSet::setName,TagSet::getName);
  final ColorTagTable<TagSet,Tag> tagTable=new ColorTagTable<>(null,ts -> ts.createTag("String_Node_Str",colorGenerator.next()),ts -> ts.getTags().size(),TagSet::removeTag,(ts,i) -> ts.getTags().get(i),Tag::setLabel,Tag::label,(t,color) -> t.setColor(color.getRGB()),t -> new Color(t.color(),true));
  tagSetTable.updateListeners().add(this::notifyListeners);
  tagTable.updateListeners().add(this::notifyListeners);
  tagSetTable.selectionListeners().add(tagTable::setElements);
  final JSplitPane splitPane=new JSplitPane(JSplitPane.HORIZONTAL_SPLIT,tagSetTable.getTable(),tagTable.getTable());
  splitPane.setResizeWeight(0);
  splitPane.setContinuousLayout(true);
  splitPane.setDividerSize(10);
  splitPane.setDividerLocation(300);
  splitPane.setBorder(new MatteBorder(0,0,1,0,Color.LIGHT_GRAY));
  this.add(splitPane,BorderLayout.CENTER);
}

Fixed version (ground truth):
public TagSetPanel(final TagSetStructure tagSetStructure){
  super(new BorderLayout(0,0));
  this.tagSetStructure=tagSetStructure;
  updateListeners=new Listeners.SynchronizedList<>();
  tagSetTable=new TagTable<>(tagSetStructure,tss -> tss.createTagSet(makeNewName("String_Node_Str")),tss -> tss.getTagSets().size(),TagSetStructure::remove,(tss,i) -> tss.getTagSets().get(i),TagSet::setName,TagSet::getName);
  tagTable=new ColorTagTable<>(null,ts -> ts.createTag("String_Node_Str",colorGenerator.next()),ts -> ts.getTags().size(),TagSet::removeTag,(ts,i) -> ts.getTags().get(i),Tag::setLabel,Tag::label,(t,color) -> t.setColor(color.getRGB()),t -> new Color(t.color(),true));
  tagSetTable.updateListeners().add(this::notifyListeners);
  tagTable.updateListeners().add(this::notifyListeners);
  tagSetTable.selectionListeners().add(tagTable::setElements);
  final JSplitPane splitPane=new JSplitPane(JSplitPane.HORIZONTAL_SPLIT,tagSetTable.getTable(),tagTable.getTable());
  splitPane.setResizeWeight(0);
  splitPane.setContinuousLayout(true);
  splitPane.setDividerSize(10);
  splitPane.setDividerLocation(300);
  splitPane.setBorder(new MatteBorder(0,0,1,0,Color.LIGHT_GRAY));
  this.add(splitPane,BorderLayout.CENTER);
}
Program: 90820
Project: 90820
Buggy source:
@Override public void setTagSetStructure(final TagSetStructure tss){
  final Set<Integer> removedIds=tagSetStructure.getTagSets().stream().flatMap(ts -> ts.getTags().stream()).map(Tag::id).collect(Collectors.toSet());
  final Set<Integer> newIds=tss.getTagSets().stream().flatMap(ts -> ts.getTags().stream()).map(Tag::id).collect(Collectors.toSet());
  removedIds.removeAll(newIds);
  final LabelSet<V,Integer> vref=vertexIdLabelSets.createRef();
  for (  final Integer id : removedIds) {
    final RefSet<V> labeledWithId=RefCollections.createRefSet(graph.vertices());
    labeledWithId.addAll(vertexIdLabelSets.getLabeledWith(id));
    labeledWithId.forEach(v -> vertexIdLabelSets.getLabels(v,vref).remove(id));
  }
  vertexIdLabelSets.releaseRef(vref);
  final LabelSet<E,Integer> eref=edgeIdLabelSets.createRef();
  for (  final Integer id : removedIds) {
    final RefSet<E> labeledWithId=RefCollections.createRefSet(graph.edges());
    labeledWithId.addAll(edgeIdLabelSets.getLabeledWith(id));
    labeledWithId.forEach(e -> edgeIdLabelSets.getLabels(e,eref).remove(id));
  }
  edgeIdLabelSets.releaseRef(eref);
  if (editRecorder != null) {
    editRecorder.record(new SetTagSetStructureUndoableEdit(this,tagSetStructure,tss));
  }
  tagSetStructure.set(tss);
  listeners.list.forEach(TagSetModelListener::tagSetStructureChanged);
  vertexTags.update(tagSetStructure);
  edgeTags.update(tagSetStructure);
}

Fixed version (ground truth):
@Override public void setTagSetStructure(final TagSetStructure tss){
  final Set<Integer> removedIds=tagSetStructure.getTagSets().stream().flatMap(ts -> ts.getTags().stream()).map(Tag::id).collect(Collectors.toSet());
  final Set<Integer> newIds=tss.getTagSets().stream().flatMap(ts -> ts.getTags().stream()).map(Tag::id).collect(Collectors.toSet());
  removedIds.removeAll(newIds);
  final LabelSet<V,Integer> vref=vertexIdLabelSets.createRef();
  for (  final Integer id : removedIds) {
    final RefSet<V> labeledWithId=RefCollections.createRefSet(graph.vertices());
    labeledWithId.addAll(vertexIdLabelSets.getLabeledWith(id));
    labeledWithId.forEach(v -> vertexIdLabelSets.getLabels(v,vref).remove(id));
  }
  vertexIdLabelSets.releaseRef(vref);
  final LabelSet<E,Integer> eref=edgeIdLabelSets.createRef();
  for (  final Integer id : removedIds) {
    final RefSet<E> labeledWithId=RefCollections.createRefSet(graph.edges());
    labeledWithId.addAll(edgeIdLabelSets.getLabeledWith(id));
    labeledWithId.forEach(e -> edgeIdLabelSets.getLabels(e,eref).remove(id));
  }
  edgeIdLabelSets.releaseRef(eref);
  if (editRecorder != null) {
    editRecorder.record(new SetTagSetStructureUndoableEdit(this,tagSetStructure,tss));
  }
  tagSetStructure.set(tss);
  vertexTags.update(tagSetStructure);
  edgeTags.update(tagSetStructure);
  listeners.list.forEach(TagSetModelListener::tagSetStructureChanged);
}
Program: 90821
Project: 90821
Buggy source:
public synchronized void loadProject(){
  final String fn=proposedProjectFolder == null ? (project == null ? null : project.getProjectFolder().getAbsolutePath()) : proposedProjectFolder.getAbsolutePath();
  final Component parent=null;
  final File file=FileChooser.chooseFile(parent,fn,null,"String_Node_Str",FileChooser.DialogType.LOAD,SelectionMode.DIRECTORIES_ONLY);
  if (file == null)   return;
  try {
    proposedProjectFolder=file;
    final MamutProject project=new MamutProjectIO().load(file.getAbsolutePath());
    open(project);
  }
 catch (  final IOException|SpimDataException e) {
    e.printStackTrace();
  }
}

Fixed version (ground truth):
public synchronized void loadProject(){
  String fn=null;
  if (proposedProjectFolder != null)   fn=proposedProjectFolder.getAbsolutePath();
 else   if (project != null && project.getProjectFolder() != null)   fn=project.getProjectFolder().getAbsolutePath();
  final Component parent=null;
  final File file=FileChooser.chooseFile(parent,fn,null,"String_Node_Str",FileChooser.DialogType.LOAD,SelectionMode.DIRECTORIES_ONLY);
  if (file == null)   return;
  try {
    proposedProjectFolder=file;
    final MamutProject project=new MamutProjectIO().load(file.getAbsolutePath());
    open(project);
  }
 catch (  final IOException|SpimDataException e) {
    e.printStackTrace();
  }
}
Program: 90822
Project: 90822
Buggy source:
private void select(final int x,final int y,final boolean addToSelection){
  selection.pauseListeners();
  final V vertex=overlayGraph.vertexRef();
  final E edge=overlayGraph.edgeRef();
  if (renderer.getVertexAt(x,y,POINT_SELECT_DISTANCE_TOLERANCE,vertex) != null) {
    final boolean selected=selection.isSelected(vertex);
    if (!addToSelection)     selection.clearSelection();
    selection.setSelected(vertex,!selected);
  }
 else   if (renderer.getEdgeAt(x,y,EDGE_SELECT_DISTANCE_TOLERANCE,edge) != null) {
    final boolean selected=selection.isSelected(vertex);
    if (!addToSelection)     selection.clearSelection();
    selection.setSelected(edge,!selected);
  }
 else   if (!addToSelection)   selection.clearSelection();
  overlayGraph.releaseRef(vertex);
  overlayGraph.releaseRef(edge);
  selection.resumeListeners();
}

Fixed version (ground truth):
private void select(final int x,final int y,final boolean addToSelection){
  selection.pauseListeners();
  final V vertex=overlayGraph.vertexRef();
  final E edge=overlayGraph.edgeRef();
  if (renderer.getVertexAt(x,y,POINT_SELECT_DISTANCE_TOLERANCE,vertex) != null) {
    final boolean selected=selection.isSelected(vertex);
    if (!addToSelection)     selection.clearSelection();
    selection.setSelected(vertex,!selected);
  }
 else   if (renderer.getEdgeAt(x,y,EDGE_SELECT_DISTANCE_TOLERANCE,edge) != null) {
    final boolean selected=selection.isSelected(edge);
    if (!addToSelection)     selection.clearSelection();
    selection.setSelected(edge,!selected);
  }
 else   if (!addToSelection)   selection.clearSelection();
  overlayGraph.releaseRef(vertex);
  overlayGraph.releaseRef(edge);
  selection.resumeListeners();
}
Program: 90823
Project: 90823
Buggy source:
JMenu menu(final String path){
  final String[] parts=path.split("String_Node_Str");
  MenuElement root=menubar;
  for (  final String part : parts) {
    final String text=part.trim();
    JMenuItem next=null;
    for (    final MenuElement me : root.getSubElements()) {
      if (me instanceof JMenu) {
        final JMenuItem mi=(JMenuItem)me;
        if (mi.getText().equals(text)) {
          next=mi;
          break;
        }
      }
    }
    if (next == null) {
      next=new JMenu(text);
      if (root == menubar)       menubar.add(next);
 else       if (root instanceof JMenu)       ((JMenu)root).add(next);
 else       throw new IllegalArgumentException("String_Node_Str");
    }
    if (next instanceof JMenu)     root=next;
 else     throw new IllegalArgumentException("String_Node_Str");
  }
  if (root instanceof JMenu)   return (JMenu)root;
 else   throw new IllegalArgumentException("String_Node_Str");
}

Fixed version (ground truth):
JMenu menu(final String path){
  final String[] parts=path.split("String_Node_Str");
  MenuElement root=menubar;
  for (  final String part : parts) {
    final String text=part.trim();
    JMenuItem next=null;
    A:     for (    final MenuElement me : root.getSubElements()) {
      if (me instanceof JPopupMenu) {
        final JPopupMenu pm=(JPopupMenu)me;
        for (        final MenuElement pme : pm.getSubElements()) {
          if (pme instanceof JMenu) {
            final JMenuItem mi=(JMenuItem)pme;
            if (mi.getText().equals(text)) {
              next=mi;
              break A;
            }
          }
        }
      }
      if (me instanceof JMenu) {
        final JMenuItem mi=(JMenuItem)me;
        if (mi.getText().equals(text)) {
          next=mi;
          break;
        }
      }
    }
    if (next == null) {
      next=new JMenu(text);
      if (root == menubar)       menubar.add(next);
 else       if (root instanceof JMenu)       ((JMenu)root).add(next);
 else       throw new IllegalArgumentException("String_Node_Str");
    }
    if (next instanceof JMenu)     root=next;
 else     throw new IllegalArgumentException("String_Node_Str");
  }
  if (root instanceof JMenu)   return (JMenu)root;
 else   throw new IllegalArgumentException("String_Node_Str");
}
Program: 90824
Project: 90824
Buggy source:
public static void main(final String[] args) throws IOException {
  final String bdvFile="String_Node_Str";
  final String modelFile="String_Node_Str";
  final MamutProject project=new MamutProject(new File("String_Node_Str"),new File(bdvFile),new File(modelFile));
  final Model model=new Model();
  model.loadRaw(project.getRawModelFile());
  final File target=new File("String_Node_Str");
  export(target,model,project);
}

Fixed version (ground truth):
public static void main(final String[] args) throws IOException {
  final String projectFolder="String_Node_Str";
  final String bdvFile="String_Node_Str";
  final MamutProject project=new MamutProject(new File(projectFolder),new File(bdvFile));
  final Model model=new Model();
  model.loadRaw(project.getRawModelFile());
  final File target=new File("String_Node_Str");
  export(target,model,project);
}
Program: 90825
Project: 90825
Buggy source:
public static void main(final String[] args) throws IOException, JDOMException, SpimDataException {
  final String bdvFile="String_Node_Str";
  final String modelFile="String_Node_Str";
  final MamutProject project=new MamutProject(new File("String_Node_Str"),new File(bdvFile),new File(modelFile));
  final Model model=new Model();
  model.loadRaw(project.getRawModelFile());
  final Context context=new Context(MamutFeatureComputerService.class);
  final MamutFeatureComputerService featureComputerService=context.getService(MamutFeatureComputerService.class);
  final Set<FeatureComputer<Model>> featureComputers=new HashSet<>(featureComputerService.getFeatureComputers());
  final ProgressListener pl=new ProgressListener(){
    @Override public void showStatus(    final String string){
      System.out.println("String_Node_Str" + string);
    }
    @Override public void showProgress(    final int current,    final int total){
    }
    @Override public void clearStatus(){
    }
  }
;
  System.out.println("String_Node_Str");
  final boolean computed=featureComputerService.compute(model,model.getFeatureModel(),featureComputers,pl);
  if (!computed) {
    System.err.println("String_Node_Str");
    return;
  }
  final File target=new File("String_Node_Str");
  MamutExporter.export(target,model,project);
  final Model importedModel=new Model();
  TrackMateImporter.importModel(target,importedModel);
  System.out.println(MastodonUtil.dump(importedModel));
}

Fixed version (ground truth):
public static void main(final String[] args) throws IOException, JDOMException, SpimDataException {
  final String projectFolder="String_Node_Str";
  final String bdvFile="String_Node_Str";
  final MamutProject project=new MamutProject(new File(projectFolder),new File(bdvFile));
  final Model model=new Model();
  model.loadRaw(project.getRawModelFile());
  final Context context=new Context(MamutFeatureComputerService.class);
  final MamutFeatureComputerService featureComputerService=context.getService(MamutFeatureComputerService.class);
  final Set<FeatureComputer<Model>> featureComputers=new HashSet<>(featureComputerService.getFeatureComputers());
  final ProgressListener pl=new ProgressListener(){
    @Override public void showStatus(    final String string){
      System.out.println("String_Node_Str" + string);
    }
    @Override public void showProgress(    final int current,    final int total){
    }
    @Override public void clearStatus(){
    }
  }
;
  System.out.println("String_Node_Str");
  final boolean computed=featureComputerService.compute(model,model.getFeatureModel(),featureComputers,pl);
  if (!computed) {
    System.err.println("String_Node_Str");
    return;
  }
  final File target=new File("String_Node_Str");
  MamutExporter.export(target,model,project);
  final Model importedModel=new Model();
  TrackMateImporter.importModel(target,importedModel);
  System.out.println(MastodonUtil.dump(importedModel));
}
Program: 90826
Project: 90826
Buggy source:
public static void main(final String[] args) throws IOException {
  final String projectFolder="String_Node_Str";
  final String bdvFile="String_Node_Str";
  final MamutProject project=new MamutProject(new File(projectFolder),new File(bdvFile));
  final Model model=new Model();
  model.loadRaw(project.getRawModelFile());
  final File target=new File("String_Node_Str");
  export(target,model,project);
}

Fixed version (ground truth):
public static void main(final String[] args) throws IOException {
  final String projectFolder="String_Node_Str";
  final String bdvFile="String_Node_Str";
  final MamutProject project=new MamutProject(new File(projectFolder),new File(bdvFile));
  final Model model=new Model();
  model.loadRaw(project);
  final File target=new File("String_Node_Str");
  export(target,model,project);
}
Program: 90827
Project: 90827
Buggy source:
public static void main(final String[] args) throws IOException, JDOMException, SpimDataException {
  final String projectFolder="String_Node_Str";
  final String bdvFile="String_Node_Str";
  final MamutProject project=new MamutProject(new File(projectFolder),new File(bdvFile));
  final Model model=new Model();
  model.loadRaw(project.getRawModelFile());
  final Context context=new Context(MamutFeatureComputerService.class);
  final MamutFeatureComputerService featureComputerService=context.getService(MamutFeatureComputerService.class);
  final Set<FeatureComputer<Model>> featureComputers=new HashSet<>(featureComputerService.getFeatureComputers());
  final ProgressListener pl=new ProgressListener(){
    @Override public void showStatus(    final String string){
      System.out.println("String_Node_Str" + string);
    }
    @Override public void showProgress(    final int current,    final int total){
    }
    @Override public void clearStatus(){
    }
  }
;
  System.out.println("String_Node_Str");
  final boolean computed=featureComputerService.compute(model,model.getFeatureModel(),featureComputers,pl);
  if (!computed) {
    System.err.println("String_Node_Str");
    return;
  }
  final File target=new File("String_Node_Str");
  MamutExporter.export(target,model,project);
  final Model importedModel=new Model();
  TrackMateImporter.importModel(target,importedModel);
  System.out.println(MastodonUtil.dump(importedModel));
}

Fixed version (ground truth):
public static void main(final String[] args) throws IOException, JDOMException, SpimDataException {
  final String projectFolder="String_Node_Str";
  final String bdvFile="String_Node_Str";
  final MamutProject project=new MamutProject(new File(projectFolder),new File(bdvFile));
  final Model model=new Model();
  model.loadRaw(project);
  final Context context=new Context(MamutFeatureComputerService.class);
  final MamutFeatureComputerService featureComputerService=context.getService(MamutFeatureComputerService.class);
  final Set<FeatureComputer<Model>> featureComputers=new HashSet<>(featureComputerService.getFeatureComputers());
  final ProgressListener pl=new ProgressListener(){
    @Override public void showStatus(    final String string){
      System.out.println("String_Node_Str" + string);
    }
    @Override public void showProgress(    final int current,    final int total){
    }
    @Override public void clearStatus(){
    }
  }
;
  System.out.println("String_Node_Str");
  final boolean computed=featureComputerService.compute(model,model.getFeatureModel(),featureComputers,pl);
  if (!computed) {
    System.err.println("String_Node_Str");
    return;
  }
  final File target=new File("String_Node_Str");
  MamutExporter.export(target,model,project);
  final Model importedModel=new Model();
  TrackMateImporter.importModel(target,importedModel);
  System.out.println(MastodonUtil.dump(importedModel));
}
Program: 90828
Project: 90828
Buggy source:
private void deleteSelected(){
  final Item selected=(Item)comboBox.getSelectedItem();
  if (selected != null) {
    manager.delete(selected.profile);
    makeModel();
  }
}

Fixed version (ground truth):
private void deleteSelected(){
  final Item selected=(Item)comboBox.getSelectedItem();
  if (selected != null) {
    manager.delete(selected.profile);
    selectionListeners.list.forEach(l -> l.deselected(selected.profile));
    selectionListeners.list.forEach(l -> l.selected(manager.getSelectedProfile()));
    editor.loadProfile(manager.getSelectedProfile());
    makeModel();
  }
}