nus-yam/ex-repair huggingface dataset:
Program: 135314
Project: 135314
Buggy source:
private void applyMilestone(TurboIssue issue,IModel model) throws QualifierApplicationException {
  if (!content.isPresent()) {
    throw new QualifierApplicationException("String_Node_Str" + (date.isPresent() ? date.get() : dateRange.get()));
  }
  List<TurboMilestone> milestones=model.getMilestones().stream().filter(m -> m.getTitle().toLowerCase().contains(content.get().toLowerCase())).collect(Collectors.toList());
  if (milestones.size() > 1) {
    throw new QualifierApplicationException("String_Node_Str" + milestones.toString());
  }
 else {
    issue.setMilestone(milestones.get(0));
  }
}

Fixed version (ground truth):
private void applyMilestone(TurboIssue issue,IModel model) throws QualifierApplicationException {
  if (!content.isPresent()) {
    throw new QualifierApplicationException("String_Node_Str");
  }
  List<TurboMilestone> milestones=model.getMilestones().stream().filter(m -> m.getTitle().toLowerCase().contains(content.get().toLowerCase())).collect(Collectors.toList());
  if (milestones.isEmpty()) {
    throw new QualifierApplicationException("String_Node_Str" + content.get());
  }
 else   if (milestones.size() == 1) {
    issue.setMilestone(milestones.get(0));
    return;
  }
  milestones=model.getMilestones().stream().filter(m -> m.getTitle().toLowerCase().equals(content.get().toLowerCase())).collect(Collectors.toList());
  if (milestones.isEmpty()) {
    throw new QualifierApplicationException("String_Node_Str" + content.get());
  }
 else   if (milestones.size() == 1) {
    issue.setMilestone(milestones.get(0));
    return;
  }
  throw new QualifierApplicationException("String_Node_Str" + milestones.toString());
}
Program: 135315
Project: 135315
Buggy source:
private void applyLabel(TurboIssue issue,IModel model) throws QualifierApplicationException {
  if (!content.isPresent()) {
    throw new QualifierApplicationException("String_Node_Str" + (date.isPresent() ? date.get() : dateRange.get()));
  }
  List<TurboLabel> labels=model.getLabels().stream().filter(l -> l.getActualName().toLowerCase().contains(content.get().toLowerCase())).collect(Collectors.toList());
  if (labels.size() > 1) {
    throw new QualifierApplicationException("String_Node_Str" + labels.toString());
  }
 else {
    issue.addLabel(labels.get(0));
  }
}

Fixed version (ground truth):
private void applyLabel(TurboIssue issue,IModel model) throws QualifierApplicationException {
  if (!content.isPresent()) {
    throw new QualifierApplicationException("String_Node_Str");
  }
  List<TurboLabel> labels=model.getLabels().stream().filter(l -> l.getActualName().toLowerCase().contains(content.get().toLowerCase())).collect(Collectors.toList());
  if (labels.isEmpty()) {
    throw new QualifierApplicationException("String_Node_Str" + content.get());
  }
 else   if (labels.size() == 1) {
    issue.addLabel(labels.get(0));
    return;
  }
  labels=model.getLabels().stream().filter(l -> l.getActualName().toLowerCase().equals(content.get().toLowerCase())).collect(Collectors.toList());
  if (labels.isEmpty()) {
    throw new QualifierApplicationException("String_Node_Str" + content.get());
  }
 else   if (labels.size() == 1) {
    issue.addLabel(labels.get(0));
    return;
  }
  throw new QualifierApplicationException("String_Node_Str" + labels.toString());
}
Program: 135316
Project: 135316
Buggy source:
private void applyState(TurboIssue issue) throws QualifierApplicationException {
  if (!content.isPresent()) {
    throw new QualifierApplicationException("String_Node_Str" + (date.isPresent() ? date.get() : dateRange.get()));
  }
  if (content.get().toLowerCase().contains("String_Node_Str")) {
    issue.setOpen(true);
  }
 else   if (content.get().toLowerCase().contains("String_Node_Str")) {
    issue.setOpen(false);
  }
}

Fixed version (ground truth):
private void applyState(TurboIssue issue) throws QualifierApplicationException {
  if (!content.isPresent()) {
    throw new QualifierApplicationException("String_Node_Str");
  }
  if (content.get().toLowerCase().contains("String_Node_Str")) {
    issue.setOpen(true);
  }
 else   if (content.get().toLowerCase().contains("String_Node_Str")) {
    issue.setOpen(false);
  }
 else {
    throw new QualifierApplicationException("String_Node_Str" + content.get());
  }
}
Program: 135319
Project: 135319
Buggy source:
/** 
 * Should be called to restore selection after making changes to the item list of this list view. Must be called after saveSelection is.
 * @throws IllegalStateException if called before saveSelection is
 */
public void restoreSelection(){
  if (!lastSelectedItem.isPresent()) {
    if (!saveSelectionCalled) {
      throw new IllegalStateException("String_Node_Str");
    }
 else {
      saveSelectionCalled=false;
      return;
    }
  }
  saveSelectionCalled=false;
  int index=-1;
  int i=0;
  for (  T item : getItems()) {
    if (item.equals(lastSelectedItem)) {
      index=i;
      break;
    }
    i++;
  }
  if (index == -1) {
  }
 else {
    getSelectionModel().clearAndSelect(index);
    selectedIndex=Optional.of(index);
  }
}

Fixed version (ground truth):
/** 
 * Should be called to restore selection after making changes to the item list of this list view. Must be called after saveSelection is.
 * @throws IllegalStateException if called before saveSelection is
 */
public void restoreSelection(){
  if (!lastSelectedItem.isPresent()) {
    if (!saveSelectionCalled) {
      throw new IllegalStateException("String_Node_Str");
    }
 else {
      saveSelectionCalled=false;
      return;
    }
  }
  saveSelectionCalled=false;
  int index=-1;
  int i=0;
  for (  T item : getItems()) {
    if (item.equals(lastSelectedItem.get())) {
      index=i;
      break;
    }
    i++;
  }
  if (index == -1) {
  }
 else {
    getSelectionModel().clearAndSelect(index);
    selectedIndex=Optional.of(index);
  }
}
Program: 135320
Project: 135320
Buggy source:
/** 
 * Takes lists of TurboIssues and reconciles the changes between them, returning a list of TurboIssues with updates from the second.
 */
public static List<TurboIssue> reconcile(String repoId,List<TurboIssue> existing,List<TurboIssue> changed){
  existing=new ArrayList<>(existing);
  for (  TurboIssue issue : changed) {
    int id=issue.getId();
    Optional<Integer> corresponding=findIssueWithId(existing,id);
    if (corresponding.isPresent()) {
      existing.set(corresponding.get(),new TurboIssue(issue));
    }
 else {
      existing.add(new TurboIssue(issue));
    }
  }
  return existing;
}

Fixed version (ground truth):
/** 
 * Takes lists of TurboIssues and reconciles the changes between them, returning a list of TurboIssues with updates from the second.
 */
public static List<TurboIssue> reconcile(String repoId,List<TurboIssue> existing,List<TurboIssue> changed){
  existing=new ArrayList<>(existing);
  for (  TurboIssue issue : changed) {
    int id=issue.getId();
    Optional<Integer> corresponding=findIssueWithId(existing,id);
    if (corresponding.isPresent()) {
      TurboIssue newIssue=new TurboIssue(issue);
      newIssue.transferTransientState(existing.get(corresponding.get()));
      existing.set(corresponding.get(),newIssue);
    }
 else {
      existing.add(new TurboIssue(issue));
    }
  }
  return existing;
}
Program: 135321
Project: 135321
Buggy source:
public synchronized MultiModel add(Model model){
  this.models.put(model.getRepoId(),model);
  preprocessNewIssues(model);
  return this;
}

Fixed version (ground truth):
public synchronized MultiModel add(Model model){
  this.models.put(model.getRepoId(),model);
  return this;
}
Program: 135322
Project: 135322
Buggy source:
public String getName(){
  if (getDelimiter().isPresent()) {
    return actualName.split("String_Node_Str" + getDelimiter().get())[1];
  }
 else {
    return actualName;
  }
}

Fixed version (ground truth):
public String getName(){
}
Program: 135323
Project: 135323
Buggy source:
public Optional<String> getGroup(){
  if (getDelimiter().isPresent()) {
    return Optional.of(actualName.split("String_Node_Str" + getDelimiter().get())[0]);
  }
 else {
    return Optional.empty();
  }
}

Fixed version (ground truth):
public Optional<String> getGroup(){
}
Program: 135324
Project: 135324
Buggy source:
private static TurboLabel updateRandomLabel(String repoId){
  int i=(int)(Math.random() * issueCounter);
  return new TurboLabel(repoId,"String_Node_Str" + i + "String_Node_Str"+ Math.random());
}

Fixed version (ground truth):
private static TurboLabel updateRandomLabel(String repoId){
  int i=(int)(Math.random() * labelCounter);
  return labels.set(i,new TurboLabel(repoId,"String_Node_Str" + (i + 1) + "String_Node_Str"+ Math.random()));
}
Program: 135325
Project: 135325
Buggy source:
@Override public List<TurboUser> getCollaborators(String repoId){
  List<TurboUser> users=new ArrayList<>();
  for (int i=0; i < 10; i++) {
    users.add(makeDummyUser(DUMMY_REPO_ID));
  }
  return users;
}

Fixed version (ground truth):
@Override public List<TurboUser> getCollaborators(String repoId){
  return users;
}
Program: 135326
Project: 135326
Buggy source:
private static TurboIssue updateRandomIssue(String repoId){
  int i=(int)(Math.random() * issueCounter);
  return new TurboIssue(repoId,i,"String_Node_Str" + i + "String_Node_Str"+ Math.random());
}

Fixed version (ground truth):
private static TurboIssue updateRandomIssue(String repoId){
  int i=(int)(Math.random() * issueCounter);
  return issues.set(i,new TurboIssue(repoId,i + 1,"String_Node_Str" + (i + 1) + "String_Node_Str"+ Math.random()));
}
Program: 135327
Project: 135327
Buggy source:
@Override public List<TurboMilestone> getMilestones(String repoId){
  List<TurboMilestone> milestones=new ArrayList<>();
  for (int i=0; i < 10; i++) {
    milestones.add(makeDummyMilestone(DUMMY_REPO_ID));
  }
  return milestones;
}

Fixed version (ground truth):
@Override public List<TurboMilestone> getMilestones(String repoId){
  return milestones;
}
Program: 135328
Project: 135328
Buggy source:
@Override public List<TurboLabel> getLabels(String repoId){
  List<TurboLabel> labels=new ArrayList<>();
  for (int i=0; i < 10; i++) {
    labels.add(makeDummyLabel(DUMMY_REPO_ID));
  }
  return labels;
}

Fixed version (ground truth):
@Override public List<TurboLabel> getLabels(String repoId){
  return labels;
}
Program: 135329
Project: 135329
Buggy source:
private static TurboMilestone updateRandomMilestone(String repoId){
  int i=(int)(Math.random() * milestoneCounter);
  return new TurboMilestone(repoId,i,"String_Node_Str" + i + "String_Node_Str"+ Math.random());
}

Fixed version (ground truth):
private static TurboMilestone updateRandomMilestone(String repoId){
  int i=(int)(Math.random() * milestoneCounter);
  return milestones.set(i,new TurboMilestone(repoId,(i + 1),"String_Node_Str" + (i + 1) + "String_Node_Str"+ Math.random()));
}
Program: 135330
Project: 135330
Buggy source:
public DummyRepo(){
}

Fixed version (ground truth):
public DummyRepo(){
  for (int i=0; i < 10; i++) {
    issues.add(makeDummyIssue(DUMMY_REPO_ID));
    labels.add(makeDummyLabel(DUMMY_REPO_ID));
    milestones.add(makeDummyMilestone(DUMMY_REPO_ID));
    users.add(makeDummyUser(DUMMY_REPO_ID));
  }
}
Program: 135331
Project: 135331
Buggy source:
private static TurboUser updateRandomUser(String repoId){
  int i=(int)(Math.random() * userCounter);
  return new TurboUser(repoId,"String_Node_Str" + i + "String_Node_Str"+ Math.random());
}

Fixed version (ground truth):
private static TurboUser updateRandomUser(String repoId){
  int i=(int)(Math.random() * userCounter);
  return users.set(i,new TurboUser(repoId,"String_Node_Str" + (i + 1) + "String_Node_Str"+ Math.random()));
}
Program: 135332
Project: 135332
Buggy source:
@Override public List<TurboIssue> getIssues(String repoName){
  List<TurboIssue> issues=new ArrayList<>();
  for (int i=0; i < 10; i++) {
    issues.add(makeDummyIssue(DUMMY_REPO_ID));
  }
  return issues;
}

Fixed version (ground truth):
@Override public List<TurboIssue> getIssues(String repoName){
  return issues;
}
Program: 135333
Project: 135333
Buggy source:
private boolean keywordSatisfies(TurboIssue issue,MetaQualifierInfo info){
  if (info.getIn().isPresent()) {
switch (info.getIn().get()) {
case "String_Node_Str":
      return titleSatisfies(issue);
case "String_Node_Str":
case "String_Node_Str":
    return bodySatisfies(issue);
default :
  return false;
}
}
 else {
return titleSatisfies(issue) || bodySatisfies(issue);
}
}

Fixed version (ground truth):
private boolean keywordSatisfies(TurboIssue issue,MetaQualifierInfo info){
  if (info.getIn().isPresent()) {
switch (info.getIn().get()) {
case "String_Node_Str":
      return titleSatisfies(issue);
case "String_Node_Str":
case "String_Node_Str":
case "String_Node_Str":
    return bodySatisfies(issue);
default :
  return false;
}
}
 else {
return titleSatisfies(issue) || bodySatisfies(issue);
}
}
Program: 135334
Project: 135334
Buggy source:
private boolean labelsSatisfy(IModel model,TurboIssue issue){
  if (!content.isPresent())   return false;
  TurboLabel tokens=new TurboLabel("String_Node_Str",content.get().toLowerCase());
  String group="String_Node_Str";
  if (tokens.getGroup().isPresent()) {
    group=tokens.getGroup().get().toLowerCase();
  }
  String labelName=tokens.getName().toLowerCase();
  for (  TurboLabel label : model.getLabelsOfIssue(issue)) {
    if (label.getGroup().isPresent()) {
      if (label.getGroup().get().toLowerCase().contains(group) && label.getName().toLowerCase().contains(labelName)) {
        return true;
      }
    }
 else {
      return label.getName().toLowerCase().contains(labelName);
    }
  }
  return false;
}

Fixed version (ground truth):
private boolean labelsSatisfy(IModel model,TurboIssue issue){
  if (!content.isPresent())   return false;
  TurboLabel tokens=new TurboLabel("String_Node_Str",content.get().toLowerCase());
  String group="String_Node_Str";
  if (tokens.getGroup().isPresent()) {
    group=tokens.getGroup().get().toLowerCase();
  }
  String labelName=tokens.getName().toLowerCase();
  for (  TurboLabel label : model.getLabelsOfIssue(issue)) {
    if (label.getGroup().isPresent()) {
      if (labelName.isEmpty()) {
        if (label.getGroup().get().toLowerCase().contains(group)) {
          return true;
        }
      }
 else {
        if (label.getGroup().get().toLowerCase().contains(group) && label.getName().toLowerCase().contains(labelName)) {
          return true;
        }
      }
    }
 else {
      if (!group.isEmpty()) {
        return false;
      }
 else       if (!labelName.isEmpty() && label.getName().toLowerCase().contains(labelName)) {
        return true;
      }
    }
  }
  return false;
}
Program: 135335
Project: 135335
Buggy source:
private boolean satisfiesHasConditions(TurboIssue issue){
  if (!content.isPresent())   return false;
switch (content.get()) {
case "String_Node_Str":
case "String_Node_Str":
    return issue.getLabels().size() > 0;
case "String_Node_Str":
case "String_Node_Str":
  return issue.getMilestone() != null;
case "String_Node_Str":
case "String_Node_Str":
return issue.getAssignee() != null;
default :
return false;
}
}

Fixed version (ground truth):
private boolean satisfiesHasConditions(TurboIssue issue){
}
Program: 135336
Project: 135336
Buggy source:
public List<TurboLabel> getLabelsOfIssue(TurboIssue issue){
  return issue.getLabels().stream().map(this::getLabelByName).filter(Optional::isPresent).map(Optional::get).collect(Collectors.toList());
}

Fixed version (ground truth):
public List<TurboLabel> getLabelsOfIssue(TurboIssue issue){
  return issue.getLabels().stream().map(this::getLabelByActualName).filter(Optional::isPresent).map(Optional::get).collect(Collectors.toList());
}
Program: 135337
Project: 135337
Buggy source:
@Override public void run(){
  UpdateIssuesTask issuesTask=new UpdateIssuesTask(taskRunner,repo,model);
  UpdateLabelsTask labelsTask=new UpdateLabelsTask(taskRunner,repo,model);
  UpdateMilestonesTask milestonesTask=new UpdateMilestonesTask(taskRunner,repo,model);
  UpdateUsersTask usersTask=new UpdateUsersTask(taskRunner,repo,model);
  taskRunner.execute(issuesTask);
  taskRunner.execute(labelsTask);
  taskRunner.execute(milestonesTask);
  taskRunner.execute(usersTask);
  try {
    GitHubRepoTask.Result<TurboIssue> issuesResult=issuesTask.response.get();
    GitHubRepoTask.Result<TurboLabel> labelsResult=labelsTask.response.get();
    GitHubRepoTask.Result<TurboMilestone> milestonesResult=milestonesTask.response.get();
    GitHubRepoTask.Result<TurboUser> usersResult=usersTask.response.get();
    UpdateSignature newSignature=new UpdateSignature(issuesResult.ETag,labelsResult.ETag,milestonesResult.ETag,usersResult.ETag,issuesResult.lastCheckTime);
    Model result=new Model(model.getRepoId(),model.getIssues(),model.getLabels(),model.getMilestones(),model.getUsers(),newSignature);
    logger.info(HTLog.format(model.getRepoId(),"String_Node_Str" + result.summarise()));
    response.complete(result);
  }
 catch (  InterruptedException|ExecutionException e) {
    HTLog.error(logger,e);
  }
}

Fixed version (ground truth):
@Override public void run(){
  UpdateIssuesTask issuesTask=new UpdateIssuesTask(taskRunner,repo,model);
  UpdateLabelsTask labelsTask=new UpdateLabelsTask(taskRunner,repo,model);
  UpdateMilestonesTask milestonesTask=new UpdateMilestonesTask(taskRunner,repo,model);
  UpdateUsersTask usersTask=new UpdateUsersTask(taskRunner,repo,model);
  taskRunner.execute(issuesTask);
  taskRunner.execute(labelsTask);
  taskRunner.execute(milestonesTask);
  taskRunner.execute(usersTask);
  try {
    GitHubRepoTask.Result<TurboIssue> issuesResult=issuesTask.response.get();
    GitHubRepoTask.Result<TurboLabel> labelsResult=labelsTask.response.get();
    GitHubRepoTask.Result<TurboMilestone> milestonesResult=milestonesTask.response.get();
    GitHubRepoTask.Result<TurboUser> usersResult=usersTask.response.get();
    UpdateSignature newSignature=new UpdateSignature(issuesResult.ETag,labelsResult.ETag,milestonesResult.ETag,usersResult.ETag,issuesResult.lastCheckTime);
    Model result=new Model(model.getRepoId(),issuesResult.items,labelsResult.items,milestonesResult.items,usersResult.items,newSignature);
    logger.info(HTLog.format(model.getRepoId(),"String_Node_Str" + result.summarise()));
    response.complete(result);
  }
 catch (  InterruptedException|ExecutionException e) {
    HTLog.error(logger,e);
  }
}
Program: 135338
Project: 135338
Buggy source:
private void updateUI(){
  uiManager.update(models);
}

Fixed version (ground truth):
private void updateUI(MultiModel models){
  uiManager.update(models);
}
Program: 135339
Project: 135339
Buggy source:
public void refresh(){
  logger.info("String_Node_Str" + models.toModels().stream().map(Model::getRepoId).collect(Collectors.toList()));
  Utility.sequence(models.toModels().stream().map(repoIO::updateModel).collect(Collectors.toList())).thenAccept(models::replace).thenRun(this::updateUI);
}

Fixed version (ground truth):
public void refresh(){
  logger.info("String_Node_Str" + models.toModels().stream().map(Model::getRepoId).collect(Collectors.toList()));
  Utility.sequence(models.toModels().stream().map(repoIO::updateModel).collect(Collectors.toList())).thenApply(models::replace).thenAccept(this::updateUI).exceptionally(HTLog::log);
}
Program: 135340
Project: 135340
Buggy source:
public Logic(UIManager uiManager,Preferences prefs){
  this.uiManager=uiManager;
  this.prefs=prefs;
  updateUI();
}

Fixed version (ground truth):
public Logic(UIManager uiManager,Preferences prefs){
  this.uiManager=uiManager;
  this.prefs=prefs;
  updateUI(models);
}
Program: 135341
Project: 135341
Buggy source:
public CompletableFuture<Map<Integer,IssueMetadata>> getIssueMetadata(String repoId,List<Integer> issues){
  logger.info("String_Node_Str" + issues);
  return repoIO.getIssueMetadata(repoId,issues).thenApply(metadata -> {
    models.insertMetadata(repoId,metadata);
    return metadata;
  }
);
}

Fixed version (ground truth):
public CompletableFuture<Map<Integer,IssueMetadata>> getIssueMetadata(String repoId,List<Integer> issues){
  logger.info("String_Node_Str" + issues);
  return repoIO.getIssueMetadata(repoId,issues).thenApply(metadata -> {
    models.insertMetadata(repoId,metadata);
    return metadata;
  }
).exceptionally(HTLog.withResult(new HashMap<>()));
}
Program: 135342
Project: 135342
Buggy source:
public CompletableFuture<Model> updateModel(Model model){
  return repoSource.updateModel(model).thenApply(newModel -> {
    if (!model.equals(newModel)) {
      repoStore.saveRepository(newModel.getRepoId().generateId(),new SerializableModel(newModel));
    }
 else {
      logger.info(HTLog.format(model.getRepoId(),"String_Node_Str"));
    }
    return model;
  }
);
}

Fixed version (ground truth):
public CompletableFuture<Model> updateModel(Model model){
  return repoSource.updateModel(model).thenApply(newModel -> {
    if (!model.equals(newModel)) {
      repoStore.saveRepository(newModel.getRepoId().generateId(),new SerializableModel(newModel));
    }
 else {
      logger.info(HTLog.format(model.getRepoId(),"String_Node_Str"));
    }
    return newModel;
  }
).exceptionally(HTLog.withResult(new Model(model.getRepoId())));
}
Program: 135343
Project: 135343
Buggy source:
public CompletableFuture<Model> openRepository(String repoId){
  if (repoStore.isRepoStored(repoId)) {
    return repoStore.loadRepository(repoId).thenCompose(this::updateModel);
  }
 else {
    return repoSource.downloadRepository(repoId).thenCompose(this::updateModel);
  }
}

Fixed version (ground truth):
public CompletableFuture<Model> openRepository(String repoId){
  if (repoStore.isRepoStored(repoId)) {
    return repoStore.loadRepository(repoId).thenCompose(this::updateModel).exceptionally(HTLog.withResult(new Model(RepositoryId.createFromId(repoId))));
  }
 else {
    return repoSource.downloadRepository(repoId).thenCompose(this::updateModel).exceptionally(HTLog.withResult(new Model(RepositoryId.createFromId(repoId))));
  }
}
Program: 135344
Project: 135344
Buggy source:
@Override public void run(){
  ImmutableTriple<List<TurboIssue>,String,Date> changes=repo.getUpdatedIssues(model.getRepoId().generateId(),model.getUpdateSignature().issuesETag,model.getUpdateSignature().lastCheckTime);
  List<TurboIssue> existing=model.getIssues();
  List<TurboIssue> changed=changes.left;
  logger.info(HTLog.format(model.getRepoId(),"String_Node_Str",changed.size(),changed.size() == 0 ? "String_Node_Str" : "String_Node_Str" + changed));
  List<TurboIssue> updated=TurboIssue.reconcile(model.getRepoId().generateId(),existing,changed);
  response.complete(new Result<>(updated,changes.middle,changes.right));
}

Fixed version (ground truth):
@Override public void run(){
  ImmutableTriple<List<TurboIssue>,String,Date> changes=repo.getUpdatedIssues(model.getRepoId().generateId(),model.getUpdateSignature().issuesETag,model.getUpdateSignature().lastCheckTime);
  List<TurboIssue> existing=model.getIssues();
  List<TurboIssue> changed=changes.left;
  logger.info(HTLog.format(model.getRepoId(),"String_Node_Str",changed.size(),changed.isEmpty() ? "String_Node_Str" : "String_Node_Str" + changed));
  List<TurboIssue> updated=changed.isEmpty() ? existing : TurboIssue.reconcile(model.getRepoId().generateId(),existing,changed);
  response.complete(new Result<>(updated,changes.middle,changes.right));
}
Program: 135345
Project: 135345
Buggy source:
@Override public void run(){
  ImmutablePair<List<TurboLabel>,String> changes=repo.getUpdatedLabels(model.getRepoId().generateId(),model.getUpdateSignature().labelsETag);
  List<TurboLabel> changed=changes.left;
  logger.info(HTLog.format(model.getRepoId(),"String_Node_Str",changed.size(),changed.size() == 0 ? "String_Node_Str" : "String_Node_Str" + changed));
  List<TurboLabel> updated=new ArrayList<>(changed);
  response.complete(new Result<>(updated,changes.right));
}

Fixed version (ground truth):
@Override public void run(){
  ImmutablePair<List<TurboLabel>,String> changes=repo.getUpdatedLabels(model.getRepoId().generateId(),model.getUpdateSignature().labelsETag);
  List<TurboLabel> changed=changes.left;
  logger.info(HTLog.format(model.getRepoId(),"String_Node_Str",changed.size(),changed.isEmpty() ? "String_Node_Str" : "String_Node_Str" + changed));
  List<TurboLabel> updated=changed.isEmpty() ? model.getLabels() : new ArrayList<>(changed);
  response.complete(new Result<>(updated,changes.right));
}
Program: 135346
Project: 135346
Buggy source:
@Override public void run(){
  ImmutablePair<List<TurboMilestone>,String> changes=repo.getUpdatedMilestones(model.getRepoId().generateId(),model.getUpdateSignature().milestonesETag);
  List<TurboMilestone> changed=changes.left;
  logger.info(HTLog.format(model.getRepoId(),"String_Node_Str",changed.size(),changed.size() == 0 ? "String_Node_Str" : "String_Node_Str" + changed));
  List<TurboMilestone> updated=new ArrayList<>(changed);
  response.complete(new Result<>(updated,changes.right));
}

Fixed version (ground truth):
@Override public void run(){
  ImmutablePair<List<TurboMilestone>,String> changes=repo.getUpdatedMilestones(model.getRepoId().generateId(),model.getUpdateSignature().milestonesETag);
  List<TurboMilestone> changed=changes.left;
  logger.info(HTLog.format(model.getRepoId(),"String_Node_Str",changed.size(),changed.isEmpty() ? "String_Node_Str" : "String_Node_Str" + changed));
  List<TurboMilestone> updated=changed.isEmpty() ? model.getMilestones() : new ArrayList<>(changed);
  response.complete(new Result<>(updated,changes.right));
}
Program: 135347
Project: 135347
Buggy source:
@Override public void run(){
  ImmutablePair<List<TurboUser>,String> changes=repo.getUpdatedCollaborators(model.getRepoId().generateId(),model.getUpdateSignature().collaboratorsETag);
  List<TurboUser> changed=changes.left;
  logger.info(HTLog.format(model.getRepoId(),"String_Node_Str",changed.size(),changed.size() == 0 ? "String_Node_Str" : "String_Node_Str" + changed));
  List<TurboUser> updated=new ArrayList<>(changed);
  response.complete(new Result<>(updated,changes.right));
}

Fixed version (ground truth):
@Override public void run(){
  ImmutablePair<List<TurboUser>,String> changes=repo.getUpdatedCollaborators(model.getRepoId().generateId(),model.getUpdateSignature().collaboratorsETag);
  List<TurboUser> changed=changes.left;
  logger.info(HTLog.format(model.getRepoId(),"String_Node_Str",changed.size(),changed.isEmpty() ? "String_Node_Str" : "String_Node_Str" + changed));
  List<TurboUser> updated=changed.isEmpty() ? model.getUsers() : new ArrayList<>(changed);
  response.complete(new Result<>(updated,changes.right));
}
Program: 135348
Project: 135348
Buggy source:
private Model load(String repoId){
  Optional<String> input=RepoStore.read(repoId);
  if (!input.isPresent()) {
    logger.error("String_Node_Str" + repoId + "String_Node_Str");
    return new Model(RepositoryId.createFromId(repoId),UpdateSignature.empty);
  }
 else {
    logger.info(HTLog.format(repoId,"String_Node_Str"));
    SerializableModel sModel=new Gson().fromJson(input.get(),new TypeToken<SerializableModel>(){
    }
.getType());
    return new Model(sModel);
  }
}

Fixed version (ground truth):
private Model load(String repoId){
  Optional<String> input=RepoStore.read(repoId);
  if (!input.isPresent()) {
    logger.error("String_Node_Str" + repoId + "String_Node_Str");
    return new Model(RepositoryId.createFromId(repoId));
  }
 else {
    logger.info(HTLog.format(repoId,"String_Node_Str"));
    SerializableModel sModel=new Gson().fromJson(input.get(),new TypeToken<SerializableModel>(){
    }
.getType());
    return new Model(sModel);
  }
}
Program: 135349
Project: 135349
Buggy source:
public synchronized void add(Model model){
}

Fixed version (ground truth):
public synchronized MultiModel add(Model model){
  this.models.put(model.getRepoId().generateId(),model);
  return this;
}
Program: 135350
Project: 135350
Buggy source:
public synchronized void replace(List<Model> models){
  this.models.clear();
  models.forEach(this::add);
}

Fixed version (ground truth):
public synchronized MultiModel replace(List<Model> newModels){
  this.models.clear();
  newModels.forEach(this::add);
  return this;
}
Program: 135351
Project: 135351
Buggy source:
public String getName(){
}

Fixed version (ground truth):
public String getName(){
  if (getDelimiter().isPresent()) {
    return actualName.split("String_Node_Str" + getDelimiter().get())[1];
  }
 else {
    return actualName;
  }
}
Program: 135352
Project: 135352
Buggy source:
public boolean isExclusive(){
}

Fixed version (ground truth):
public boolean isExclusive(){
  if (getDelimiter().isPresent()) {
    return getDelimiter().get().equals(EXCLUSIVE_DELIMITER);
  }
 else {
    return false;
  }
}
Program: 135353
Project: 135353
Buggy source:
public Optional<String> getGroup(){
}

Fixed version (ground truth):
public Optional<String> getGroup(){
  if (getDelimiter().isPresent()) {
    return Optional.of(actualName.split("String_Node_Str" + getDelimiter().get())[0]);
  }
 else {
    return Optional.empty();
  }
}
Program: 135354
Project: 135354
Buggy source:
public static FilterExpression parse(String input){
  if (input == null)   return null;
 else   if (input.isEmpty())   return Qualifier.EMPTY;
  return new Parser(new Lexer(input).lex()).parseExpression(0);
}

Fixed version (ground truth):
public static FilterExpression parse(String input){
  if (input == null || input.isEmpty())   return Qualifier.EMPTY;
  return new Parser(new Lexer(input).lex()).parseExpression(0);
}
Program: 135355
Project: 135355
Buggy source:
@Test public void basics(){
  assertEquals(Parser.parse(null),null);
  assertEquals(Parser.parse("String_Node_Str"),Qualifier.EMPTY);
}

Fixed version (ground truth):
@Test public void basics(){
  assertEquals(Parser.parse(null),Qualifier.EMPTY);
  assertEquals(Parser.parse("String_Node_Str"),Qualifier.EMPTY);
}
Program: 135356
Project: 135356
Buggy source:
@Test public void emptyQualifiers(){
  try {
    Parser.parse("String_Node_Str");
    fail("String_Node_Str");
  }
 catch (  ParseException e) {
  }
  try {
    Parser.parse("String_Node_Str");
    fail("String_Node_Str");
  }
 catch (  ParseException e) {
  }
}

Fixed version (ground truth):
@Test public void emptyQualifiers(){
  try {
    Parser.parse("String_Node_Str");
    fail("String_Node_Str");
  }
 catch (  ParseException ignored) {
  }
  try {
    Parser.parse("String_Node_Str");
    fail("String_Node_Str");
  }
 catch (  ParseException ignored) {
  }
}
Program: 135357
Project: 135357
Buggy source:
@Test public void dates(){
  assertEquals(Parser.parse("String_Node_Str"),new Qualifier("String_Node_Str",LocalDate.of(2014,6,1)));
  assertEquals(Parser.parse("String_Node_Str"),new Qualifier("String_Node_Str",LocalDate.of(2014,6,1)));
  assertEquals(Parser.parse("String_Node_Str"),new Conjunction(new Conjunction(new Qualifier("String_Node_Str","String_Node_Str"),new Qualifier("String_Node_Str",LocalDate.of(2014,06,01))),new Qualifier("String_Node_Str","String_Node_Str")));
}

Fixed version (ground truth):
@Test public void dates(){
  assertEquals(Parser.parse("String_Node_Str"),new Qualifier("String_Node_Str",LocalDate.of(2014,6,1)));
  assertEquals(Parser.parse("String_Node_Str"),new Qualifier("String_Node_Str",LocalDate.of(2014,6,1)));
  assertEquals(Parser.parse("String_Node_Str"),new Conjunction(new Conjunction(new Qualifier("String_Node_Str","String_Node_Str"),new Qualifier("String_Node_Str",LocalDate.of(2014,6,1))),new Qualifier("String_Node_Str","String_Node_Str")));
}
Program: 135358
Project: 135358
Buggy source:
@Test public void lexer(){
  assertEquals(new Lexer("String_Node_Str").lex(),new ArrayList<Token>(Arrays.asList(new Token(TokenType.EOF,"String_Node_Str",0))));
  assertEquals(new Lexer("String_Node_Str").lex(),new ArrayList<Token>(Arrays.asList(new Token(TokenType.SYMBOL,"String_Node_Str",0),new Token(TokenType.SYMBOL,"String_Node_Str",0),new Token(TokenType.SYMBOL,"String_Node_Str",0),new Token(TokenType.EOF,"String_Node_Str",0))));
}

Fixed version (ground truth):
@Test public void lexer(){
  assertEquals(new Lexer("String_Node_Str").lex(),Arrays.asList(new Token(TokenType.EOF,"String_Node_Str",0)));
  assertEquals(new Lexer("String_Node_Str").lex(),Arrays.asList(new Token(TokenType.SYMBOL,"String_Node_Str",0),new Token(TokenType.SYMBOL,"String_Node_Str",0),new Token(TokenType.SYMBOL,"String_Node_Str",0),new Token(TokenType.EOF,"String_Node_Str",0)));
}
Program: 135359
Project: 135359
Buggy source:
@Test public void dateRanges(){
  assertEquals(Parser.parse("String_Node_Str"),new Qualifier("String_Node_Str",new DateRange(LocalDate.of(2014,06,01),LocalDate.of(2013,03,15))));
  assertEquals(Parser.parse("String_Node_Str"),new Qualifier("String_Node_Str",new DateRange(LocalDate.of(2014,06,01),null)));
  assertEquals(Parser.parse("String_Node_Str"),new Conjunction(new Conjunction(new Qualifier("String_Node_Str","String_Node_Str"),new Qualifier("String_Node_Str",new DateRange(LocalDate.of(2014,06,01),LocalDate.of(2013,03,15)))),new Qualifier("String_Node_Str","String_Node_Str")));
}

Fixed version (ground truth):
@Test public void dateRanges(){
  assertEquals(Parser.parse("String_Node_Str"),new Qualifier("String_Node_Str",new DateRange(LocalDate.of(2014,6,1),LocalDate.of(2013,3,15))));
  assertEquals(Parser.parse("String_Node_Str"),new Qualifier("String_Node_Str",new DateRange(LocalDate.of(2014,6,1),null)));
  assertEquals(Parser.parse("String_Node_Str"),new Conjunction(new Conjunction(new Qualifier("String_Node_Str","String_Node_Str"),new Qualifier("String_Node_Str",new DateRange(LocalDate.of(2014,6,1),LocalDate.of(2013,03,15)))),new Qualifier("String_Node_Str","String_Node_Str")));
}
Program: 135360
Project: 135360
Buggy source:
@Test public void serialisation(){
  String[] tests={"String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str"};
  for (int i=0; i < tests.length; i++) {
    assertEquals(Parser.parse(Parser.parse(tests[i]).toString()),Parser.parse(tests[i]));
  }
}

Fixed version (ground truth):
@Test public void serialisation(){
}
Program: 135361
Project: 135361
Buggy source:
@Test public void unexpectedEOFs(){
  try {
    Parser.parse("String_Node_Str");
    fail("String_Node_Str");
  }
 catch (  ParseException e) {
  }
  try {
    Parser.parse("String_Node_Str");
    fail("String_Node_Str");
  }
 catch (  ParseException e) {
  }
}

Fixed version (ground truth):
@Test public void unexpectedEOFs(){
  try {
    Parser.parse("String_Node_Str");
    fail("String_Node_Str");
  }
 catch (  ParseException ignored) {
  }
  try {
    Parser.parse("String_Node_Str");
    fail("String_Node_Str");
  }
 catch (  ParseException ignored) {
  }
}
Program: 135362
Project: 135362
Buggy source:
/** 
 * Creates a JavaFX node containing a graphical display of this issue's events.
 * @param withinHours
 * @return
 */
public Node getEventDisplay(final int withinHours){
  final LocalDateTime now=LocalDateTime.now();
  List<TurboIssueEvent> eventsWithinDuration=events.stream().filter(event -> {
    LocalDateTime eventTime=Utility.longToLocalDateTime(event.getDate().getTime());
    int hours=Utility.safeLongToInt(eventTime.until(now,ChronoUnit.HOURS));
    return hours < withinHours;
  }
).collect(Collectors.toList());
  List<Comment> commentsWithinDuration=this.comments.stream().filter(comment -> {
    LocalDateTime created=Utility.longToLocalDateTime(comment.getCreatedAt().getTime());
    int hours=Utility.safeLongToInt(created.until(now,ChronoUnit.HOURS));
    return hours < withinHours;
  }
).collect(Collectors.toList());
  return layoutEvents(eventsWithinDuration,commentsWithinDuration);
}

Fixed version (ground truth):
/** 
 * Creates a JavaFX node containing a graphical display of this issue's events.
 * @param withinHours the number of hours to bound the returned events by
 * @return the node
 */
public Node getEventDisplay(final int withinHours){
  final LocalDateTime now=LocalDateTime.now();
  List<TurboIssueEvent> eventsWithinDuration=events.stream().filter(event -> {
    LocalDateTime eventTime=Utility.longToLocalDateTime(event.getDate().getTime());
    int hours=Utility.safeLongToInt(eventTime.until(now,ChronoUnit.HOURS));
    return hours < withinHours;
  }
).collect(Collectors.toList());
  List<Comment> commentsWithinDuration=this.comments.stream().filter(comment -> {
    LocalDateTime created=Utility.longToLocalDateTime(comment.getCreatedAt().getTime());
    int hours=Utility.safeLongToInt(created.until(now,ChronoUnit.HOURS));
    return hours < withinHours;
  }
).collect(Collectors.toList());
  return layoutEvents(eventsWithinDuration,commentsWithinDuration);
}
Program: 135363
Project: 135363
Buggy source:
public void addLabels(List<TurboLabel> labList){
  for (  TurboLabel label : labList) {
    addLabel(label);
  }
}

Fixed version (ground truth):
public void addLabels(List<TurboLabel> newLabels){
  newLabels.forEach(this::addLabel);
}
Program: 135364
Project: 135364
Buggy source:
private ObservableList<TurboLabel> translateLabels(List<Label> labels){
  ObservableList<TurboLabel> turboLabels=FXCollections.observableArrayList();
  if (labels == null)   return turboLabels;
  for (  Label label : labels) {
    turboLabels.add(new TurboLabel(label));
  }
  return turboLabels;
}

Fixed version (ground truth):
private ObservableList<TurboLabel> translateLabels(List<Label> labels){
  ObservableList<TurboLabel> turboLabels=FXCollections.observableArrayList();
  if (labels == null) {
    return turboLabels;
  }
  turboLabels.addAll(labels.stream().map(label -> new TurboLabel(label)).collect(Collectors.toList()));
  return turboLabels;
}
Program: 135365
Project: 135365
Buggy source:
public void setLabels(List<TurboLabel> labels){
  if (this.labels != labels) {
    this.labels.clear();
    for (    TurboLabel label : labels) {
      addLabel(label);
    }
  }
}

Fixed version (ground truth):
public void setLabels(List<TurboLabel> labels){
  if (this.labels != labels) {
    this.labels.clear();
    labels.forEach(this::addLabel);
  }
}
Program: 135366
Project: 135366
Buggy source:
/** 
 * A convenient string representation of this object, for purposes of readable logs.
 * @return
 */
public String logString(){
  return "String_Node_Str" + getId() + "String_Node_Str"+ getTitle();
}

Fixed version (ground truth):
/** 
 * A convenient string representation of this object, for purposes of readable logs.
 * @return a string representation suitable for logs
 */
public String logString(){
  return "String_Node_Str" + getId() + "String_Node_Str"+ getTitle();
}
Program: 135367
Project: 135367
Buggy source:
public void removeLabel(TurboLabel label){
  if (!labels.remove(label)) {
    return;
  }
}

Fixed version (ground truth):
public void removeLabel(TurboLabel label){
  labels.remove(label);
}
Program: 135368
Project: 135368
Buggy source:
public void removeLabels(List<TurboLabel> labList){
  for (  TurboLabel label : labList) {
    removeLabel(label);
  }
}

Fixed version (ground truth):
public void removeLabels(List<TurboLabel> toRemove){
  toRemove.forEach(this::removeLabel);
}
Program: 135369
Project: 135369
Buggy source:
/** 
 * Given a list of issue events, returns a JavaFX node laying them out properly.
 * @param events
 * @return
 */
private static Node layoutEvents(List<TurboIssueEvent> events,List<Comment> comments){
  VBox result=new VBox();
  result.setSpacing(3);
  VBox.setMargin(result,new Insets(3,0,0,0));
  events.stream().map(TurboIssueEvent::display).forEach(e -> result.getChildren().add(e));
  if (comments.size() > 0) {
    String names=comments.stream().map(comment -> comment.getUser().getLogin()).distinct().collect(Collectors.joining("String_Node_Str"));
    HBox commentDisplay=new HBox();
    commentDisplay.getChildren().addAll(TurboIssueEvent.octicon(TurboIssueEvent.OCTICON_QUOTE),new javafx.scene.control.Label(String.format("String_Node_Str",comments.size(),names)));
    result.getChildren().add(commentDisplay);
  }
  return result;
}

Fixed version (ground truth):
/** 
 * Given a list of issue events, returns a JavaFX node laying them out properly.
 * @param events
 * @param comments
 * @return
 */
private static Node layoutEvents(List<TurboIssueEvent> events,List<Comment> comments){
  VBox result=new VBox();
  result.setSpacing(3);
  VBox.setMargin(result,new Insets(3,0,0,0));
  events.stream().map(TurboIssueEvent::display).forEach(e -> result.getChildren().add(e));
  if (comments.size() > 0) {
    String names=comments.stream().map(comment -> comment.getUser().getLogin()).distinct().collect(Collectors.joining("String_Node_Str"));
    HBox commentDisplay=new HBox();
    commentDisplay.getChildren().addAll(TurboIssueEvent.octicon(TurboIssueEvent.OCTICON_QUOTE),new javafx.scene.control.Label(String.format("String_Node_Str",comments.size(),names)));
    result.getChildren().add(commentDisplay);
  }
  return result;
}
Program: 135370
Project: 135370
Buggy source:
public static int extractIssueParent(String issueBody){
  if (issueBody == null) {
    return -1;
  }
  String[] lines=issueBody.split(REGEX_SPLIT_LINES);
  int seperatorLineIndex=getSeparatorIndex(lines);
  for (int i=0; i < seperatorLineIndex; i++) {
    String line=lines[i];
    if (line.startsWith(METADATA_HEADER_PARENT)) {
      String value=line.replace(METADATA_HEADER_PARENT,"String_Node_Str");
      String[] valueTokens=value.split(REGEX_SPLIT_PARENT);
      for (int j=0; j < valueTokens.length; j++) {
        if (!valueTokens[j].trim().isEmpty()) {
          return Integer.parseInt(valueTokens[j].trim());
        }
      }
    }
 else     if (line.startsWith(OLD_METADATA_HEADER_PARENT)) {
      String value=line.replace(OLD_METADATA_HEADER_PARENT,"String_Node_Str");
      String[] valueTokens=value.split(REGEX_SPLIT_PARENT);
      for (int j=0; j < valueTokens.length; j++) {
        if (!valueTokens[j].trim().isEmpty()) {
          return Integer.parseInt(valueTokens[j].trim());
        }
      }
    }
  }
  return -1;
}

Fixed version (ground truth):
public static int extractIssueParent(String issueBody){
  if (issueBody == null) {
    return -1;
  }
  String[] lines=issueBody.split(REGEX_SPLIT_LINES);
  int seperatorLineIndex=getSeparatorIndex(lines);
  for (int i=0; i < seperatorLineIndex; i++) {
    String line=lines[i];
    if (line.startsWith(METADATA_HEADER_PARENT)) {
      String value=line.replace(METADATA_HEADER_PARENT,"String_Node_Str");
      String[] valueTokens=value.split(REGEX_SPLIT_PARENT);
      for (      String valueToken : valueTokens) {
        if (!valueToken.trim().isEmpty()) {
          return Integer.parseInt(valueToken.trim());
        }
      }
    }
 else     if (line.startsWith(OLD_METADATA_HEADER_PARENT)) {
      String value=line.replace(OLD_METADATA_HEADER_PARENT,"String_Node_Str");
      String[] valueTokens=value.split(REGEX_SPLIT_PARENT);
      for (      String valueToken : valueTokens) {
        if (!valueToken.trim().isEmpty()) {
          return Integer.parseInt(valueToken.trim());
        }
      }
    }
  }
  return -1;
}
Program: 135371
Project: 135371
Buggy source:
public static String extractDescription(String issueBody){
  if (issueBody == null)   return "String_Node_Str";
  String description=issueBody.replaceAll(REGEX_REPLACE_DESC,"String_Node_Str").trim();
  return description;
}

Fixed version (ground truth):
public static String extractDescription(String issueBody){
  if (issueBody == null) {
    return "String_Node_Str";
  }
  return issueBody.replaceAll(REGEX_REPLACE_DESC,"String_Node_Str").trim();
}
Program: 135372
Project: 135372
Buggy source:
/** 
 * Given a list of issue events, returns a textual representation of them, concatenated together with newlines.
 * @param events
 * @return
 */
private static Node formatEventsText(List<TurboIssueEvent> events,int width){
  String text=events.stream().map(TurboIssueEvent::toString).collect(Collectors.joining("String_Node_Str"));
  Text display=new Text(text);
  display.setWrappingWidth(width);
  display.getStyleClass().add("String_Node_Str");
  return display;
}

Fixed version (ground truth):
/** 
 * Given a list of issue events, returns a textual representation of them, concatenated together with newlines.
 * @param events
 * @param width
 * @return
 */
private static Node formatEventsText(List<TurboIssueEvent> events,int width){
  String text=events.stream().map(TurboIssueEvent::toString).collect(Collectors.joining("String_Node_Str"));
  Text display=new Text(text);
  display.setWrappingWidth(width);
  display.getStyleClass().add("String_Node_Str");
  return display;
}
Program: 135373
Project: 135373
Buggy source:
private boolean typeSatisfies(TurboIssue issue){
  if (!content.isPresent())   return false;
  String content=this.content.get().toLowerCase();
  if (content.equals("String_Node_Str")) {
    return !isPullRequest(issue);
  }
 else   if (content.equals("String_Node_Str") || content.equals("String_Node_Str")) {
    return isPullRequest(issue);
  }
 else {
    return false;
  }
}

Fixed version (ground truth):
private boolean typeSatisfies(TurboIssue issue){
  if (!content.isPresent())   return false;
  String content=this.content.get().toLowerCase();
  if (content.equals("String_Node_Str")) {
    return !issue.isPullRequest();
  }
 else   if (content.equals("String_Node_Str") || content.equals("String_Node_Str")) {
    return issue.isPullRequest();
  }
 else {
    return false;
  }
}
Program: 135374
Project: 135374
Buggy source:
private boolean satisfiesIsConditions(TurboIssue issue){
  if (!content.isPresent())   return false;
switch (content.get()) {
case "String_Node_Str":
case "String_Node_Str":
    return stateSatisfies(issue);
case "String_Node_Str":
case "String_Node_Str":
  return typeSatisfies(issue);
case "String_Node_Str":
return isPullRequest(issue) && !issue.isOpen();
case "String_Node_Str":
return isPullRequest(issue) && issue.isOpen();
default :
return false;
}
}

Fixed version (ground truth):
private boolean satisfiesIsConditions(TurboIssue issue){
  if (!content.isPresent())   return false;
switch (content.get()) {
case "String_Node_Str":
case "String_Node_Str":
    return stateSatisfies(issue);
case "String_Node_Str":
case "String_Node_Str":
  return typeSatisfies(issue);
case "String_Node_Str":
return issue.isPullRequest() && !issue.isOpen();
case "String_Node_Str":
return issue.isPullRequest() && issue.isOpen();
default :
return false;
}
}
Program: 135375
Project: 135375
Buggy source:
public void updateIssueCheckTime(String date){
  this.lastIssueCheckTime=date;
}

Fixed version (ground truth):
public void updateIssueCheckTime(Date date){
  this.lastIssueCheckTime=date;
}
Program: 135376
Project: 135376
Buggy source:
public void updateModel(CountDownLatch latch,String repoId){
  logger.info("String_Node_Str");
  model.disableModelChanges();
  updateModelCollaborators(latch,repoId);
  updateModelLabels(latch,repoId);
  updateModelMilestones(latch,repoId);
  updateModelIssues(latch,repoId);
  lastUpdateTime=issueUpdateService.lastCheckTime;
  model.enableModelChanges();
}

Fixed version (ground truth):
public void updateModel(CountDownLatch latch,String repoId){
  logger.info("String_Node_Str");
  model.disableModelChanges();
  updateModelCollaborators(latch,repoId);
  updateModelLabels(latch,repoId);
  updateModelMilestones(latch,repoId);
  updateModelIssues(latch,repoId);
  lastUpdateTime=issueUpdateService.getUpdatedCheckTime();
  model.enableModelChanges();
}
Program: 135377
Project: 135377
Buggy source:
private void updateModelIssues(CountDownLatch latch,String repoId){
  if (model.getRepoId().generateId().equals(repoId)) {
    List<Issue> updatedIssues=issueUpdateService.getUpdatedItems(RepositoryId.createFromId(repoId));
    if (updatedIssues.size() > 0) {
      model.updateIssuesETag(issueUpdateService.getLastETag());
      model.updateIssueCheckTime(issueUpdateService.getLastIssueCheckTime());
      model.updateCachedIssues(latch,updatedIssues,repoId);
    }
 else {
      logger.info("String_Node_Str");
      latch.countDown();
    }
  }
}

Fixed version (ground truth):
private void updateModelIssues(CountDownLatch latch,String repoId){
  if (model.getRepoId().generateId().equals(repoId)) {
    List<Issue> updatedIssues=issueUpdateService.getUpdatedItems(RepositoryId.createFromId(repoId));
    if (updatedIssues.size() > 0) {
      model.updateIssuesETag(issueUpdateService.getUpdatedETag());
      model.updateIssueCheckTime(issueUpdateService.getUpdatedCheckTime());
      model.updateCachedIssues(latch,updatedIssues,repoId);
    }
 else {
      logger.info("String_Node_Str");
      latch.countDown();
    }
  }
}