nus-yam/ex-repair huggingface dataset:
Program: 14096
Project: 14096
Buggy source:
public static ResourceInfo getResourceInfo(StackResourceEntity stackResourceEntity) throws CloudFormationException {
  if (stackResourceEntity == null)   return null;
  ResourceInfo resourceInfo=new ResourceResolverManager().resolveResourceInfo(stackResourceEntity.getResourceType());
  resourceInfo.setAccountId(stackResourceEntity.getAccountId());
  resourceInfo.setAllowedByCondition(stackResourceEntity.getAllowedByCondition());
  resourceInfo.setDescription(stackResourceEntity.getDescription());
  resourceInfo.setDeletionPolicy(stackResourceEntity.getDeletionPolicy());
  resourceInfo.setLogicalResourceId(stackResourceEntity.getLogicalResourceId());
  resourceInfo.setMetadataJson(stackResourceEntity.getMetadataJson());
  resourceInfo.setPhysicalResourceId(stackResourceEntity.getPhysicalResourceId());
  resourceInfo.setPropertiesJson(stackResourceEntity.getPropertiesJson());
  resourceInfo.setReady(stackResourceEntity.getReady());
  resourceInfo.setReferenceValueJson(stackResourceEntity.getReferenceValueJson());
  resourceInfo.setUpdatePolicyJson(stackResourceEntity.getUpdatePolicyJson());
  ResourceInfoHelper.setResourceAttributesJson(resourceInfo,stackResourceEntity.getResourceAttributesJson());
  return resourceInfo;
}

Fixed version (ground truth):
public static ResourceInfo getResourceInfo(StackResourceEntity stackResourceEntity) throws CloudFormationException {
  if (stackResourceEntity == null)   return null;
  ResourceInfo resourceInfo=new ResourceResolverManager().resolveResourceInfo(stackResourceEntity.getResourceType());
  resourceInfo.setAccountId(stackResourceEntity.getAccountId());
  resourceInfo.setAllowedByCondition(stackResourceEntity.getAllowedByCondition());
  resourceInfo.setCreatedEnoughToDelete(stackResourceEntity.getCreatedEnoughToDelete());
  resourceInfo.setDescription(stackResourceEntity.getDescription());
  resourceInfo.setDeletionPolicy(stackResourceEntity.getDeletionPolicy());
  resourceInfo.setLogicalResourceId(stackResourceEntity.getLogicalResourceId());
  resourceInfo.setMetadataJson(stackResourceEntity.getMetadataJson());
  resourceInfo.setPhysicalResourceId(stackResourceEntity.getPhysicalResourceId());
  resourceInfo.setPropertiesJson(stackResourceEntity.getPropertiesJson());
  resourceInfo.setReady(stackResourceEntity.getReady());
  resourceInfo.setReferenceValueJson(stackResourceEntity.getReferenceValueJson());
  resourceInfo.setUpdatePolicyJson(stackResourceEntity.getUpdatePolicyJson());
  ResourceInfoHelper.setResourceAttributesJson(resourceInfo,stackResourceEntity.getResourceAttributesJson());
  return resourceInfo;
}
Program: 14097
Project: 14097
Buggy source:
public static void copyStackResourceEntityData(StackResourceEntity sourceEntity,StackResourceEntity destEntity){
  destEntity.setRecordDeleted(sourceEntity.getRecordDeleted());
  destEntity.setDescription(sourceEntity.getDescription());
  destEntity.setLogicalResourceId(sourceEntity.getLogicalResourceId());
  destEntity.setPhysicalResourceId(sourceEntity.getPhysicalResourceId());
  destEntity.setInternalPhysicalResourceUuid(sourceEntity.getInternalPhysicalResourceUuid());
  destEntity.setResourceStatus(sourceEntity.getResourceStatus());
  destEntity.setResourceStatusReason(sourceEntity.getResourceStatusReason());
  destEntity.setResourceType(sourceEntity.getResourceType());
  destEntity.setStackId(sourceEntity.getStackId());
  destEntity.setStackName(sourceEntity.getStackName());
  destEntity.setAccountId(sourceEntity.getAccountId());
  destEntity.setMetadataJson(sourceEntity.getMetadataJson());
  destEntity.setReady(sourceEntity.getReady());
  destEntity.setPropertiesJson(sourceEntity.getPropertiesJson());
  destEntity.setUpdatePolicyJson(sourceEntity.getUpdatePolicyJson());
  destEntity.setDeletionPolicy(sourceEntity.getDeletionPolicy());
  destEntity.setAllowedByCondition(sourceEntity.getAllowedByCondition());
  destEntity.setReferenceValueJson(sourceEntity.getReferenceValueJson());
  destEntity.setResourceAttributesJson(sourceEntity.getResourceAttributesJson());
  destEntity.setResourceVersion(sourceEntity.getResourceVersion());
}

Fixed version (ground truth):
public static void copyStackResourceEntityData(StackResourceEntity sourceEntity,StackResourceEntity destEntity){
  destEntity.setRecordDeleted(sourceEntity.getRecordDeleted());
  destEntity.setCreatedEnoughToDelete(sourceEntity.getCreatedEnoughToDelete());
  destEntity.setFromUpdateReplacement(sourceEntity.getFromUpdateReplacement());
  destEntity.setDescription(sourceEntity.getDescription());
  destEntity.setLogicalResourceId(sourceEntity.getLogicalResourceId());
  destEntity.setPhysicalResourceId(sourceEntity.getPhysicalResourceId());
  destEntity.setResourceStatus(sourceEntity.getResourceStatus());
  destEntity.setResourceStatusReason(sourceEntity.getResourceStatusReason());
  destEntity.setResourceType(sourceEntity.getResourceType());
  destEntity.setStackId(sourceEntity.getStackId());
  destEntity.setStackName(sourceEntity.getStackName());
  destEntity.setAccountId(sourceEntity.getAccountId());
  destEntity.setMetadataJson(sourceEntity.getMetadataJson());
  destEntity.setReady(sourceEntity.getReady());
  destEntity.setPropertiesJson(sourceEntity.getPropertiesJson());
  destEntity.setUpdatePolicyJson(sourceEntity.getUpdatePolicyJson());
  destEntity.setDeletionPolicy(sourceEntity.getDeletionPolicy());
  destEntity.setAllowedByCondition(sourceEntity.getAllowedByCondition());
  destEntity.setReferenceValueJson(sourceEntity.getReferenceValueJson());
  destEntity.setResourceAttributesJson(sourceEntity.getResourceAttributesJson());
  destEntity.setResourceVersion(sourceEntity.getResourceVersion());
}
Program: 14098
Project: 14098
Buggy source:
public abstract Promise<String> getCreatePromise(WorkflowOperations<StackActivity> workflowOperations,String resourceId,String stackId,String accountId,String effectiveUserId);

Fixed version (ground truth):
public abstract Promise<String> getCreatePromise(WorkflowOperations<StackActivityClient> workflowOperations,String resourceId,String stackId,String accountId,String effectiveUserId);
Program: 14099
Project: 14099
Buggy source:
public abstract Promise<String> getDeletePromise(WorkflowOperations<StackActivity> workflowOperations,String resourceId,String stackId,String accountId,String effectiveUserId);

Fixed version (ground truth):
public abstract Promise<String> getDeletePromise(WorkflowOperations<StackActivityClient> workflowOperations,String resourceId,String stackId,String accountId,String effectiveUserId);
Program: 14100
Project: 14100
Buggy source:
@Override public Promise<String> getCreatePromise(WorkflowOperations<StackActivity> workflowOperations,String resourceId,String stackId,String accountId,String effectiveUserId){
  List<String> stepIds=Lists.transform(Lists.newArrayList(CreateSteps.values()),StepTransform.INSTANCE);
  return new CreateMultiStepPromise(workflowOperations,stepIds,this).getCreatePromise(resourceId,stackId,accountId,effectiveUserId);
}

Fixed version (ground truth):
@Override public Promise<String> getCreatePromise(WorkflowOperations<StackActivityClient> workflowOperations,String resourceId,String stackId,String accountId,String effectiveUserId){
  List<String> stepIds=Lists.transform(Lists.newArrayList(CreateSteps.values()),StepTransform.INSTANCE);
  return new CreateMultiStepPromise(workflowOperations,stepIds,this).getCreatePromise(resourceId,stackId,accountId,effectiveUserId);
}
Program: 14101
Project: 14101
Buggy source:
@Override public Promise<String> getDeletePromise(WorkflowOperations<StackActivity> workflowOperations,String resourceId,String stackId,String accountId,String effectiveUserId){
  List<String> stepIds=Lists.transform(Lists.newArrayList(DeleteSteps.values()),StepTransform.INSTANCE);
  return new DeleteMultiStepPromise(workflowOperations,stepIds,this).getDeletePromise(resourceId,stackId,accountId,effectiveUserId);
}

Fixed version (ground truth):
@Override public Promise<String> getDeletePromise(WorkflowOperations<StackActivityClient> workflowOperations,String resourceId,String stackId,String accountId,String effectiveUserId){
  List<String> stepIds=Lists.transform(Lists.newArrayList(DeleteSteps.values()),StepTransform.INSTANCE);
  return new DeleteMultiStepPromise(workflowOperations,stepIds,this).getDeletePromise(resourceId,stackId,accountId,effectiveUserId);
}
Program: 14102
Project: 14102
Buggy source:
@Override public Promise<String> getCreatePromise(WorkflowOperations<StackActivity> workflowOperations,String resourceId,String stackId,String accountId,String effectiveUserId){
  List<String> stepIds=Lists.transform(Lists.newArrayList(CreateSteps.values()),StepTransform.INSTANCE);
  return new CreateMultiStepPromise(workflowOperations,stepIds,this).getCreatePromise(resourceId,stackId,accountId,effectiveUserId);
}

Fixed version (ground truth):
@Override public Promise<String> getCreatePromise(WorkflowOperations<StackActivityClient> workflowOperations,String resourceId,String stackId,String accountId,String effectiveUserId){
  List<String> stepIds=Lists.transform(Lists.newArrayList(CreateSteps.values()),StepTransform.INSTANCE);
  return new CreateMultiStepPromise(workflowOperations,stepIds,this).getCreatePromise(resourceId,stackId,accountId,effectiveUserId);
}
Program: 14103
Project: 14103
Buggy source:
@Override public Promise<String> getDeletePromise(WorkflowOperations<StackActivity> workflowOperations,String resourceId,String stackId,String accountId,String effectiveUserId){
  List<String> stepIds=Lists.transform(Lists.newArrayList(DeleteSteps.values()),StepTransform.INSTANCE);
  return new DeleteMultiStepPromise(workflowOperations,stepIds,this).getDeletePromise(resourceId,stackId,accountId,effectiveUserId);
}

Fixed version (ground truth):
@Override public Promise<String> getDeletePromise(WorkflowOperations<StackActivityClient> workflowOperations,String resourceId,String stackId,String accountId,String effectiveUserId){
  List<String> stepIds=Lists.transform(Lists.newArrayList(DeleteSteps.values()),StepTransform.INSTANCE);
  return new DeleteMultiStepPromise(workflowOperations,stepIds,this).getDeletePromise(resourceId,stackId,accountId,effectiveUserId);
}
Program: 14104
Project: 14104
Buggy source:
@Override public Promise<String> getCreatePromise(WorkflowOperations<StackActivity> workflowOperations,String resourceId,String stackId,String accountId,String effectiveUserId){
  List<String> stepIds=Lists.transform(Lists.newArrayList(CreateSteps.values()),StepTransform.INSTANCE);
  return new CreateMultiStepPromise(workflowOperations,stepIds,this).getCreatePromise(resourceId,stackId,accountId,effectiveUserId);
}

Fixed version (ground truth):
@Override public Promise<String> getCreatePromise(WorkflowOperations<StackActivityClient> workflowOperations,String resourceId,String stackId,String accountId,String effectiveUserId){
  List<String> stepIds=Lists.transform(Lists.newArrayList(CreateSteps.values()),StepTransform.INSTANCE);
  return new CreateMultiStepPromise(workflowOperations,stepIds,this).getCreatePromise(resourceId,stackId,accountId,effectiveUserId);
}
Program: 14105
Project: 14105
Buggy source:
@Override public Promise<String> getDeletePromise(WorkflowOperations<StackActivity> workflowOperations,String resourceId,String stackId,String accountId,String effectiveUserId){
  List<String> stepIds=Lists.transform(Lists.newArrayList(DeleteSteps.values()),StepTransform.INSTANCE);
  return new DeleteMultiStepPromise(workflowOperations,stepIds,this).getDeletePromise(resourceId,stackId,accountId,effectiveUserId);
}

Fixed version (ground truth):
@Override public Promise<String> getDeletePromise(WorkflowOperations<StackActivityClient> workflowOperations,String resourceId,String stackId,String accountId,String effectiveUserId){
  List<String> stepIds=Lists.transform(Lists.newArrayList(DeleteSteps.values()),StepTransform.INSTANCE);
  return new DeleteMultiStepPromise(workflowOperations,stepIds,this).getDeletePromise(resourceId,stackId,accountId,effectiveUserId);
}
Program: 14106
Project: 14106
Buggy source:
@Override public Promise<String> getCreatePromise(WorkflowOperations<StackActivity> workflowOperations,String resourceId,String stackId,String accountId,String effectiveUserId){
  List<String> stepIds=Lists.transform(Lists.newArrayList(CreateSteps.values()),StepTransform.INSTANCE);
  return new CreateMultiStepPromise(workflowOperations,stepIds,this).getCreatePromise(resourceId,stackId,accountId,effectiveUserId);
}

Fixed version (ground truth):
@Override public Promise<String> getCreatePromise(WorkflowOperations<StackActivityClient> workflowOperations,String resourceId,String stackId,String accountId,String effectiveUserId){
  List<String> stepIds=Lists.transform(Lists.newArrayList(CreateSteps.values()),StepTransform.INSTANCE);
  return new CreateMultiStepPromise(workflowOperations,stepIds,this).getCreatePromise(resourceId,stackId,accountId,effectiveUserId);
}
Program: 14107
Project: 14107
Buggy source:
@Override public Promise<String> getDeletePromise(WorkflowOperations<StackActivity> workflowOperations,String resourceId,String stackId,String accountId,String effectiveUserId){
  List<String> stepIds=Lists.transform(Lists.newArrayList(DeleteSteps.values()),StepTransform.INSTANCE);
  return new DeleteMultiStepPromise(workflowOperations,stepIds,this).getDeletePromise(resourceId,stackId,accountId,effectiveUserId);
}

Fixed version (ground truth):
@Override public Promise<String> getDeletePromise(WorkflowOperations<StackActivityClient> workflowOperations,String resourceId,String stackId,String accountId,String effectiveUserId){
  List<String> stepIds=Lists.transform(Lists.newArrayList(DeleteSteps.values()),StepTransform.INSTANCE);
  return new DeleteMultiStepPromise(workflowOperations,stepIds,this).getDeletePromise(resourceId,stackId,accountId,effectiveUserId);
}
Program: 14108
Project: 14108
Buggy source:
@Override public Promise<String> getCreatePromise(WorkflowOperations<StackActivity> workflowOperations,String resourceId,String stackId,String accountId,String effectiveUserId){
  List<String> stepIds=Lists.transform(Lists.newArrayList(CreateSteps.values()),StepTransform.INSTANCE);
  return new CreateMultiStepPromise(workflowOperations,stepIds,this).getCreatePromise(resourceId,stackId,accountId,effectiveUserId);
}

Fixed version (ground truth):
@Override public Promise<String> getCreatePromise(WorkflowOperations<StackActivityClient> workflowOperations,String resourceId,String stackId,String accountId,String effectiveUserId){
  List<String> stepIds=Lists.transform(Lists.newArrayList(CreateSteps.values()),StepTransform.INSTANCE);
  return new CreateMultiStepPromise(workflowOperations,stepIds,this).getCreatePromise(resourceId,stackId,accountId,effectiveUserId);
}
Program: 14109
Project: 14109
Buggy source:
@Override public Promise<String> getDeletePromise(WorkflowOperations<StackActivity> workflowOperations,String resourceId,String stackId,String accountId,String effectiveUserId){
  List<String> stepIds=Lists.transform(Lists.newArrayList(DeleteSteps.values()),StepTransform.INSTANCE);
  return new DeleteMultiStepPromise(workflowOperations,stepIds,this).getDeletePromise(resourceId,stackId,accountId,effectiveUserId);
}

Fixed version (ground truth):
@Override public Promise<String> getDeletePromise(WorkflowOperations<StackActivityClient> workflowOperations,String resourceId,String stackId,String accountId,String effectiveUserId){
  List<String> stepIds=Lists.transform(Lists.newArrayList(DeleteSteps.values()),StepTransform.INSTANCE);
  return new DeleteMultiStepPromise(workflowOperations,stepIds,this).getDeletePromise(resourceId,stackId,accountId,effectiveUserId);
}
Program: 14110
Project: 14110
Buggy source:
@Override public Promise<String> getCreatePromise(WorkflowOperations<StackActivity> workflowOperations,String resourceId,String stackId,String accountId,String effectiveUserId){
  return new AWSCloudFormationWaitConditionCreatePromise(workflowOperations,CreateSteps.CREATE_WAIT_CONDITION.name()).getCreatePromise(resourceId,stackId,accountId,effectiveUserId);
}

Fixed version (ground truth):
@Override public Promise<String> getCreatePromise(WorkflowOperations<StackActivityClient> workflowOperations,String resourceId,String stackId,String accountId,String effectiveUserId){
  return new AWSCloudFormationWaitConditionCreatePromise(workflowOperations,CreateSteps.CREATE_WAIT_CONDITION.name()).getCreatePromise(resourceId,stackId,accountId,effectiveUserId);
}
Program: 14111
Project: 14111
Buggy source:
@Override public Promise<String> getDeletePromise(WorkflowOperations<StackActivity> workflowOperations,String resourceId,String stackId,String accountId,String effectiveUserId){
  List<String> stepIds=Lists.transform(Lists.newArrayList(DeleteSteps.values()),StepTransform.INSTANCE);
  return new DeleteMultiStepPromise(workflowOperations,stepIds,this).getDeletePromise(resourceId,stackId,accountId,effectiveUserId);
}

Fixed version (ground truth):
@Override public Promise<String> getDeletePromise(WorkflowOperations<StackActivityClient> workflowOperations,String resourceId,String stackId,String accountId,String effectiveUserId){
  List<String> stepIds=Lists.transform(Lists.newArrayList(DeleteSteps.values()),StepTransform.INSTANCE);
  return new DeleteMultiStepPromise(workflowOperations,stepIds,this).getDeletePromise(resourceId,stackId,accountId,effectiveUserId);
}
Program: 14112
Project: 14112
Buggy source:
@Override public Promise<String> getCreatePromise(WorkflowOperations<StackActivity> workflowOperations,String resourceId,String stackId,String accountId,String effectiveUserId){
  List<String> stepIds=Lists.transform(Lists.newArrayList(CreateSteps.values()),StepTransform.INSTANCE);
  return new CreateMultiStepPromise(workflowOperations,stepIds,this).getCreatePromise(resourceId,stackId,accountId,effectiveUserId);
}

Fixed version (ground truth):
@Override public Promise<String> getCreatePromise(WorkflowOperations<StackActivityClient> workflowOperations,String resourceId,String stackId,String accountId,String effectiveUserId){
  List<String> stepIds=Lists.transform(Lists.newArrayList(CreateSteps.values()),StepTransform.INSTANCE);
  return new CreateMultiStepPromise(workflowOperations,stepIds,this).getCreatePromise(resourceId,stackId,accountId,effectiveUserId);
}
Program: 14113
Project: 14113
Buggy source:
@Override public Promise<String> getDeletePromise(WorkflowOperations<StackActivity> workflowOperations,String resourceId,String stackId,String accountId,String effectiveUserId){
  List<String> stepIds=Lists.transform(Lists.newArrayList(DeleteSteps.values()),StepTransform.INSTANCE);
  return new DeleteMultiStepPromise(workflowOperations,stepIds,this).getDeletePromise(resourceId,stackId,accountId,effectiveUserId);
}

Fixed version (ground truth):
@Override public Promise<String> getDeletePromise(WorkflowOperations<StackActivityClient> workflowOperations,String resourceId,String stackId,String accountId,String effectiveUserId){
  List<String> stepIds=Lists.transform(Lists.newArrayList(DeleteSteps.values()),StepTransform.INSTANCE);
  return new DeleteMultiStepPromise(workflowOperations,stepIds,this).getDeletePromise(resourceId,stackId,accountId,effectiveUserId);
}
Program: 14114
Project: 14114
Buggy source:
@Override public Promise<String> getCreatePromise(WorkflowOperations<StackActivity> workflowOperations,String resourceId,String stackId,String accountId,String effectiveUserId){
  List<String> stepIds=Lists.transform(Lists.newArrayList(CreateSteps.values()),StepTransform.INSTANCE);
  return new CreateMultiStepPromise(workflowOperations,stepIds,this).getCreatePromise(resourceId,stackId,accountId,effectiveUserId);
}

Fixed version (ground truth):
@Override public Promise<String> getCreatePromise(WorkflowOperations<StackActivityClient> workflowOperations,String resourceId,String stackId,String accountId,String effectiveUserId){
  List<String> stepIds=Lists.transform(Lists.newArrayList(CreateSteps.values()),StepTransform.INSTANCE);
  return new CreateMultiStepPromise(workflowOperations,stepIds,this).getCreatePromise(resourceId,stackId,accountId,effectiveUserId);
}
Program: 14115
Project: 14115
Buggy source:
@Override public Promise<String> getDeletePromise(WorkflowOperations<StackActivity> workflowOperations,String resourceId,String stackId,String accountId,String effectiveUserId){
  List<String> stepIds=Lists.transform(Lists.newArrayList(DeleteSteps.values()),StepTransform.INSTANCE);
  return new DeleteMultiStepPromise(workflowOperations,stepIds,this).getDeletePromise(resourceId,stackId,accountId,effectiveUserId);
}

Fixed version (ground truth):
@Override public Promise<String> getDeletePromise(WorkflowOperations<StackActivityClient> workflowOperations,String resourceId,String stackId,String accountId,String effectiveUserId){
  List<String> stepIds=Lists.transform(Lists.newArrayList(DeleteSteps.values()),StepTransform.INSTANCE);
  return new DeleteMultiStepPromise(workflowOperations,stepIds,this).getDeletePromise(resourceId,stackId,accountId,effectiveUserId);
}
Program: 14116
Project: 14116
Buggy source:
@Override public Promise<String> getCreatePromise(WorkflowOperations<StackActivity> workflowOperations,String resourceId,String stackId,String accountId,String effectiveUserId){
  List<String> stepIds=Lists.transform(Lists.newArrayList(CreateSteps.values()),StepTransform.INSTANCE);
  return new CreateMultiStepPromise(workflowOperations,stepIds,this).getCreatePromise(resourceId,stackId,accountId,effectiveUserId);
}

Fixed version (ground truth):
@Override public Promise<String> getCreatePromise(WorkflowOperations<StackActivityClient> workflowOperations,String resourceId,String stackId,String accountId,String effectiveUserId){
  List<String> stepIds=Lists.transform(Lists.newArrayList(CreateSteps.values()),StepTransform.INSTANCE);
  return new CreateMultiStepPromise(workflowOperations,stepIds,this).getCreatePromise(resourceId,stackId,accountId,effectiveUserId);
}
Program: 14117
Project: 14117
Buggy source:
@Override public Promise<String> getDeletePromise(WorkflowOperations<StackActivity> workflowOperations,String resourceId,String stackId,String accountId,String effectiveUserId){
  List<String> stepIds=Lists.transform(Lists.newArrayList(DeleteSteps.values()),StepTransform.INSTANCE);
  return new DeleteMultiStepPromise(workflowOperations,stepIds,this).getDeletePromise(resourceId,stackId,accountId,effectiveUserId);
}

Fixed version (ground truth):
@Override public Promise<String> getDeletePromise(WorkflowOperations<StackActivityClient> workflowOperations,String resourceId,String stackId,String accountId,String effectiveUserId){
  List<String> stepIds=Lists.transform(Lists.newArrayList(DeleteSteps.values()),StepTransform.INSTANCE);
  return new DeleteMultiStepPromise(workflowOperations,stepIds,this).getDeletePromise(resourceId,stackId,accountId,effectiveUserId);
}
Program: 14119
Project: 14119
Buggy source:
public MetadataRequest(String requestIp,String requestUrl,Optional<String> vmId){
  try {
    this.requestIp=requestIp;
    requestUrl=requestUrl.replaceAll("String_Node_Str","String_Node_Str");
    String[] path=requestUrl.split("String_Node_Str",2);
    if (path.length > 0) {
      this.metadataName=path[0];
      if (path.length > 1) {
        this.localPath=path[1].replaceFirst("String_Node_Str","String_Node_Str");
      }
 else {
        this.localPath="String_Node_Str";
      }
    }
 else {
      this.metadataName="String_Node_Str";
      this.localPath="String_Node_Str";
    }
    this.vmId=vmId.orNull();
  }
  finally {
    LOG.debug((this.vmId != null ? "String_Node_Str" : "String_Node_Str") + "String_Node_Str" + this.requestIp+ "String_Node_Str"+ this.metadataName+ "String_Node_Str"+ this.localPath+ "String_Node_Str"+ requestUrl);
  }
}

Fixed version (ground truth):
public MetadataRequest(String requestIp,String requestUrl,Optional<String> vmId){
  this.requestIp=requestIp;
  requestUrl=requestUrl.replaceAll("String_Node_Str","String_Node_Str");
  String[] path=requestUrl.split("String_Node_Str",2);
  if (path.length > 0) {
    this.metadataName=path[0];
    if (path.length > 1) {
      this.localPath=path[1].replaceFirst("String_Node_Str","String_Node_Str");
    }
 else {
      this.localPath="String_Node_Str";
    }
  }
 else {
    this.metadataName="String_Node_Str";
    this.localPath="String_Node_Str";
  }
  this.vmId=vmId.orNull();
  LOG.debug((this.vmId != null ? "String_Node_Str" : "String_Node_Str") + "String_Node_Str" + this.requestIp+ "String_Node_Str"+ this.metadataName+ "String_Node_Str"+ this.localPath+ "String_Node_Str"+ requestUrl);
}
Program: 14122
Project: 14122
Buggy source:
@Override public boolean apply(@Nullable final T t){
  if (t != null)   identifiers.remove(idFunction.apply(t));
  return true;
}

Fixed version (ground truth):
@Override public boolean apply(@Nullable final T t){
  if (t != null) {
    while (identifiers.remove(idFunction.apply(t)))     ;
  }
  return true;
}
Program: 14123
Project: 14123
Buggy source:
public synchronized void updateBackendProgress(final int percentComplete){
  int progress=(int)percentComplete / 2;
  if (progress >= 50 || (progress - this.backendProgress < PROGRESS_TICK)) {
    return;
  }
 else {
    this.backendProgress=percentComplete;
    this.lastProgress=this.backendProgress + this.uploadProgress;
    Threads.enqueue(scConfig,SnapshotProgressCallback.class,1,new ProgressSetter(this.snapshotId,this.lastProgress));
  }
}

Fixed version (ground truth):
public synchronized void updateBackendProgress(final int percentComplete){
  int progress=(int)percentComplete / 2;
  if (progress >= 50 || (progress - this.backendProgress < PROGRESS_TICK)) {
    return;
  }
 else {
    this.backendProgress=progress;
    this.lastProgress=this.backendProgress + this.uploadProgress;
    Threads.enqueue(scConfig,SnapshotProgressCallback.class,1,new ProgressSetter(this.snapshotId,this.lastProgress));
  }
}
Program: 14125
Project: 14125
Buggy source:
public static List<String> getSubnetIds(String effectiveUserId) throws Exception {
  List<String> retVal=Lists.newArrayList();
  ServiceConfiguration configuration=Topology.lookup(Compute.class);
  DescribeSubnetsType describeSubnetsType=MessageHelper.createMessage(DescribeSubnetsType.class,effectiveUserId);
  DescribeSubnetsResponseType describeSubnetsResponseType=AsyncRequests.<DescribeSubnetsType,DescribeSubnetsResponseType>sendSync(configuration,describeSubnetsType);
  if (describeSubnetsResponseType != null && describeSubnetsResponseType.getSubnetSet() != null && describeSubnetsResponseType.getSubnetSet().getItem() != null) {
    for (    SubnetType subnetType : describeSubnetsResponseType.getSubnetSet().getItem()) {
      retVal.add(subnetType.getSubnetId());
    }
  }
  return retVal;
}

Fixed version (ground truth):
public static List<String> getSubnetIds(String effectiveUserId) throws AccessDeniedException {
  List<String> retVal=Lists.newArrayList();
  ServiceConfiguration configuration=Topology.lookup(Compute.class);
  try {
    DescribeSubnetsType describeSubnetsType=MessageHelper.createMessage(DescribeSubnetsType.class,effectiveUserId);
    DescribeSubnetsResponseType describeSubnetsResponseType=AsyncRequests.<DescribeSubnetsType,DescribeSubnetsResponseType>sendSync(configuration,describeSubnetsType);
    if (describeSubnetsResponseType != null && describeSubnetsResponseType.getSubnetSet() != null && describeSubnetsResponseType.getSubnetSet().getItem() != null) {
      for (      SubnetType subnetType : describeSubnetsResponseType.getSubnetSet().getItem()) {
        retVal.add(subnetType.getSubnetId());
      }
    }
  }
 catch (  Exception e) {
    Throwable rootCause=Throwables.getRootCause(e);
    throw new AccessDeniedException("String_Node_Str" + (rootCause.getMessage() == null ? "String_Node_Str" : rootCause.getMessage()));
  }
  return retVal;
}
Program: 14126
Project: 14126
Buggy source:
public static List<String> getKeyPairKeyNames(String effectiveUserId) throws Exception {
  List<String> retVal=Lists.newArrayList();
  ServiceConfiguration configuration=Topology.lookup(Compute.class);
  DescribeKeyPairsType describeKeyPairsType=MessageHelper.createMessage(DescribeKeyPairsType.class,effectiveUserId);
  DescribeKeyPairsResponseType describeKeyPairsResponseType=AsyncRequests.<DescribeKeyPairsType,DescribeKeyPairsResponseType>sendSync(configuration,describeKeyPairsType);
  if (describeKeyPairsResponseType != null && describeKeyPairsResponseType.getKeySet() != null) {
    for (    DescribeKeyPairsResponseItemType describeKeyPairsResponseItemType : describeKeyPairsResponseType.getKeySet()) {
      retVal.add(describeKeyPairsResponseItemType.getKeyName());
    }
  }
  return retVal;
}

Fixed version (ground truth):
public static List<String> getKeyPairKeyNames(String effectiveUserId) throws AccessDeniedException {
  List<String> retVal=Lists.newArrayList();
  ServiceConfiguration configuration=Topology.lookup(Compute.class);
  try {
    DescribeKeyPairsType describeKeyPairsType=MessageHelper.createMessage(DescribeKeyPairsType.class,effectiveUserId);
    DescribeKeyPairsResponseType describeKeyPairsResponseType=AsyncRequests.<DescribeKeyPairsType,DescribeKeyPairsResponseType>sendSync(configuration,describeKeyPairsType);
    if (describeKeyPairsResponseType != null && describeKeyPairsResponseType.getKeySet() != null) {
      for (      DescribeKeyPairsResponseItemType describeKeyPairsResponseItemType : describeKeyPairsResponseType.getKeySet()) {
        retVal.add(describeKeyPairsResponseItemType.getKeyName());
      }
    }
  }
 catch (  Exception e) {
    Throwable rootCause=Throwables.getRootCause(e);
    throw new AccessDeniedException("String_Node_Str" + (rootCause.getMessage() == null ? "String_Node_Str" : rootCause.getMessage()));
  }
  return retVal;
}
Program: 14127
Project: 14127
Buggy source:
public static List<String> getSecurityGroupIds(String effectiveUserId) throws Exception {
  List<String> retVal=Lists.newArrayList();
  ServiceConfiguration configuration=Topology.lookup(Compute.class);
  DescribeSecurityGroupsType describeSecurityGroupsType=MessageHelper.createMessage(DescribeSecurityGroupsType.class,effectiveUserId);
  DescribeSecurityGroupsResponseType describeSecurityGroupsResponseType=AsyncRequests.<DescribeSecurityGroupsType,DescribeSecurityGroupsResponseType>sendSync(configuration,describeSecurityGroupsType);
  if (describeSecurityGroupsResponseType != null && describeSecurityGroupsResponseType.getSecurityGroupInfo() != null) {
    for (    SecurityGroupItemType securityGroupItemType : describeSecurityGroupsResponseType.getSecurityGroupInfo()) {
      retVal.add(securityGroupItemType.getGroupId());
    }
  }
  return retVal;
}

Fixed version (ground truth):
public static List<String> getSecurityGroupIds(String effectiveUserId) throws AccessDeniedException {
  List<String> retVal=Lists.newArrayList();
  ServiceConfiguration configuration=Topology.lookup(Compute.class);
  try {
    DescribeSecurityGroupsType describeSecurityGroupsType=MessageHelper.createMessage(DescribeSecurityGroupsType.class,effectiveUserId);
    DescribeSecurityGroupsResponseType describeSecurityGroupsResponseType=AsyncRequests.<DescribeSecurityGroupsType,DescribeSecurityGroupsResponseType>sendSync(configuration,describeSecurityGroupsType);
    if (describeSecurityGroupsResponseType != null && describeSecurityGroupsResponseType.getSecurityGroupInfo() != null) {
      for (      SecurityGroupItemType securityGroupItemType : describeSecurityGroupsResponseType.getSecurityGroupInfo()) {
        retVal.add(securityGroupItemType.getGroupId());
      }
    }
  }
 catch (  Exception e) {
    Throwable rootCause=Throwables.getRootCause(e);
    throw new AccessDeniedException("String_Node_Str" + (rootCause.getMessage() == null ? "String_Node_Str" : rootCause.getMessage()));
  }
  return retVal;
}
Program: 14129
Project: 14129
Buggy source:
@Override public DeleteBucketResponseType deleteBucket(DeleteBucketType request) throws WalrusException {
  DeleteBucketResponseType reply=(DeleteBucketResponseType)request.getReply();
  String bucketName=request.getBucket();
  try (TransactionResource tr=Entities.transactionFor(BucketInfo.class)){
    BucketInfo bucketInfo=Entities.uniqueResult(new BucketInfo(bucketName));
    ObjectInfo searchObject=new ObjectInfo();
    searchObject.setBucketName(bucketName);
    List<ObjectInfo> objects=Transactions.findAll(searchObject);
    if (objects != null && !objects.isEmpty()) {
      tr.commit();
      throw new BucketNotEmptyException(bucketName);
    }
 else {
      Entities.delete(bucketInfo);
      Threads.lookup(WalrusBackend.class,WalrusFSManager.ObjectDeleter.class).limitTo(10).submit(new BucketDeleter(bucketName));
    }
    tr.commit();
  }
 catch (  NoSuchElementException e) {
    throw new NoSuchBucketException(bucketName);
  }
catch (  Exception e) {
    LOG.error("String_Node_Str" + bucketName,e);
    throw new InternalErrorException("String_Node_Str" + bucketName,e);
  }
  reply.setStatus(HttpResponseStatus.NO_CONTENT);
  reply.setStatusMessage("String_Node_Str");
  return reply;
}

Fixed version (ground truth):
@Override public DeleteBucketResponseType deleteBucket(DeleteBucketType request) throws WalrusException {
  DeleteBucketResponseType reply=(DeleteBucketResponseType)request.getReply();
  String bucketName=request.getBucket();
  try (TransactionResource tr=Entities.transactionFor(BucketInfo.class)){
    BucketInfo bucketInfo=Entities.uniqueResult(new BucketInfo(bucketName));
    ObjectInfo searchObject=new ObjectInfo();
    searchObject.setBucketName(bucketName);
    List<ObjectInfo> objects=Transactions.findAll(searchObject);
    if (objects != null && !objects.isEmpty()) {
      tr.commit();
      throw new BucketNotEmptyException(bucketName);
    }
 else {
      Entities.delete(bucketInfo);
      Threads.lookup(WalrusBackend.class,WalrusFSManager.ObjectDeleter.class).limitTo(10).submit(new BucketDeleter(bucketName));
    }
    tr.commit();
  }
 catch (  NoSuchElementException e) {
    throw new NoSuchBucketException(bucketName);
  }
catch (  BucketNotEmptyException e) {
    throw e;
  }
catch (  Exception e) {
    LOG.error("String_Node_Str" + bucketName,e);
    throw new InternalErrorException("String_Node_Str" + bucketName,e);
  }
  reply.setStatus(HttpResponseStatus.NO_CONTENT);
  reply.setStatusMessage("String_Node_Str");
  return reply;
}
Program: 14131
Project: 14131
Buggy source:
@Override public boolean canApply(String action){
  if (PolicySpec.qualifiedName(PolicySpec.VENDOR_EC2,PolicySpec.EC2_RUNINSTANCES).equals(action)) {
    return true;
  }
  return false;
}

Fixed version (ground truth):
@Override public boolean canApply(String action,String resourceType){
  if (PolicySpec.qualifiedName(PolicySpec.VENDOR_EC2,PolicySpec.EC2_RUNINSTANCES).equals(action) && PolicySpec.qualifiedName(PolicySpec.VENDOR_EC2,POLICY_RESOURCE_TYPE).equals(resourceType)) {
    return true;
  }
  return false;
}
Program: 14132
Project: 14132
Buggy source:
@Override public boolean canApply(String action){
  if (PolicySpec.qualifiedName(PolicySpec.VENDOR_EC2,PolicySpec.EC2_RUNINSTANCES).equals(action)) {
    return true;
  }
  return false;
}

Fixed version (ground truth):
@Override public boolean canApply(String action,String resourceType){
  if (PolicySpec.qualifiedName(PolicySpec.VENDOR_EC2,PolicySpec.EC2_RUNINSTANCES).equals(action) && PolicySpec.qualifiedName(PolicySpec.VENDOR_EC2,POLICY_RESOURCE_TYPE).equals(resourceType)) {
    return true;
  }
  return false;
}
Program: 14133
Project: 14133
Buggy source:
@Override public boolean canApply(String action){
  if (PolicySpec.qualifiedName(PolicySpec.VENDOR_EC2,PolicySpec.EC2_RUNINSTANCES).equals(action)) {
    return true;
  }
  return false;
}

Fixed version (ground truth):
@Override public boolean canApply(String action,String resourceType){
  if (PolicySpec.qualifiedName(PolicySpec.VENDOR_EC2,PolicySpec.EC2_RUNINSTANCES).equals(action) && PolicySpec.qualifiedName(PolicySpec.VENDOR_EC2,POLICY_RESOURCE_TYPE).equals(resourceType)) {
    return true;
  }
  return false;
}
Program: 14134
Project: 14134
Buggy source:
@Override public boolean canApply(String action){
  if (PolicySpec.qualifiedName(PolicySpec.VENDOR_EC2,PolicySpec.EC2_RUNINSTANCES).equals(action)) {
    return true;
  }
  return false;
}

Fixed version (ground truth):
@Override public boolean canApply(String action,String resourceType){
  if (PolicySpec.qualifiedName(PolicySpec.VENDOR_EC2,PolicySpec.EC2_RUNINSTANCES).equals(action) && PolicySpec.qualifiedName(PolicySpec.VENDOR_EC2,POLICY_RESOURCE_TYPE).equals(resourceType)) {
    return true;
  }
  return false;
}
Program: 14142
Project: 14142
Buggy source:
@Override public SetBucketTaggingResponseType setBucketTagging(SetBucketTaggingType request) throws S3Exception {
  SetBucketTaggingResponseType reply=request.getReply();
  Bucket bucket=getBucketAndCheckAuthorization(request);
  try {
    TaggingConfiguration taggingConfiguration=request.getTaggingConfiguration();
    List<BucketTag> bucketTagList=taggingConfiguration.getBucketTagSet().getBucketTags();
    if (bucketTagList.isEmpty() || bucketTagList.size() > 10) {
      throw new MalformedXMLException();
    }
    BucketTaggingManagers.getInstance().addBucketTagging(bucketTagList,bucket.getBucketUuid());
  }
 catch (  Exception ex) {
    if (ex instanceof MalformedXMLException) {
      throw new MalformedXMLException(bucket.getBucketName());
    }
 else     if (ex instanceof InvalidTagErrorException) {
      throw new InvalidTagErrorException(bucket.getBucketName());
    }
 else {
      LOG.error("String_Node_Str" + bucket.getBucketName() + "String_Node_Str",ex);
      InternalErrorException e=new InternalErrorException(bucket.getBucketName() + "String_Node_Str");
      e.setMessage("String_Node_Str" + bucket.getBucketName());
      throw e;
    }
  }
  return reply;
}

Fixed version (ground truth):
@Override public SetBucketTaggingResponseType setBucketTagging(SetBucketTaggingType request) throws S3Exception {
  SetBucketTaggingResponseType reply=request.getReply();
  Bucket bucket=getBucketAndCheckAuthorization(request);
  try {
    TaggingConfiguration taggingConfiguration=request.getTaggingConfiguration();
    List<BucketTag> bucketTagList=taggingConfiguration.getBucketTagSet().getBucketTags();
    if (bucketTagList.isEmpty() || bucketTagList.size() > 10) {
      throw new MalformedXMLException(bucket.getBucketName());
    }
    BucketTaggingManagers.getInstance().addBucketTagging(bucketTagList,bucket.getBucketUuid());
  }
 catch (  S3Exception ex) {
    LOG.error("String_Node_Str" + bucket.getBucketName() + "String_Node_Str",ex);
    throw ex;
  }
catch (  Exception ex) {
    LOG.error("String_Node_Str" + bucket.getBucketName() + "String_Node_Str",ex);
    InternalErrorException e=new InternalErrorException(bucket.getBucketName() + "String_Node_Str",ex);
    e.setMessage("String_Node_Str" + bucket.getBucketName());
    throw e;
  }
  reply.setStatus(HttpResponseStatus.NO_CONTENT);
  return reply;
}
Program: 14143
Project: 14143
Buggy source:
@Override public GetBucketTaggingResponseType getBucketTagging(GetBucketTaggingType request) throws S3Exception {
  GetBucketTaggingResponseType reply=(GetBucketTaggingResponseType)request.getReply();
  Bucket bucket=getBucketAndCheckAuthorization(request);
  try {
    TaggingConfiguration tagging=new TaggingConfiguration();
    List<BucketTag> bucketTagList=new ArrayList<>();
    List<BucketTags> bucketTagsList=BucketTaggingManagers.getInstance().getBucketTagging(bucket.getBucketUuid());
    if (bucketTagList.isEmpty()) {
      throw new NoSuchTagSetException();
    }
    for (    BucketTags bucketTags : bucketTagsList) {
      BucketTag bucketTag=new BucketTag();
      bucketTag.setKey(bucketTags.getKey());
      bucketTag.setValue(bucketTags.getValue());
      bucketTagList.add(bucketTag);
    }
    BucketTagSet tagSet=new BucketTagSet();
    tagSet.setBucketTags(bucketTagList);
    tagging.setBucketTagSet(tagSet);
    reply.setTaggingConfiguration(tagging);
  }
 catch (  Exception ex) {
    if (ex instanceof NoSuchTagSetException) {
      throw new NoSuchTagSetException(bucket.getBucketName());
    }
 else {
      LOG.error("String_Node_Str" + bucket.getBucketName() + "String_Node_Str",ex);
      InternalErrorException e=new InternalErrorException(bucket.getBucketName() + "String_Node_Str");
      e.setMessage("String_Node_Str" + bucket.getBucketName());
      throw e;
    }
  }
  return reply;
}

Fixed version (ground truth):
@Override public GetBucketTaggingResponseType getBucketTagging(GetBucketTaggingType request) throws S3Exception {
  GetBucketTaggingResponseType reply=(GetBucketTaggingResponseType)request.getReply();
  Bucket bucket=getBucketAndCheckAuthorization(request);
  try {
    TaggingConfiguration tagging=new TaggingConfiguration();
    List<BucketTag> bucketTagList=new ArrayList<>();
    List<BucketTags> bucketTagsList=BucketTaggingManagers.getInstance().getBucketTagging(bucket.getBucketUuid());
    if (bucketTagList.isEmpty()) {
      throw new NoSuchTagSetException(bucket.getBucketName());
    }
    for (    BucketTags bucketTags : bucketTagsList) {
      BucketTag bucketTag=new BucketTag();
      bucketTag.setKey(bucketTags.getKey());
      bucketTag.setValue(bucketTags.getValue());
      bucketTagList.add(bucketTag);
    }
    BucketTagSet tagSet=new BucketTagSet();
    tagSet.setBucketTags(bucketTagList);
    tagging.setBucketTagSet(tagSet);
    reply.setTaggingConfiguration(tagging);
  }
 catch (  S3Exception ex) {
    LOG.error("String_Node_Str" + bucket.getBucketName() + "String_Node_Str",ex);
    throw ex;
  }
catch (  Exception ex) {
    LOG.error("String_Node_Str" + bucket.getBucketName() + "String_Node_Str",ex);
    InternalErrorException e=new InternalErrorException(bucket.getBucketName() + "String_Node_Str",ex);
    e.setMessage("String_Node_Str" + bucket.getBucketName());
    throw e;
  }
  return reply;
}
Program: 14145
Project: 14145
Buggy source:
public void cleanFailedVolumes(){
  TransactionResource tran=Entities.transactionFor(VolumeInfo.class);
  VolumeInfo volumeInfo=new VolumeInfo();
  volumeInfo.setStatus(StorageProperties.Status.failed.toString());
  List<VolumeInfo> volumeInfos=Entities.query(volumeInfo);
  for (  VolumeInfo volInfo : volumeInfos) {
    String volumeId=volInfo.getVolumeId();
    LOG.info("String_Node_Str" + volumeId);
    blockManager.cleanVolume(volumeId);
  }
  tran.commit();
}

Fixed version (ground truth):
public void cleanFailedVolumes(){
  VolumeInfo volumeInfo=new VolumeInfo();
  volumeInfo.setStatus(StorageProperties.Status.failed.toString());
  List<VolumeInfo> volumeInfos=null;
  try {
    volumeInfos=Transactions.findAll(volumeInfo);
  }
 catch (  Exception e) {
    LOG.warn("String_Node_Str",e);
  }
  if (volumeInfos == null || volumeInfos.size() == 0) {
    LOG.info("String_Node_Str");
    return;
  }
  for (  VolumeInfo volInfo : volumeInfos) {
    try {
      LOG.info("String_Node_Str" + volInfo.getVolumeId());
      blockManager.cleanVolume(volInfo.getVolumeId());
      Transactions.delete(volInfo);
    }
 catch (    Exception e) {
      LOG.warn("String_Node_Str" + volInfo.getVolumeId(),e);
    }
  }
}
Program: 14150
Project: 14150
Buggy source:
@SuppressWarnings("String_Node_Str") private Class getBootstrapper(Class candidate) throws Exception {
  if (Modifier.isAbstract(candidate.getModifiers()))   throw new InstantiationException(candidate.getName() + "String_Node_Str");
  if (!Bootstrapper.class.isAssignableFrom(candidate))   throw new InstantiationException(candidate + "String_Node_Str" + Bootstrapper.class);
  LOG.trace("String_Node_Str" + candidate.getName());
  if (!Modifier.isPublic(candidate.getDeclaredConstructor(new Class[]{}).getModifiers())) {
    Method factory=candidate.getDeclaredMethod("String_Node_Str",new Class[]{});
    if (!Modifier.isStatic(factory.getModifiers()) || !Modifier.isPublic(factory.getModifiers())) {
      throw new InstantiationException(candidate.getCanonicalName() + "String_Node_Str");
    }
  }
  EventRecord.here(ServiceJarDiscovery.class,EventType.BOOTSTRAPPER_ADDED,candidate.getName()).info();
  return candidate;
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") private Class getBootstrapper(Class candidate) throws Exception {
  LOG.trace("String_Node_Str" + candidate.getName());
  if (!Modifier.isPublic(candidate.getDeclaredConstructor(new Class[]{}).getModifiers())) {
    Method factory=candidate.getDeclaredMethod("String_Node_Str",new Class[]{});
    if (!Modifier.isStatic(factory.getModifiers()) || !Modifier.isPublic(factory.getModifiers())) {
      throw BootstrapException.throwFatal(candidate.getCanonicalName() + "String_Node_Str");
    }
  }
  EventRecord.here(ServiceJarDiscovery.class,EventType.BOOTSTRAPPER_ADDED,candidate.getName()).info();
  return candidate;
}
Program: 14151
Project: 14151
Buggy source:
/** 
 * Find 
 * @see com.eucalyptus.bootstrap.ServiceJarDiscovery#processClass(java.lang.Class)
 * @param candidate
 * @return
 * @throws Exception
 */
@Override public boolean processClass(Class candidate) throws Exception {
  String bc=candidate.getCanonicalName();
  Class bootstrapper=this.getBootstrapper(candidate);
  if (!Ats.from(candidate).has(RunDuring.class)) {
    throw BootstrapException.throwFatal("String_Node_Str" + bc);
  }
 else   if (!Ats.from(candidate).has(Provides.class)) {
    throw BootstrapException.throwFatal("String_Node_Str" + bc);
  }
  this.bootstrappers.add(bootstrapper);
  return true;
}

Fixed version (ground truth):
/** 
 * Find 
 * @see com.eucalyptus.bootstrap.ServiceJarDiscovery#processClass(java.lang.Class)
 * @param candidate
 * @return
 * @throws Exception
 */
@Override public boolean processClass(Class candidate) throws Exception {
  String bc=candidate.getCanonicalName();
  if (Modifier.isAbstract(candidate.getModifiers()) || !Bootstrapper.class.isAssignableFrom(candidate)) {
    return false;
  }
  Class bootstrapper=this.getBootstrapper(candidate);
  if (!Ats.from(candidate).has(RunDuring.class)) {
    throw BootstrapException.throwFatal("String_Node_Str" + bc);
  }
 else   if (!Ats.from(candidate).has(Provides.class)) {
    throw BootstrapException.throwFatal("String_Node_Str" + bc);
  }
  this.bootstrappers.add(bootstrapper);
  return true;
}
Program: 14152
Project: 14152
Buggy source:
public static DASInfo getStorageInfo(){
  DASInfo conf=null;
  TransactionResource tran=Entities.transactionFor(DASInfo.class);
  try {
    conf=Entities.uniqueResult(new DASInfo(StorageProperties.NAME));
    tran.commit();
  }
 catch (  NoSuchElementException e) {
    LOG.warn("String_Node_Str" + StorageProperties.NAME + "String_Node_Str");
    conf=new DASInfo(StorageProperties.NAME,StorageProperties.DAS_DEVICE);
    Entities.persist(conf);
    tran.commit();
  }
catch (  Exception t) {
    LOG.error("String_Node_Str" + StorageProperties.NAME);
    tran.rollback();
    return new DASInfo(StorageProperties.NAME,StorageProperties.DAS_DEVICE);
  }
  return conf;
}

Fixed version (ground truth):
public static DASInfo getStorageInfo(){
  DASInfo conf=null;
  try {
    conf=Transactions.find(new DASInfo());
  }
 catch (  Exception e) {
    LOG.warn("String_Node_Str" + StorageProperties.NAME + "String_Node_Str");
    try {
      conf=Transactions.saveDirect(new DASInfo(StorageProperties.NAME,StorageProperties.DAS_DEVICE));
    }
 catch (    Exception e1) {
      try {
        conf=Transactions.find(new DASInfo());
      }
 catch (      Exception e2) {
        LOG.warn("String_Node_Str");
      }
    }
  }
  if (conf == null) {
    conf=new DASInfo(StorageProperties.NAME,StorageProperties.DAS_DEVICE);
  }
  return conf;
}
Program: 14153
Project: 14153
Buggy source:
@Override public boolean apply(Class arg0){
  EntityTransaction db=Entities.get(DirectStorageInfo.class);
  try {
    List<DirectStorageInfo> entities=Entities.query(new DirectStorageInfo());
    for (    DirectStorageInfo entry : entities) {
      LOG.debug("String_Node_Str" + entry);
      entry.setTimeoutInMillis(StorageProperties.timeoutInMillis);
    }
    db.commit();
    return true;
  }
 catch (  Exception ex) {
    db.rollback();
    throw Exceptions.toUndeclared(ex);
  }
}

Fixed version (ground truth):
@Override public boolean apply(Class arg0){
  try (TransactionResource tr=Entities.transactionFor(DirectStorageInfo.class)){
    List<DirectStorageInfo> entities=Entities.query(new DirectStorageInfo());
    for (    DirectStorageInfo entry : entities) {
      LOG.debug("String_Node_Str" + entry);
      entry.setTimeoutInMillis(StorageProperties.timeoutInMillis);
    }
    tr.commit();
    return true;
  }
 catch (  Exception ex) {
    throw Exceptions.toUndeclared(ex);
  }
}