nus-yam/ex-repair huggingface dataset:
Program: 14831
Project: 14831
Buggy source:
public DescribeImagesResponseType describe(final DescribeImagesType request) throws EucalyptusCloudException, TransactionException {
  DescribeImagesResponseType reply=request.getReply();
  final Context ctx=Contexts.lookup();
  final String requestAccountId=ctx.getUserFullName().getAccountNumber();
  final List<String> ownersSet=request.getOwnersSet();
  if (ownersSet.remove(Images.SELF)) {
    ownersSet.add(requestAccountId);
  }
  Predicate<ImageInfo> rangeFilter=Predicates.and(CloudMetadatas.filterById(request.getImagesSet()),CloudMetadatas.filterByOwningAccount(request.getOwnersSet()),Images.filterExecutableBy(ownersSet));
  Predicate<ImageInfo> privilegesFilter=Predicates.and(Images.FilterPermissions.INSTANCE,RestrictedTypes.filterPrivileged(true));
  Predicate<ImageInfo> filter=Predicates.and(privilegesFilter,rangeFilter);
  List<ImageDetails> imageDetailsList=Transactions.filteredTransform(new ImageInfo(),filter,Images.TO_IMAGE_DETAILS);
  reply.getImagesSet().addAll(imageDetailsList);
  ImageUtil.cleanDeregistered();
  return reply;
}

Fixed version (ground truth):
public DescribeImagesResponseType describe(final DescribeImagesType request) throws EucalyptusCloudException, TransactionException {
  DescribeImagesResponseType reply=request.getReply();
  final Context ctx=Contexts.lookup();
  final String requestAccountId=ctx.getUserFullName().getAccountNumber();
  final List<String> ownersSet=request.getOwnersSet();
  if (ownersSet.remove(Images.SELF)) {
    ownersSet.add(requestAccountId);
  }
  Predicate<ImageInfo> rangeFilter=Predicates.and(CloudMetadatas.filterById(request.getImagesSet()),CloudMetadatas.filterByOwningAccount(request.getOwnersSet()),Images.filterExecutableBy(ownersSet));
  Predicate<ImageInfo> privilegesFilter=Predicates.and(Images.FilterPermissions.INSTANCE,RestrictedTypes.filterPrivilegedWithoutOwner());
  Predicate<ImageInfo> filter=Predicates.and(privilegesFilter,rangeFilter);
  List<ImageDetails> imageDetailsList=Transactions.filteredTransform(new ImageInfo(),filter,Images.TO_IMAGE_DETAILS);
  reply.getImagesSet().addAll(imageDetailsList);
  ImageUtil.cleanDeregistered();
  return reply;
}
Program: 14832
Project: 14832
Buggy source:
public static <T extends RestrictedType>Predicate<T> filterPrivileged(final boolean ignoreOwningAccount){
  return new Predicate<T>(){
    @Override public boolean apply(    T arg0){
      Context ctx=Contexts.lookup();
      if (!ctx.hasAdministrativePrivileges()) {
        Class<? extends BaseMessage> msgType=ctx.getRequest().getClass();
        Class<?> rscType=arg0.getClass();
        Ats ats=findPolicyAnnotations(rscType,msgType);
        PolicyVendor vendor=ats.get(PolicyVendor.class);
        PolicyResourceType type=ats.get(PolicyResourceType.class);
        String action=getIamActionByMessageType();
        User requestUser=ctx.getUser();
        try {
          Account owningAccount=null;
          if (!ignoreOwningAccount) {
            owningAccount=Principals.nobodyFullName().getAccountNumber().equals(arg0.getOwner().getAccountNumber()) ? null : Accounts.lookupAccountByName(arg0.getOwner().getAccountName());
          }
          return Permissions.isAuthorized(vendor.value(),type.value(),arg0.getDisplayName(),owningAccount,action,requestUser);
        }
 catch (        AuthException ex) {
          return false;
        }
      }
      return true;
    }
  }
;
}

Fixed version (ground truth):
private static <T extends RestrictedType>Predicate<T> filterPrivileged(final boolean ignoreOwningAccount){
  return new Predicate<T>(){
    @Override public boolean apply(    T arg0){
      Context ctx=Contexts.lookup();
      if (!ctx.hasAdministrativePrivileges()) {
        Class<? extends BaseMessage> msgType=ctx.getRequest().getClass();
        Class<?> rscType=arg0.getClass();
        Ats ats=findPolicyAnnotations(rscType,msgType);
        PolicyVendor vendor=ats.get(PolicyVendor.class);
        PolicyResourceType type=ats.get(PolicyResourceType.class);
        String action=getIamActionByMessageType();
        User requestUser=ctx.getUser();
        try {
          Account owningAccount=null;
          if (!ignoreOwningAccount) {
            owningAccount=Principals.nobodyFullName().getAccountNumber().equals(arg0.getOwner().getAccountNumber()) ? null : Accounts.lookupAccountByName(arg0.getOwner().getAccountName());
          }
          return Permissions.isAuthorized(vendor.value(),type.value(),arg0.getDisplayName(),owningAccount,action,requestUser);
        }
 catch (        AuthException ex) {
          return false;
        }
      }
      return true;
    }
  }
;
}
Program: 14834
Project: 14834
Buggy source:
public static RunInstancesResponseType runInstances(RunInstancesType request) throws MetadataException, AuthException {
  Allocation allocInfo=Allocations.begin(request);
  try {
    Predicates.and(VerifyMetadata.get(),AdmissionControl.get()).apply(allocInfo);
  }
 catch (  Exception ex1) {
    LOG.trace(ex1,ex1);
  }
  RunInstancesResponseType reply=allocInfo.getRequest().getReply();
  List<String> networkNames=Lists.transform(allocInfo.getNetworkGroups(),new Function<NetworkGroup,String>(){
    @Override public String apply(    NetworkGroup arg0){
      return arg0.getDisplayName();
    }
  }
);
  ReservationInfoType reservation=new ReservationInfoType(allocInfo.getReservationId(),allocInfo.getOwnerFullName().getAccountNumber(),Lists.newArrayList(networkNames));
  EntityTransaction db=Entities.get(VmInstance.class);
  try {
    for (    ResourceToken allocToken : allocInfo.getAllocationTokens()) {
      VmInstance entity=Entities.merge(allocToken.getVmInstance());
      reservation.getInstancesSet().add(VmInstances.transform(entity));
    }
    db.commit();
  }
 catch (  Exception ex) {
    Logs.exhaust().error(ex,ex);
    db.rollback();
    allocInfo.abort();
    throw Exceptions.toUndeclared(ex);
  }
  ClusterAllocator.get().apply(allocInfo);
  reply.setRsvInfo(reservation);
  return reply;
}

Fixed version (ground truth):
public static RunInstancesResponseType runInstances(RunInstancesType request) throws MetadataException, AuthException {
  Allocation allocInfo=Allocations.begin(request);
  try {
    Predicates.and(VerifyMetadata.get(),AdmissionControl.get()).apply(allocInfo);
  }
 catch (  Exception ex1) {
    LOG.trace(ex1,ex1);
  }
  RunInstancesResponseType reply=allocInfo.getRequest().getReply();
  List<String> networkNames=Lists.transform(allocInfo.getNetworkGroups(),new Function<NetworkGroup,String>(){
    @Override public String apply(    NetworkGroup arg0){
      return arg0.getDisplayName();
    }
  }
);
  ReservationInfoType reservation=new ReservationInfoType(allocInfo.getReservationId(),allocInfo.getOwnerFullName().getAccountNumber(),Lists.newArrayList(networkNames));
  EntityTransaction db=Entities.get(VmInstance.class);
  try {
    allocInfo.commit();
    for (    ResourceToken allocToken : allocInfo.getAllocationTokens()) {
      VmInstance entity=Entities.merge(allocToken.getVmInstance());
      reservation.getInstancesSet().add(VmInstances.transform(entity));
    }
    db.commit();
  }
 catch (  Exception ex) {
    Logs.exhaust().error(ex,ex);
    db.rollback();
    allocInfo.abort();
    throw Exceptions.toUndeclared(ex);
  }
  ClusterAllocator.get().apply(allocInfo);
  reply.setRsvInfo(reservation);
  return reply;
}
Program: 14835
Project: 14835
Buggy source:
static String lookatPersistenceContext(final Object obj) throws RuntimeException {
  final Class type=Classes.typeOf(obj);
  final Ats ats=Ats.inClassHierarchy(type);
  PersistenceContext persistenceContext=null;
  if (!ats.has(PersistenceContext.class)) {
    throw new RuntimeException("String_Node_Str" + type.getCanonicalName() + "String_Node_Str"+ ats.toString());
  }
 else {
    persistenceContext=ats.get(PersistenceContext.class);
  }
  return persistenceContext.name();
}

Fixed version (ground truth):
static String lookatPersistenceContext(final Object obj) throws RuntimeException {
  final Class type=Classes.typeOf(obj);
  final Ats ats=Ats.inClassHierarchy(type);
  PersistenceContext persistenceContext=null;
  if (!ats.has(PersistenceContext.class)) {
    throw new RuntimeException("String_Node_Str" + type + "String_Node_Str"+ ats.toString());
  }
 else {
    persistenceContext=ats.get(PersistenceContext.class);
  }
  return persistenceContext.name();
}
Program: 14836
Project: 14836
Buggy source:
/** 
 * {@inheritDoc ResourceAlllocation#teardown()}
 * @throws ResourceAllocationException
 * @see Reference#teardown()
 */
@Override public final void teardown() throws ResourceAllocationException {
  Entities.delete(this);
  this.setId(null);
}

Fixed version (ground truth):
/** 
 * {@inheritDoc ResourceAlllocation#teardown()}
 * @throws ResourceAllocationException
 * @see Reference#teardown()
 */
@Override public final boolean teardown() throws ResourceAllocationException {
  Entities.delete(this);
  this.setId(null);
  return true;
}
Program: 14837
Project: 14837
Buggy source:
/** 
 * Dependent external resource state has been cleared and the resource is ready for re-use.
 * @throws ResourceAllocationException
 */
public void teardown() throws ResourceAllocationException ;

Fixed version (ground truth):
/** 
 * Dependent external resource state has been cleared and the resource is ready for re-use.
 * @return 
 * @throws ResourceAllocationException
 */
public boolean teardown() throws ResourceAllocationException ;
Program: 14838
Project: 14838
Buggy source:
public static NetworkGroup delete(final OwnerFullName ownerFullName,final String groupName) throws MetadataException {
  if (defaultNetworkName().equals(groupName)) {
    createDefault(ownerFullName);
  }
  final EntityTransaction db=Entities.get(NetworkGroup.class);
  try {
    final NetworkGroup ret=Entities.uniqueResult(new NetworkGroup(ownerFullName,groupName));
    Entities.delete(ret);
    db.commit();
    return ret;
  }
 catch (  final Exception ex) {
    Logs.exhaust().error(ex,ex);
    db.rollback();
    throw new NoSuchMetadataException("String_Node_Str" + groupName + "String_Node_Str"+ ownerFullName,ex);
  }
}

Fixed version (ground truth):
public static NetworkGroup delete(final OwnerFullName ownerFullName,final String groupName) throws MetadataException {
  if (defaultNetworkName().equals(groupName)) {
    createDefault(ownerFullName);
  }
  final EntityTransaction db=Entities.get(NetworkGroup.class);
  try {
    final NetworkGroup ret=Entities.uniqueResult(new NetworkGroup(ownerFullName,groupName));
    Entities.delete(ret);
    db.commit();
    return ret;
  }
 catch (  final ConstraintViolationException ex) {
    Logs.exhaust().error(ex,ex);
    db.rollback();
    throw new IllegalMetadataAccessException("String_Node_Str" + groupName + "String_Node_Str"+ ownerFullName+ "String_Node_Str"+ Exceptions.causeString(ex),ex);
  }
catch (  final Exception ex) {
    Logs.exhaust().error(ex,ex);
    db.rollback();
    throw new NoSuchMetadataException("String_Node_Str" + groupName + "String_Node_Str"+ ownerFullName,ex);
  }
}
Program: 14839
Project: 14839
Buggy source:
public void abort(){
  for (  ResourceToken token : this.allocationTokens) {
    token.abort();
  }
}

Fixed version (ground truth):
public void abort(){
  for (  ResourceToken token : this.allocationTokens) {
    EntityTransaction db=Entities.get(VmInstance.class);
    try {
      token.abort();
      db.commit();
    }
 catch (    Exception ex) {
      LOG.warn(ex.getMessage());
      Logs.exhaust().error(ex,ex);
      db.rollback();
    }
  }
}
Program: 14840
Project: 14840
Buggy source:
public void commit() throws Exception {
  try {
    Iterables.transform(this.getAllocationTokens(),VmInstance.Create.INSTANCE);
  }
 catch (  Exception ex) {
    this.abort();
    throw ex;
  }
}

Fixed version (ground truth):
public void commit() throws Exception {
  try {
    for (    ResourceToken t : this.getAllocationTokens()) {
      VmInstance.Create.INSTANCE.apply(t);
    }
  }
 catch (  Exception ex) {
    this.abort();
    throw ex;
  }
}
Program: 14841
Project: 14841
Buggy source:
public static RunInstancesResponseType runInstances(RunInstancesType request) throws MetadataException, AuthException {
  Allocation allocInfo=Allocations.begin(request);
  try {
    Predicates.and(VerifyMetadata.get(),AdmissionControl.get(),ClusterAllocator.get()).apply(allocInfo);
  }
 catch (  Exception ex1) {
    LOG.trace(ex1,ex1);
  }
  RunInstancesResponseType reply=allocInfo.getRequest().getReply();
  List<String> networkNames=Lists.transform(allocInfo.getNetworkGroups(),new Function<NetworkGroup,String>(){
    @Override public String apply(    NetworkGroup arg0){
      return arg0.getDisplayName();
    }
  }
);
  ReservationInfoType reservation=new ReservationInfoType(allocInfo.getReservationId(),allocInfo.getOwnerFullName().getAccountNumber(),Lists.newArrayList(networkNames));
  EntityTransaction db=Entities.get(VmInstance.class);
  try {
    for (    ResourceToken allocToken : allocInfo.getAllocationTokens()) {
      VmInstance entity=Entities.merge(allocToken.getVmInstance());
      reservation.getInstancesSet().add(VmInstances.transform(entity));
    }
    db.commit();
  }
 catch (  Exception ex) {
    Logs.exhaust().error(ex,ex);
    db.rollback();
    throw Exceptions.toUndeclared(ex);
  }
  reply.setRsvInfo(reservation);
  return reply;
}

Fixed version (ground truth):
public static RunInstancesResponseType runInstances(RunInstancesType request) throws MetadataException, AuthException {
  Allocation allocInfo=Allocations.begin(request);
  try {
    Predicates.and(VerifyMetadata.get(),AdmissionControl.get()).apply(allocInfo);
  }
 catch (  Exception ex1) {
    LOG.trace(ex1,ex1);
  }
  RunInstancesResponseType reply=allocInfo.getRequest().getReply();
  List<String> networkNames=Lists.transform(allocInfo.getNetworkGroups(),new Function<NetworkGroup,String>(){
    @Override public String apply(    NetworkGroup arg0){
      return arg0.getDisplayName();
    }
  }
);
  ReservationInfoType reservation=new ReservationInfoType(allocInfo.getReservationId(),allocInfo.getOwnerFullName().getAccountNumber(),Lists.newArrayList(networkNames));
  EntityTransaction db=Entities.get(VmInstance.class);
  try {
    for (    ResourceToken allocToken : allocInfo.getAllocationTokens()) {
      VmInstance entity=Entities.merge(allocToken.getVmInstance());
      reservation.getInstancesSet().add(VmInstances.transform(entity));
    }
    db.commit();
    ClusterAllocator.get().apply(allocInfo);
  }
 catch (  Exception ex) {
    Logs.exhaust().error(ex,ex);
    db.rollback();
    throw Exceptions.toUndeclared(ex);
  }
  reply.setRsvInfo(reservation);
  return reply;
}
Program: 14842
Project: 14842
Buggy source:
private void sendSecondaryAssign(){
  try {
    VmInstance vm=VmInstances.lookup(super.getRequest().getInstanceId());
    if (!vm.getPartition().equals(this.address.getPartition())) {
      Partition partition=Partitions.lookupByName(vm.getPartition());
      ServiceConfiguration config=Partitions.lookupService(ClusterController.class,partition);
      AssignAddressType request=new AssignAddressType(this.address.getNaturalId(),this.address.getDisplayName(),vm.getPrivateAddress(),vm.getDisplayName());
      try {
        AsyncRequests.sendSync(config,request);
      }
 catch (      Exception ex) {
        LOG.error(ex,ex);
      }
    }
  }
 catch (  TerminatedInstanceException ex) {
    LOG.error(ex,ex);
  }
catch (  NoSuchElementException ex) {
    LOG.error(ex,ex);
  }
}

Fixed version (ground truth):
private void sendSecondaryAssign(){
  try {
    VmInstance vm=VmInstances.lookup(super.getRequest().getInstanceId());
    if (!vm.getPartition().equals(this.address.getPartition())) {
      Partition partition=Partitions.lookupByName(vm.getPartition());
      ServiceConfiguration config=Partitions.lookupService(ClusterController.class,partition);
      AssignAddressType request=new AssignAddressType(this.address.getStateUuid(),this.address.getDisplayName(),vm.getPrivateAddress(),vm.getDisplayName());
      try {
        AsyncRequests.sendSync(config,request);
      }
 catch (      Exception ex) {
        LOG.error(ex,ex);
      }
    }
  }
 catch (  TerminatedInstanceException ex) {
    LOG.error(ex,ex);
  }
catch (  NoSuchElementException ex) {
    LOG.error(ex,ex);
  }
}
Program: 14843
Project: 14843
Buggy source:
@Override public boolean apply(final VmRunResponseType reply){
  EntityTransaction db=Entities.get(VmInstance.class);
  try {
    VmRunCallback.this.token.redeem();
    for (    final VmInfo vmInfo : reply.getVms()) {
      final VmInstance vm=VmInstances.lookup(vmInfo.getInstanceId());
      vm.updateAddresses(vmInfo.getNetParams().getIpAddress(),vmInfo.getNetParams().getIgnoredPublicIp());
    }
    db.commit();
    return true;
  }
 catch (  Exception ex) {
    Logs.exhaust().error(ex,ex);
    db.rollback();
    throw new EucalyptusClusterException("String_Node_Str" + VmRunCallback.this.getRequest().getInstanceId() + "String_Node_Str"+ ex.getMessage(),ex);
  }
}

Fixed version (ground truth):
@Override public boolean apply(final VmRunResponseType reply){
  EntityTransaction db=Entities.get(VmInstance.class);
  try {
    try {
      VmRunCallback.this.token.redeem();
    }
 catch (    Exception ex) {
      Logs.extreme().error(ex,ex);
    }
    for (    final VmInfo vmInfo : reply.getVms()) {
      final VmInstance vm=VmInstances.lookup(vmInfo.getInstanceId());
      vm.updateAddresses(vmInfo.getNetParams().getIpAddress(),vmInfo.getNetParams().getIgnoredPublicIp());
    }
    db.commit();
    return true;
  }
 catch (  RuntimeException ex) {
    Logs.exhaust().error(ex,ex);
    db.rollback();
    throw ex;
  }
catch (  Exception ex) {
    Logs.exhaust().error(ex,ex);
    db.rollback();
    throw new EucalyptusClusterException("String_Node_Str" + VmRunCallback.this.getRequest().getInstanceId() + "String_Node_Str"+ ex.getMessage(),ex);
  }
}
Program: 14844
Project: 14844
Buggy source:
@Override public void fire(final VmRunResponseType reply){
  if (!reply.get_return()) {
    throw new EucalyptusClusterException("String_Node_Str" + this.getRequest().getInstanceId());
  }
  Logs.extreme().error(reply);
  Predicate<VmRunResponseType> redeemToken=new Predicate<VmRunResponseType>(){
    @Override public boolean apply(    final VmRunResponseType reply){
      EntityTransaction db=Entities.get(VmInstance.class);
      try {
        VmRunCallback.this.token.redeem();
        for (        final VmInfo vmInfo : reply.getVms()) {
          final VmInstance vm=VmInstances.lookup(vmInfo.getInstanceId());
          vm.updateAddresses(vmInfo.getNetParams().getIpAddress(),vmInfo.getNetParams().getIgnoredPublicIp());
        }
        db.commit();
        return true;
      }
 catch (      Exception ex) {
        Logs.exhaust().error(ex,ex);
        db.rollback();
        throw new EucalyptusClusterException("String_Node_Str" + VmRunCallback.this.getRequest().getInstanceId() + "String_Node_Str"+ ex.getMessage(),ex);
      }
    }
  }
;
  try {
    Entities.retry(reply,redeemToken);
  }
 catch (  RuntimeException ex) {
    LOG.error(ex,ex);
    throw ex;
  }
}

Fixed version (ground truth):
@Override public void fire(final VmRunResponseType reply){
  if (!reply.get_return()) {
    throw new EucalyptusClusterException("String_Node_Str" + this.getRequest().getInstanceId());
  }
  Logs.extreme().error(reply);
  Predicate<VmRunResponseType> redeemToken=new Predicate<VmRunResponseType>(){
    @Override public boolean apply(    final VmRunResponseType reply){
      EntityTransaction db=Entities.get(VmInstance.class);
      try {
        try {
          VmRunCallback.this.token.redeem();
        }
 catch (        Exception ex) {
          Logs.extreme().error(ex,ex);
        }
        for (        final VmInfo vmInfo : reply.getVms()) {
          final VmInstance vm=VmInstances.lookup(vmInfo.getInstanceId());
          vm.updateAddresses(vmInfo.getNetParams().getIpAddress(),vmInfo.getNetParams().getIgnoredPublicIp());
        }
        db.commit();
        return true;
      }
 catch (      RuntimeException ex) {
        Logs.exhaust().error(ex,ex);
        db.rollback();
        throw ex;
      }
catch (      Exception ex) {
        Logs.exhaust().error(ex,ex);
        db.rollback();
        throw new EucalyptusClusterException("String_Node_Str" + VmRunCallback.this.getRequest().getInstanceId() + "String_Node_Str"+ ex.getMessage(),ex);
      }
    }
  }
;
  try {
    Entities.retry(reply,redeemToken);
  }
 catch (  RuntimeException ex) {
    LOG.error(ex,ex);
    throw ex;
  }
}
Program: 14845
Project: 14845
Buggy source:
private void sendSecondaryAssign(){
  try {
    VmInstance vm=VmInstances.lookup(super.getRequest().getInstanceId());
    if (!vm.getPartition().equals(this.address.getPartition())) {
      Partition partition=Partitions.lookupByName(vm.getPartition());
      ServiceConfiguration config=Partitions.lookupService(ClusterController.class,partition);
      AssignAddressType request=new AssignAddressType(this.address.getNaturalId(),this.address.getDisplayName(),vm.getPrivateAddress(),vm.getDisplayName());
      try {
        AsyncRequests.sendSync(config,request);
      }
 catch (      Exception ex) {
        LOG.error(ex,ex);
      }
    }
  }
 catch (  TerminatedInstanceException ex) {
    LOG.error(ex,ex);
  }
catch (  NoSuchElementException ex) {
    LOG.error(ex,ex);
  }
}

Fixed version (ground truth):
private void sendSecondaryAssign(){
  try {
    VmInstance vm=VmInstances.lookup(super.getRequest().getInstanceId());
    if (!vm.getPartition().equals(this.address.getPartition())) {
      Partition partition=Partitions.lookupByName(vm.getPartition());
      ServiceConfiguration config=Partitions.lookupService(ClusterController.class,partition);
      AssignAddressType request=new AssignAddressType(this.address.getStateUuid(),this.address.getDisplayName(),vm.getPrivateAddress(),vm.getDisplayName());
      try {
        AsyncRequests.sendSync(config,request);
      }
 catch (      Exception ex) {
        LOG.error(ex,ex);
      }
    }
  }
 catch (  TerminatedInstanceException ex) {
    LOG.error(ex,ex);
  }
catch (  NoSuchElementException ex) {
    LOG.error(ex,ex);
  }
}
Program: 14846
Project: 14846
Buggy source:
private void sendSecondaryAssign(){
  try {
    VmInstance vm=VmInstances.lookup(super.getRequest().getInstanceId());
    if (!vm.getPartition().equals(this.address.getPartition())) {
      Partition partition=Partitions.lookupByName(vm.getPartition());
      ServiceConfiguration config=Partitions.lookupService(ClusterController.class,partition);
      AssignAddressType request=new AssignAddressType(this.address.getNaturalId(),this.address.getDisplayName(),vm.getPrivateAddress(),vm.getDisplayName());
      try {
        AsyncRequests.sendSync(config,request);
      }
 catch (      Exception ex) {
        LOG.error(ex,ex);
      }
    }
  }
 catch (  TerminatedInstanceException ex) {
    LOG.error(ex,ex);
  }
catch (  NoSuchElementException ex) {
    LOG.error(ex,ex);
  }
}

Fixed version (ground truth):
private void sendSecondaryAssign(){
  try {
    VmInstance vm=VmInstances.lookup(super.getRequest().getInstanceId());
    if (!vm.getPartition().equals(this.address.getPartition())) {
      Partition partition=Partitions.lookupByName(vm.getPartition());
      ServiceConfiguration config=Partitions.lookupService(ClusterController.class,partition);
      AssignAddressType request=new AssignAddressType(this.address.getStateUuid(),this.address.getDisplayName(),vm.getPrivateAddress(),vm.getDisplayName());
      try {
        AsyncRequests.sendSync(config,request);
      }
 catch (      Exception ex) {
        LOG.error(ex,ex);
      }
    }
  }
 catch (  TerminatedInstanceException ex) {
    LOG.error(ex,ex);
  }
catch (  NoSuchElementException ex) {
    LOG.error(ex,ex);
  }
}
Program: 14847
Project: 14847
Buggy source:
private void updateState(){
  if (!this.checkVmState()) {
    this.address.clearPending();
    try {
      VmInstance vm=VmInstances.lookup(super.getRequest().getInstanceId());
      if (!vm.getPartition().equals(address.getPartition())) {
        Partition partition=Partitions.lookupByName(vm.getPartition());
        ServiceConfiguration config=Partitions.lookupService(ClusterController.class,partition);
        AssignAddressType request=new AssignAddressType(address.getNaturalId(),address.getDisplayName(),vm.getPrivateAddress(),vm.getDisplayName());
        try {
          AsyncRequests.sendSync(config,request);
        }
 catch (        Exception ex) {
          LOG.error(ex,ex);
        }
      }
    }
 catch (    TerminatedInstanceException ex) {
      LOG.error(ex,ex);
    }
catch (    NoSuchElementException ex) {
      LOG.error(ex,ex);
    }
    throw new IllegalStateException("String_Node_Str" + this.getRequest());
  }
 else {
    EventRecord.here(AssignAddressCallback.class,EventType.ADDRESS_ASSIGNED,Address.State.assigned.toString(),LogUtil.dumpObject(address)).info();
    this.address.clearPending();
  }
}

Fixed version (ground truth):
private void updateState(){
  if (!this.checkVmState()) {
    this.address.clearPending();
    throw new IllegalStateException("String_Node_Str" + this.getRequest());
  }
 else {
    EventRecord.here(AssignAddressCallback.class,EventType.ADDRESS_ASSIGNED,Address.State.assigned.toString(),LogUtil.dumpObject(address)).info();
    this.sendSecondaryAssign();
    this.address.clearPending();
  }
}
Program: 14848
Project: 14848
Buggy source:
@Override public void fire(UnassignAddressResponseType reply){
  this.clearVmAddress();
  if (reply.get_return()) {
    EventRecord.here(UnassignAddressCallback.class,EventType.ADDRESS_UNASSIGN,address.toString()).info();
  }
 else {
    EventRecord.here(UnassignAddressCallback.class,EventType.ADDRESS_STATE,"String_Node_Str",address.toString()).warn();
  }
  if (!Transition.system.equals(this.address.getTransition())) {
    try {
      this.address.clearPending();
    }
 catch (    IllegalStateException t) {
      LOG.debug(t);
    }
catch (    Exception t) {
      LOG.warn(t.getMessage());
      EventRecord.here(UnassignAddressCallback.class,EventType.ADDRESS_STATE,"String_Node_Str",address.toString()).warn();
      LOG.trace(t,t);
    }
 finally {
      if (!this.address.isPending() && this.address.isSystemOwned() && Address.UNASSIGNED_INSTANCEID.equals(this.address.getInstanceId())) {
        try {
          this.address.release();
        }
 catch (        Exception t) {
          LOG.warn("String_Node_Str" + this.address);
        }
      }
    }
  }
}

Fixed version (ground truth):
@Override public void fire(UnassignAddressResponseType reply){
  this.sendSecondaryUnassign();
  this.clearVmAddress();
  if (reply.get_return()) {
    EventRecord.here(UnassignAddressCallback.class,EventType.ADDRESS_UNASSIGN,address.toString()).info();
  }
 else {
    EventRecord.here(UnassignAddressCallback.class,EventType.ADDRESS_STATE,"String_Node_Str",address.toString()).warn();
  }
  if (!Transition.system.equals(this.address.getTransition())) {
    try {
      this.address.clearPending();
    }
 catch (    IllegalStateException t) {
      LOG.debug(t);
    }
catch (    Exception t) {
      LOG.warn(t.getMessage());
      EventRecord.here(UnassignAddressCallback.class,EventType.ADDRESS_STATE,"String_Node_Str",address.toString()).warn();
      LOG.trace(t,t);
    }
 finally {
      if (!this.address.isPending() && this.address.isSystemOwned() && Address.UNASSIGNED_INSTANCEID.equals(this.address.getInstanceId())) {
        try {
          this.address.release();
        }
 catch (        Exception t) {
          LOG.warn("String_Node_Str" + this.address);
        }
      }
    }
  }
}
Program: 14849
Project: 14849
Buggy source:
public boolean isBucket(){
  if (this.object == null || "String_Node_Str".equals(this.object)) {
    return false;
  }
  return true;
}

Fixed version (ground truth):
public boolean isBucket(){
  if (this.object == null || "String_Node_Str".equals(this.object)) {
    return true;
  }
  return false;
}
Program: 14850
Project: 14850
Buggy source:
public S3ResourceName(String bucket,String object){
  this.bucket=bucket;
  this.object=object;
}

Fixed version (ground truth):
public S3ResourceName(String bucket,String object){
  this.bucket=bucket;
  this.object=object;
  this.vendor=PolicySpec.VENDOR_S3;
}
Program: 14851
Project: 14851
Buggy source:
public boolean isBucket(){
  if (this.object == null || "String_Node_Str".equals(this.object)) {
    return false;
  }
  return true;
}

Fixed version (ground truth):
public boolean isBucket(){
  if (this.object == null || "String_Node_Str".equals(this.object)) {
    return true;
  }
  return false;
}
Program: 14852
Project: 14852
Buggy source:
public S3ResourceName(String bucket,String object){
  this.bucket=bucket;
  this.object=object;
}

Fixed version (ground truth):
public S3ResourceName(String bucket,String object){
  this.bucket=bucket;
  this.object=object;
  this.vendor=PolicySpec.VENDOR_S3;
}
Program: 14853
Project: 14853
Buggy source:
private static BootableSet bootsetWithKernel(BootableSet bootSet) throws MetadataException {
  String kernelId=determineKernelId(bootSet);
  LOG.debug("String_Node_Str" + kernelId + "String_Node_Str"+ bootSet.toString());
  try {
    KernelImageInfo kernel=RestrictedTypes.doPrivileged(kernelId,LookupKernel.INSTANCE);
    return new NoRamdiskBootableSet(bootSet.getMachine(),kernel);
  }
 catch (  Exception ex) {
    throw new NoSuchMetadataException("String_Node_Str" + kernelId + "String_Node_Str"+ ex.getMessage(),ex);
  }
}

Fixed version (ground truth):
private static BootableSet bootsetWithKernel(BootableSet bootSet) throws MetadataException {
  String kernelId=determineKernelId(bootSet);
  LOG.debug("String_Node_Str" + kernelId + "String_Node_Str"+ bootSet.toString());
  try {
    KernelImageInfo kernel=RestrictedTypes.doPrivileged(kernelId,LookupKernel.INSTANCE,true);
    return new NoRamdiskBootableSet(bootSet.getMachine(),kernel);
  }
 catch (  Exception ex) {
    throw new NoSuchMetadataException("String_Node_Str" + kernelId + "String_Node_Str"+ ex.getMessage(),ex);
  }
}
Program: 14854
Project: 14854
Buggy source:
public static <T extends ImageInfo>T resolveDiskImage(String imageId,Function<String,T> resolver) throws IllegalMetadataAccessException {
  T img=resolver.apply(imageId);
  Predicate<T> filter=Predicates.or(Images.FilterPermissions.INSTANCE,RestrictedTypes.filterPrivileged());
  if (filter.apply(img)) {
    return img;
  }
 else {
    throw new IllegalMetadataAccessException(imageId + "String_Node_Str");
  }
}

Fixed version (ground truth):
public static <T extends ImageInfo>T resolveDiskImage(String imageId,Function<String,T> resolver) throws IllegalMetadataAccessException {
  T img=resolver.apply(imageId);
  Predicate<T> filter=Predicates.and(Images.FilterPermissions.INSTANCE,RestrictedTypes.filterPrivileged(true));
  if (filter.apply(img)) {
    return img;
  }
 else {
    throw new IllegalMetadataAccessException(imageId + "String_Node_Str");
  }
}
Program: 14855
Project: 14855
Buggy source:
private static BootableSet bootsetWithRamdisk(BootableSet bootSet) throws MetadataException {
  String ramdiskId=determineRamdiskId(bootSet);
  LOG.debug("String_Node_Str" + ramdiskId + "String_Node_Str"+ bootSet.toString());
  if (ramdiskId == null) {
    return bootSet;
  }
 else {
    try {
      RamdiskImageInfo ramdisk=RestrictedTypes.doPrivileged(ramdiskId,LookupRamdisk.INSTANCE);
      return new TrifectaBootableSet(bootSet.getMachine(),bootSet.getKernel(),ramdisk);
    }
 catch (    Exception ex) {
      throw new NoSuchMetadataException("String_Node_Str" + ramdiskId + "String_Node_Str"+ ex.getMessage(),ex);
    }
  }
}

Fixed version (ground truth):
private static BootableSet bootsetWithRamdisk(BootableSet bootSet) throws MetadataException {
  String ramdiskId=determineRamdiskId(bootSet);
  LOG.debug("String_Node_Str" + ramdiskId + "String_Node_Str"+ bootSet.toString());
  if (ramdiskId == null) {
    return bootSet;
  }
 else {
    try {
      RamdiskImageInfo ramdisk=RestrictedTypes.doPrivileged(ramdiskId,LookupRamdisk.INSTANCE,true);
      return new TrifectaBootableSet(bootSet.getMachine(),bootSet.getKernel(),ramdisk);
    }
 catch (    Exception ex) {
      throw new NoSuchMetadataException("String_Node_Str" + ramdiskId + "String_Node_Str"+ ex.getMessage(),ex);
    }
  }
}
Program: 14856
Project: 14856
Buggy source:
public DescribeImagesResponseType describe(final DescribeImagesType request) throws EucalyptusCloudException, TransactionException {
  DescribeImagesResponseType reply=request.getReply();
  final Context ctx=Contexts.lookup();
  final String requestAccountId=ctx.getUserFullName().getAccountNumber();
  final List<String> ownersSet=request.getOwnersSet();
  if (ownersSet.remove(Images.SELF)) {
    ownersSet.add(requestAccountId);
  }
  Predicate<ImageInfo> rangeFilter=Predicates.and(CloudMetadatas.filterById(request.getImagesSet()),CloudMetadatas.filterByOwningAccount(request.getOwnersSet()),Images.filterExecutableBy(ownersSet));
  Predicate<ImageInfo> privilegesFilter=Predicates.or(Images.FilterPermissions.INSTANCE,RestrictedTypes.filterPrivileged());
  Predicate<ImageInfo> filter=Predicates.and(privilegesFilter,rangeFilter);
  List<ImageDetails> imageDetailsList=Transactions.filteredTransform(new ImageInfo(),filter,Images.TO_IMAGE_DETAILS);
  reply.getImagesSet().addAll(imageDetailsList);
  ImageUtil.cleanDeregistered();
  return reply;
}

Fixed version (ground truth):
public DescribeImagesResponseType describe(final DescribeImagesType request) throws EucalyptusCloudException, TransactionException {
  DescribeImagesResponseType reply=request.getReply();
  final Context ctx=Contexts.lookup();
  final String requestAccountId=ctx.getUserFullName().getAccountNumber();
  final List<String> ownersSet=request.getOwnersSet();
  if (ownersSet.remove(Images.SELF)) {
    ownersSet.add(requestAccountId);
  }
  Predicate<ImageInfo> rangeFilter=Predicates.and(CloudMetadatas.filterById(request.getImagesSet()),CloudMetadatas.filterByOwningAccount(request.getOwnersSet()),Images.filterExecutableBy(ownersSet));
  Predicate<ImageInfo> privilegesFilter=Predicates.and(Images.FilterPermissions.INSTANCE,RestrictedTypes.filterPrivileged(true));
  Predicate<ImageInfo> filter=Predicates.and(privilegesFilter,rangeFilter);
  List<ImageDetails> imageDetailsList=Transactions.filteredTransform(new ImageInfo(),filter,Images.TO_IMAGE_DETAILS);
  reply.getImagesSet().addAll(imageDetailsList);
  ImageUtil.cleanDeregistered();
  return reply;
}
Program: 14857
Project: 14857
Buggy source:
public static boolean isAuthorized(String vendor,String resourceType,String resourceName,Account resourceAccount,String action,User requestUser){
  Context context=null;
  try {
    context=Contexts.lookup();
  }
 catch (  IllegalContextAccessException e) {
    LOG.debug("String_Node_Str",e);
  }
  try {
    Map<Contract.Type,Contract> contracts=context != null ? context.getContracts() : new HashMap<Contract.Type,Contract>();
    policyEngine.evaluateAuthorization(vendor + "String_Node_Str" + resourceType,resourceName,resourceAccount,action,requestUser,contracts);
    return true;
  }
 catch (  AuthException e) {
    LOG.error("String_Node_Str" + resourceType + "String_Node_Str"+ resourceName+ "String_Node_Str"+ resourceAccount.getName()+ "String_Node_Str"+ requestUser.getName(),e);
  }
catch (  Exception e) {
    LOG.debug("String_Node_Str" + resourceType + "String_Node_Str"+ resourceName+ "String_Node_Str"+ resourceAccount.getName()+ "String_Node_Str"+ requestUser.getName(),e);
  }
  return false;
}

Fixed version (ground truth):
public static boolean isAuthorized(String vendor,String resourceType,String resourceName,Account resourceAccount,String action,User requestUser){
  Context context=null;
  try {
    context=Contexts.lookup();
  }
 catch (  IllegalContextAccessException e) {
    LOG.debug("String_Node_Str",e);
  }
  try {
    Map<Contract.Type,Contract> contracts=context != null ? context.getContracts() : new HashMap<Contract.Type,Contract>();
    policyEngine.evaluateAuthorization(vendor + "String_Node_Str" + resourceType,resourceName,resourceAccount,vendor + "String_Node_Str" + action,requestUser,contracts);
    return true;
  }
 catch (  AuthException e) {
    LOG.error("String_Node_Str" + resourceType + "String_Node_Str"+ resourceName+ "String_Node_Str"+ resourceAccount.getName()+ "String_Node_Str"+ requestUser.getName(),e);
  }
catch (  Exception e) {
    LOG.debug("String_Node_Str" + resourceType + "String_Node_Str"+ resourceName+ "String_Node_Str"+ resourceAccount.getName()+ "String_Node_Str"+ requestUser.getName(),e);
  }
  return false;
}
Program: 14858
Project: 14858
Buggy source:
public static boolean canAllocate(String vendor,String resourceType,String resourceName,String action,User requestUser,Long quantity){
  try {
    policyEngine.evaluateQuota(vendor + "String_Node_Str" + resourceType,resourceName,action,requestUser,quantity);
    return true;
  }
 catch (  AuthException e) {
    LOG.debug("String_Node_Str" + resourceType + "String_Node_Str"+ resourceName+ "String_Node_Str"+ quantity+ "String_Node_Str"+ requestUser.getName(),e);
  }
  return false;
}

Fixed version (ground truth):
public static boolean canAllocate(String vendor,String resourceType,String resourceName,String action,User requestUser,Long quantity){
  try {
    policyEngine.evaluateQuota(vendor + "String_Node_Str" + resourceType,resourceName,vendor + "String_Node_Str" + action,requestUser,quantity);
    return true;
  }
 catch (  AuthException e) {
    LOG.debug("String_Node_Str" + resourceType + "String_Node_Str"+ resourceName+ "String_Node_Str"+ quantity+ "String_Node_Str"+ requestUser.getName(),e);
  }
  return false;
}
Program: 14859
Project: 14859
Buggy source:
/** 
 * Map request to policy language's action string.
 * @param request The request message
 * @return The IAM ARN action string.
 */
public static String requestToAction(BaseMessage request){
  if (request != null) {
    PolicyAction action=Ats.from(request).get(PolicyAction.class);
    if (action != null) {
      return action.vendor() + "String_Node_Str" + action.action();
    }
  }
  return null;
}

Fixed version (ground truth):
/** 
 * Map request to policy language's action string.
 * @param request The request message
 * @return The IAM ARN action string.
 */
public static String requestToAction(BaseMessage request){
  if (request != null) {
    PolicyAction action=Ats.from(request).get(PolicyAction.class);
    if (action != null) {
      return action.action();
    }
  }
  return null;
}
Program: 14864
Project: 14864
Buggy source:
private static SearchResultRow serializeImage(ImageInfo image){
  SearchResultRow result=new SearchResultRow();
  result.addField(image.getDisplayName());
  result.addField(image.getImageName());
  result.addField(image.getDescription());
  if (image instanceof MachineImageInfo) {
    result.addField(((MachineImageInfo)image).getKernelId());
  }
 else {
    result.addField("String_Node_Str");
  }
  if (image instanceof MachineImageInfo) {
    result.addField(((MachineImageInfo)image).getRamdiskId());
  }
 else {
    result.addField("String_Node_Str");
  }
  result.addField(image.getState().toString());
  result.addField(image.getImageType().toString());
  result.addField(image.getOwnerAccountNumber());
  result.addField(image.getArchitecture().toString());
  result.addField(image.getImagePublic().toString());
  result.addField(image.getPlatform().toString());
  return result;
}

Fixed version (ground truth):
private static SearchResultRow serializeImage(ImageInfo image){
  SearchResultRow result=new SearchResultRow();
  result.addField(image.getDisplayName());
  result.addField(image.getImageName());
  if (image instanceof MachineImageInfo) {
    result.addField(((MachineImageInfo)image).getManifestLocation());
    result.addField(((MachineImageInfo)image).getKernelId());
    result.addField(((MachineImageInfo)image).getRamdiskId());
  }
 else {
    result.addField("String_Node_Str");
    result.addField("String_Node_Str");
    result.addField("String_Node_Str");
  }
  result.addField(image.getState().toString());
  result.addField(image.getImageType().toString());
  result.addField(image.getOwnerAccountNumber());
  result.addField(image.getArchitecture().toString());
  result.addField(image.getImagePublic().toString());
  result.addField(image.getPlatform().toString());
  result.addField(image.getDescription());
  return result;
}
Program: 14865
Project: 14865
Buggy source:
private static BootableSet bootsetWithKernel(BootableSet bootSet) throws MetadataException {
  String kernelId=determineKernelId(bootSet);
  LOG.debug("String_Node_Str" + kernelId + "String_Node_Str"+ bootSet.toString());
  try {
    KernelImageInfo kernel=RestrictedTypes.doPrivileged(kernelId,LookupKernel.INSTANCE);
    return new NoRamdiskBootableSet(bootSet.getMachine(),kernel);
  }
 catch (  Exception ex) {
    throw new NoSuchMetadataException("String_Node_Str" + kernelId + "String_Node_Str"+ ex.getMessage(),ex);
  }
}

Fixed version (ground truth):
private static BootableSet bootsetWithKernel(BootableSet bootSet) throws MetadataException {
  String kernelId=determineKernelId(bootSet);
  LOG.debug("String_Node_Str" + kernelId + "String_Node_Str"+ bootSet.toString());
  try {
    KernelImageInfo kernel=RestrictedTypes.doPrivileged(kernelId,LookupKernel.INSTANCE,true);
    return new NoRamdiskBootableSet(bootSet.getMachine(),kernel);
  }
 catch (  Exception ex) {
    throw new NoSuchMetadataException("String_Node_Str" + kernelId + "String_Node_Str"+ ex.getMessage(),ex);
  }
}
Program: 14866
Project: 14866
Buggy source:
public static <T extends ImageInfo>T resolveDiskImage(String imageId,Function<String,T> resolver) throws IllegalMetadataAccessException {
  T img=resolver.apply(imageId);
  Predicate<T> filter=Predicates.or(Images.FilterPermissions.INSTANCE,RestrictedTypes.filterPrivileged());
  if (filter.apply(img)) {
    return img;
  }
 else {
    throw new IllegalMetadataAccessException(imageId + "String_Node_Str");
  }
}

Fixed version (ground truth):
public static <T extends ImageInfo>T resolveDiskImage(String imageId,Function<String,T> resolver) throws IllegalMetadataAccessException {
  T img=resolver.apply(imageId);
  Predicate<T> filter=Predicates.and(Images.FilterPermissions.INSTANCE,RestrictedTypes.filterPrivileged(true));
  if (filter.apply(img)) {
    return img;
  }
 else {
    throw new IllegalMetadataAccessException(imageId + "String_Node_Str");
  }
}
Program: 14867
Project: 14867
Buggy source:
private static BootableSet bootsetWithRamdisk(BootableSet bootSet) throws MetadataException {
  String ramdiskId=determineRamdiskId(bootSet);
  LOG.debug("String_Node_Str" + ramdiskId + "String_Node_Str"+ bootSet.toString());
  if (ramdiskId == null) {
    return bootSet;
  }
 else {
    try {
      RamdiskImageInfo ramdisk=RestrictedTypes.doPrivileged(ramdiskId,LookupRamdisk.INSTANCE);
      return new TrifectaBootableSet(bootSet.getMachine(),bootSet.getKernel(),ramdisk);
    }
 catch (    Exception ex) {
      throw new NoSuchMetadataException("String_Node_Str" + ramdiskId + "String_Node_Str"+ ex.getMessage(),ex);
    }
  }
}

Fixed version (ground truth):
private static BootableSet bootsetWithRamdisk(BootableSet bootSet) throws MetadataException {
  String ramdiskId=determineRamdiskId(bootSet);
  LOG.debug("String_Node_Str" + ramdiskId + "String_Node_Str"+ bootSet.toString());
  if (ramdiskId == null) {
    return bootSet;
  }
 else {
    try {
      RamdiskImageInfo ramdisk=RestrictedTypes.doPrivileged(ramdiskId,LookupRamdisk.INSTANCE,true);
      return new TrifectaBootableSet(bootSet.getMachine(),bootSet.getKernel(),ramdisk);
    }
 catch (    Exception ex) {
      throw new NoSuchMetadataException("String_Node_Str" + ramdiskId + "String_Node_Str"+ ex.getMessage(),ex);
    }
  }
}
Program: 14869
Project: 14869
Buggy source:
public DescribeImagesResponseType describe(final DescribeImagesType request) throws EucalyptusCloudException, TransactionException {
  DescribeImagesResponseType reply=request.getReply();
  final Context ctx=Contexts.lookup();
  final String requestAccountId=ctx.getUserFullName().getAccountNumber();
  final List<String> ownersSet=request.getOwnersSet();
  if (ownersSet.remove(Images.SELF)) {
    ownersSet.add(requestAccountId);
  }
  Predicate<ImageInfo> rangeFilter=Predicates.and(CloudMetadatas.filterById(request.getImagesSet()),CloudMetadatas.filterByOwningAccount(request.getOwnersSet()),Images.filterExecutableBy(ownersSet));
  Predicate<ImageInfo> privilegesFilter=Predicates.and(Images.FilterPermissions.INSTANCE,RestrictedTypes.filterPrivileged());
  Predicate<ImageInfo> filter=Predicates.and(privilegesFilter,rangeFilter);
  List<ImageDetails> imageDetailsList=Transactions.filteredTransform(new ImageInfo(),filter,Images.TO_IMAGE_DETAILS);
  reply.getImagesSet().addAll(imageDetailsList);
  ImageUtil.cleanDeregistered();
  return reply;
}

Fixed version (ground truth):
public DescribeImagesResponseType describe(final DescribeImagesType request) throws EucalyptusCloudException, TransactionException {
  DescribeImagesResponseType reply=request.getReply();
  final Context ctx=Contexts.lookup();
  final String requestAccountId=ctx.getUserFullName().getAccountNumber();
  final List<String> ownersSet=request.getOwnersSet();
  if (ownersSet.remove(Images.SELF)) {
    ownersSet.add(requestAccountId);
  }
  Predicate<ImageInfo> rangeFilter=Predicates.and(CloudMetadatas.filterById(request.getImagesSet()),CloudMetadatas.filterByOwningAccount(request.getOwnersSet()),Images.filterExecutableBy(ownersSet));
  Predicate<ImageInfo> privilegesFilter=Predicates.and(Images.FilterPermissions.INSTANCE,RestrictedTypes.filterPrivileged(true));
  Predicate<ImageInfo> filter=Predicates.and(privilegesFilter,rangeFilter);
  List<ImageDetails> imageDetailsList=Transactions.filteredTransform(new ImageInfo(),filter,Images.TO_IMAGE_DETAILS);
  reply.getImagesSet().addAll(imageDetailsList);
  ImageUtil.cleanDeregistered();
  return reply;
}
Program: 14876
Project: 14876
Buggy source:
public PropertiesService(){
  super("String_Node_Str");
}

Fixed version (ground truth):
public PropertiesService(){
  super("String_Node_Str",null);
}
Program: 14877
Project: 14877
Buggy source:
private Notifications(){
  super(StackConfiguration.DEFAULT_AWS_SNS_URL_PREFIX);
}

Fixed version (ground truth):
public Notifications(){
  super(StackConfiguration.DEFAULT_AWS_SNS_URL_PREFIX);
}