nus-yam/ex-repair huggingface dataset:
Program: 45771
Project: 45771
Buggy source:
/** 
 * Fetches known partition state from next member and returns null if target member is left and/or not a member of this cluster anymore. If future timeouts, then fetch operation is retried until we learn target member's partition state or it leaves the cluster.
 */
private PartitionRuntimeState collectNextPartitionState(Iterator<Map.Entry<Member,Future<PartitionRuntimeState>>> iter){
  Map.Entry<Member,Future<PartitionRuntimeState>> next=iter.next();
  Member member=next.getKey();
  Future<PartitionRuntimeState> future=next.getValue();
  boolean collectedState=true;
  try {
    PartitionRuntimeState state=future.get(FETCH_PARTITION_STATE_SECONDS,TimeUnit.SECONDS);
    if (state == null) {
      logger.fine("String_Node_Str" + member);
    }
 else {
      logger.fine("String_Node_Str" + state.getVersion() + "String_Node_Str"+ member);
    }
    return state;
  }
 catch (  InterruptedException e) {
    logger.fine("String_Node_Str");
    Thread.currentThread().interrupt();
  }
catch (  TimeoutException e) {
    collectedState=false;
    next.setValue(fetchPartitionState(member));
  }
catch (  Exception e) {
    Level level=Level.SEVERE;
    if ((e instanceof MemberLeftException) || (e.getCause() instanceof TargetNotMemberException)) {
      level=Level.FINE;
    }
    logger.log(level,"String_Node_Str" + member,e);
  }
 finally {
    if (collectedState) {
      iter.remove();
    }
  }
  return null;
}

Fixed version (ground truth):
/** 
 * Fetches known partition state from next member and returns null if target member is left and/or not a member of this cluster anymore. If future timeouts, then fetch operation is retried until we learn target member's partition state or it leaves the cluster.
 */
private PartitionRuntimeState collectNextPartitionState(Iterator<Map.Entry<Member,Future<PartitionRuntimeState>>> iter){
  Map.Entry<Member,Future<PartitionRuntimeState>> next=iter.next();
  Member member=next.getKey();
  Future<PartitionRuntimeState> future=next.getValue();
  boolean collectedState=true;
  try {
    PartitionRuntimeState state=future.get(FETCH_PARTITION_STATE_SECONDS,SECONDS);
    if (state == null) {
      logger.fine("String_Node_Str" + member);
    }
 else {
      logger.fine("String_Node_Str" + state.getVersion() + "String_Node_Str"+ member);
    }
    return state;
  }
 catch (  InterruptedException e) {
    logger.fine("String_Node_Str");
    Thread.currentThread().interrupt();
  }
catch (  TimeoutException e) {
    collectedState=false;
    next.setValue(fetchPartitionState(member));
  }
catch (  Exception e) {
    Level level=Level.SEVERE;
    if ((e instanceof MemberLeftException) || (e.getCause() instanceof TargetNotMemberException)) {
      level=Level.FINE;
    }
    logger.log(level,"String_Node_Str" + member,e);
  }
 finally {
    if (collectedState) {
      iter.remove();
    }
  }
  return null;
}
Program: 45772
Project: 45772
Buggy source:
/** 
 * Sends a   {@link AssignPartitions} to the master to assign partitions. 
 */
private void triggerMasterToAssignPartitions(){
  if (partitionStateManager.isInitialized()) {
    return;
  }
  ClusterServiceImpl clusterService=node.getClusterService();
  if (!clusterService.isJoined()) {
    return;
  }
  ClusterState clusterState=clusterService.getClusterState();
  if (!clusterState.isMigrationAllowed()) {
    logger.warning("String_Node_Str" + clusterState);
    return;
  }
  if (!triggerMasterFlag.compareAndSet(false,true)) {
    return;
  }
  try {
    final Address masterAddress=clusterService.getMasterAddress();
    if (masterAddress != null && !masterAddress.equals(node.getThisAddress())) {
      Future f=nodeEngine.getOperationService().createInvocationBuilder(SERVICE_NAME,new AssignPartitions(),masterAddress).setTryCount(1).invoke();
      f.get(1,TimeUnit.SECONDS);
    }
  }
 catch (  Exception e) {
    logger.finest(e);
  }
 finally {
    triggerMasterFlag.set(false);
  }
}

Fixed version (ground truth):
/** 
 * Sends a   {@link AssignPartitions} to the master to assign partitions. 
 */
private void triggerMasterToAssignPartitions(){
  if (partitionStateManager.isInitialized()) {
    return;
  }
  ClusterServiceImpl clusterService=node.getClusterService();
  if (!clusterService.isJoined()) {
    return;
  }
  ClusterState clusterState=clusterService.getClusterState();
  if (!clusterState.isMigrationAllowed()) {
    logger.warning("String_Node_Str" + clusterState);
    return;
  }
  final Address masterAddress=clusterService.getMasterAddress();
  if (masterAddress == null || masterAddress.equals(node.getThisAddress())) {
    return;
  }
  if (masterTriggered.compareAndSet(false,true)) {
    InternalOperationService operationService=nodeEngine.getOperationService();
    operationService.createInvocationBuilder(SERVICE_NAME,new AssignPartitions(),masterAddress).invoke().andThen(new ExecutionCallback<Object>(){
      @Override public void onResponse(      Object response){
        resetMasterTriggeredFlag();
        if (response instanceof PartitionRuntimeState) {
          PartitionRuntimeState partitionState=(PartitionRuntimeState)response;
          partitionState.setEndpoint(masterAddress);
          processPartitionRuntimeState(partitionState);
        }
      }
      @Override public void onFailure(      Throwable t){
        resetMasterTriggeredFlag();
        logger.severe(t);
      }
    }
);
    masterTrigger.executeWithDelay();
  }
}
Program: 45773
Project: 45773
Buggy source:
@Override public Object getResponse(){
  return Boolean.TRUE;
}

Fixed version (ground truth):
@Override public Object getResponse(){
  return partitionState;
}
Program: 45774
Project: 45774
Buggy source:
@Override public void run(){
  InternalPartitionServiceImpl service=getService();
  service.firstArrangement();
}

Fixed version (ground truth):
@Override public void run(){
  InternalPartitionServiceImpl service=getService();
  partitionState=service.firstArrangement();
}
Program: 45775
Project: 45775
Buggy source:
@Override public void handle(Packet packet){
  int threadIndex=INT_HOLDER.get().getAndInc() % responseThreads.length;
  responseThreads[threadIndex].responseQueue.add(packet);
}

Fixed version (ground truth):
@Override public void handle(Packet packet){
  int threadIndex=hashToIndex(INT_HOLDER.get().getAndInc(),responseThreads.length);
  responseThreads[threadIndex].responseQueue.add(packet);
}
Program: 45776
Project: 45776
Buggy source:
@Override public void handle(Packet packet){
  int threadIndex=INT_HOLDER.get().getAndInc() % responseThreads.length;
  responseThreads[threadIndex].responseQueue.add(packet);
}

Fixed version (ground truth):
@Override public void handle(Packet packet){
  int threadIndex=hashToIndex(INT_HOLDER.get().getAndInc(),responseThreads.length);
  responseThreads[threadIndex].responseQueue.add(packet);
}
Program: 45777
Project: 45777
Buggy source:
@Override public void handle(ClientMessage message,ClientConnection connection){
  int threadIndex=INT_HOLDER.get().getAndInc() % responseThreads.length;
  responseThreads[threadIndex].responseQueue.add(new ClientPacket(connection,message));
}

Fixed version (ground truth):
@Override public void handle(ClientMessage message,ClientConnection connection){
  int threadIndex=hashToIndex(INT_HOLDER.get().getAndInc(),responseThreads.length);
  responseThreads[threadIndex].responseQueue.add(new ClientPacket(connection,message));
}
Program: 45778
Project: 45778
Buggy source:
@SuppressFBWarnings("String_Node_Str") private void handleAt(String first){
  if (first.length() == 1) {
    println("String_Node_Str");
    return;
  }
  File f=new File(first.substring(1));
  println("String_Node_Str" + f.getAbsolutePath());
  if (f.exists()) {
    try {
      BufferedReader br=new BufferedReader(new FileReader(f));
      String l=br.readLine();
      while (l != null) {
        handleCommand(l);
        l=br.readLine();
      }
      br.close();
    }
 catch (    IOException e) {
      e.printStackTrace();
    }
  }
 else {
    println("String_Node_Str" + f.getAbsolutePath());
  }
}

Fixed version (ground truth):
@SuppressFBWarnings("String_Node_Str") private void handleAt(String first){
  if (first.length() == 1) {
    println("String_Node_Str");
    return;
  }
  File f=new File(first.substring(1));
  println("String_Node_Str" + f.getAbsolutePath());
  if (f.exists()) {
    BufferedReader br=null;
    try {
      br=new BufferedReader(new FileReader(f));
      String l=br.readLine();
      while (l != null) {
        handleCommand(l);
        l=br.readLine();
      }
    }
 catch (    IOException e) {
      e.printStackTrace();
    }
 finally {
      IOUtil.closeResource(br);
    }
  }
 else {
    println("String_Node_Str" + f.getAbsolutePath());
  }
}
Program: 45779
Project: 45779
Buggy source:
private void handleAt(String first){
  if (first.length() == 1) {
    println("String_Node_Str");
    return;
  }
  File f=new File(first.substring(1));
  println("String_Node_Str" + f.getAbsolutePath());
  if (f.exists()) {
    try {
      BufferedReader br=new BufferedReader(new InputStreamReader(new FileInputStream(f),"String_Node_Str"));
      String l=br.readLine();
      while (l != null) {
        handleCommand(l);
        l=br.readLine();
      }
      br.close();
    }
 catch (    IOException e) {
      e.printStackTrace();
    }
  }
 else {
    println("String_Node_Str" + f.getAbsolutePath());
  }
}

Fixed version (ground truth):
private void handleAt(String first){
  if (first.length() == 1) {
    println("String_Node_Str");
    return;
  }
  File f=new File(first.substring(1));
  println("String_Node_Str" + f.getAbsolutePath());
  if (f.exists()) {
    BufferedReader br=null;
    try {
      br=new BufferedReader(new InputStreamReader(new FileInputStream(f),"String_Node_Str"));
      String l=br.readLine();
      while (l != null) {
        handleCommand(l);
        l=br.readLine();
      }
    }
 catch (    IOException e) {
      e.printStackTrace();
    }
 finally {
      IOUtil.closeResource(br);
    }
  }
 else {
    println("String_Node_Str" + f.getAbsolutePath());
  }
}
Program: 45780
Project: 45780
Buggy source:
/** 
 * Starts the test application. Loads the config from classpath hazelcast.xml, if it fails to load, will use default config.
 */
public static void main(String[] args) throws Exception {
  Config config;
  try {
    config=new FileSystemXmlConfig("String_Node_Str");
  }
 catch (  FileNotFoundException e) {
    config=new Config();
  }
  for (int i=1; i <= LOAD_EXECUTORS_COUNT; i++) {
    config.addExecutorConfig(new ExecutorConfig(EXECUTOR_NAMESPACE + "String_Node_Str" + i).setPoolSize(i));
  }
  ConsoleApp consoleApp=new ConsoleApp(Hazelcast.newHazelcastInstance(config));
  consoleApp.start();
}

Fixed version (ground truth):
/** 
 * Starts the test application. <p> Loads the config from classpath hazelcast.xml, if it fails to load, will use default config.
 */
public static void main(String[] args) throws Exception {
  Config config;
  try {
    config=new FileSystemXmlConfig("String_Node_Str");
  }
 catch (  FileNotFoundException e) {
    config=new Config();
  }
  for (int i=1; i <= LOAD_EXECUTORS_COUNT; i++) {
    config.addExecutorConfig(new ExecutorConfig(EXECUTOR_NAMESPACE + "String_Node_Str" + i).setPoolSize(i));
  }
  ConsoleApp consoleApp=new ConsoleApp(Hazelcast.newHazelcastInstance(config));
  consoleApp.start();
}
Program: 45781
Project: 45781
Buggy source:
/** 
 * Iterates through all bundles to get the available   {@link ScriptEngineFactory} classes
 * @return the names of the available ScriptEngineFactory classes
 * @throws IOException
 */
private List<String> findFactoryCandidates(BundleContext context) throws IOException {
  Bundle[] bundles=context.getBundles();
  List<String> factoryCandidates=new ArrayList<String>();
  for (  Bundle bundle : bundles) {
    if (bundle == null) {
      continue;
    }
    if ("String_Node_Str".equals(bundle.getSymbolicName())) {
      continue;
    }
    Enumeration urls=bundle.findEntries("String_Node_Str","String_Node_Str",false);
    if (urls == null) {
      continue;
    }
    while (urls.hasMoreElements()) {
      URL u=(URL)urls.nextElement();
      BufferedReader reader=new BufferedReader(new InputStreamReader(u.openStream(),"String_Node_Str"));
      String line;
      while ((line=reader.readLine()) != null) {
        line=line.trim();
        if (!line.startsWith("String_Node_Str") && line.length() > 0) {
          factoryCandidates.add(line);
        }
      }
      reader.close();
    }
  }
  addJavaScriptEngine(factoryCandidates);
  return factoryCandidates;
}

Fixed version (ground truth):
/** 
 * Iterates through all bundles to get the available   {@link ScriptEngineFactory} classes
 * @return the names of the available ScriptEngineFactory classes
 * @throws IOException
 */
private List<String> findFactoryCandidates(BundleContext context) throws IOException {
  Bundle[] bundles=context.getBundles();
  List<String> factoryCandidates=new ArrayList<String>();
  for (  Bundle bundle : bundles) {
    if (bundle == null) {
      continue;
    }
    if ("String_Node_Str".equals(bundle.getSymbolicName())) {
      continue;
    }
    Enumeration urls=bundle.findEntries("String_Node_Str","String_Node_Str",false);
    if (urls == null) {
      continue;
    }
    while (urls.hasMoreElements()) {
      URL u=(URL)urls.nextElement();
      BufferedReader reader=null;
      try {
        reader=new BufferedReader(new InputStreamReader(u.openStream(),"String_Node_Str"));
        String line;
        while ((line=reader.readLine()) != null) {
          line=line.trim();
          if (!line.startsWith("String_Node_Str") && line.length() > 0) {
            factoryCandidates.add(line);
          }
        }
      }
  finally {
        IOUtil.closeResource(reader);
      }
    }
  }
  addJavaScriptEngine(factoryCandidates);
  return factoryCandidates;
}
Program: 45782
Project: 45782
Buggy source:
@Override public Collection<DistributedObject> getDistributedObjects(){
  try {
    ClientMessage request=ClientGetDistributedObjectsCodec.encodeRequest();
    final Future<ClientMessage> future=new ClientInvocation(this,request,getName()).invoke();
    ClientMessage response=future.get();
    ClientGetDistributedObjectsCodec.ResponseParameters resultParameters=ClientGetDistributedObjectsCodec.decodeResponse(response);
    Collection<? extends DistributedObject> distributedObjects=proxyManager.getDistributedObjects();
    Set<DistributedObjectInfo> localDistributedObjects=new HashSet<DistributedObjectInfo>();
    for (    DistributedObject localInfo : distributedObjects) {
      localDistributedObjects.add(new DistributedObjectInfo(localInfo.getServiceName(),localInfo.getName()));
    }
    Collection<DistributedObjectInfo> newDistributedObjectInfo=resultParameters.response;
    for (    DistributedObjectInfo distributedObjectInfo : newDistributedObjectInfo) {
      localDistributedObjects.remove(distributedObjectInfo);
      getDistributedObject(distributedObjectInfo.getServiceName(),distributedObjectInfo.getName());
    }
    for (    DistributedObjectInfo distributedObjectInfo : localDistributedObjects) {
      proxyManager.removeProxy(distributedObjectInfo.getServiceName(),distributedObjectInfo.getName());
    }
    return (Collection<DistributedObject>)proxyManager.getDistributedObjects();
  }
 catch (  Exception e) {
    throw rethrow(e);
  }
}

Fixed version (ground truth):
@Override public Collection<DistributedObject> getDistributedObjects(){
  try {
    ClientMessage request=ClientGetDistributedObjectsCodec.encodeRequest();
    final Future<ClientMessage> future=new ClientInvocation(this,request,getName()).invoke();
    ClientMessage response=future.get();
    ClientGetDistributedObjectsCodec.ResponseParameters resultParameters=ClientGetDistributedObjectsCodec.decodeResponse(response);
    Collection<? extends DistributedObject> distributedObjects=proxyManager.getDistributedObjects();
    Set<DistributedObjectInfo> localDistributedObjects=new HashSet<DistributedObjectInfo>();
    for (    DistributedObject localInfo : distributedObjects) {
      localDistributedObjects.add(new DistributedObjectInfo(localInfo.getServiceName(),localInfo.getName()));
    }
    Collection<DistributedObjectInfo> newDistributedObjectInfo=resultParameters.response;
    for (    DistributedObjectInfo distributedObjectInfo : newDistributedObjectInfo) {
      localDistributedObjects.remove(distributedObjectInfo);
      getDistributedObject(distributedObjectInfo.getServiceName(),distributedObjectInfo.getName());
    }
    for (    DistributedObjectInfo distributedObjectInfo : localDistributedObjects) {
      proxyManager.destroyProxyLocally(distributedObjectInfo.getServiceName(),distributedObjectInfo.getName());
    }
    return (Collection<DistributedObject>)proxyManager.getDistributedObjects();
  }
 catch (  Exception e) {
    throw rethrow(e);
  }
}
Program: 45783
Project: 45783
Buggy source:
@Override public final void destroy(){
  if (preDestroy()) {
    onDestroy();
    ClientMessage clientMessage=ClientDestroyProxyCodec.encodeRequest(getDistributedObjectName(),getServiceName());
    getContext().getProxyManager().removeProxy(getServiceName(),getDistributedObjectName());
    try {
      new ClientInvocation(getClient(),clientMessage,getName()).invoke().get();
      postDestroy();
    }
 catch (    Exception e) {
      throw rethrow(e);
    }
  }
}

Fixed version (ground truth):
@Override public final void destroy(){
  getContext().getProxyManager().destroyProxy(this);
}
Program: 45784
Project: 45784
Buggy source:
@Test public void testWithMultipleNodes_clientReconnectsToNewNode(){
  ClientConfig clientConfig=createClientConfig();
  Config config=createNodeConfig();
  HazelcastInstance firstInstance=factory.newHazelcastInstance(config);
  HazelcastInstance client=factory.newHazelcastClient(clientConfig);
  factory.newHazelcastInstance(config);
  firstInstance.getLifecycleService().shutdown();
  assertCodeDeploymentWorking(client,new IncrementingEntryProcessor());
}

Fixed version (ground truth):
@Test public void testWithMultipleNodes_clientReconnectsToNewNode(){
  ClientConfig clientConfig=createClientConfig();
  Config config=createNodeConfig();
  HazelcastInstance firstInstance=factory.newHazelcastInstance(config);
  HazelcastInstance client=factory.newHazelcastClient(clientConfig);
  factory.newHazelcastInstance(config);
  final CountDownLatch clientReconnectedLatch=new CountDownLatch(1);
  client.getLifecycleService().addLifecycleListener(new ClientReconnectionListener(clientReconnectedLatch));
  firstInstance.getLifecycleService().shutdown();
  assertOpenEventually(clientReconnectedLatch);
  assertCodeDeploymentWorking(client,new IncrementingEntryProcessor());
}
Program: 45785
Project: 45785
Buggy source:
void addMembersRemovedInNotJoinableState(Collection<MemberImpl> members){
  clusterServiceLock.lock();
  try {
    members.remove(clusterService.getLocalMember());
    MemberMap membersRemovedInNotJoinableState=membersRemovedInNotJoinableStateRef.get();
    membersRemovedInNotJoinableStateRef.set(MemberMap.cloneAdding(membersRemovedInNotJoinableState,members.toArray(new MemberImpl[0])));
  }
  finally {
    clusterServiceLock.unlock();
  }
}

Fixed version (ground truth):
void addMembersRemovedInNotJoinableState(Collection<MemberImpl> members){
  clusterServiceLock.lock();
  try {
    MemberMap m=membersRemovedInNotJoinableStateRef.get();
    m=MemberMap.cloneAdding(m,members.toArray(new MemberImpl[0]));
    m=MemberMap.cloneExcluding(m,clusterService.getLocalMember());
    membersRemovedInNotJoinableStateRef.set(m);
  }
  finally {
    clusterServiceLock.unlock();
  }
}
Program: 45786
Project: 45786
Buggy source:
void addMembersRemovedInNotJoinableState(Collection<MemberImpl> members){
  clusterServiceLock.lock();
  try {
    members.remove(clusterService.getLocalMember());
    MemberMap membersRemovedInNotJoinableState=membersRemovedInNotJoinableStateRef.get();
    membersRemovedInNotJoinableStateRef.set(MemberMap.cloneAdding(membersRemovedInNotJoinableState,members.toArray(new MemberImpl[0])));
  }
  finally {
    clusterServiceLock.unlock();
  }
}

Fixed version (ground truth):
void addMembersRemovedInNotJoinableState(Collection<MemberImpl> members){
  clusterServiceLock.lock();
  try {
    MemberMap m=membersRemovedInNotJoinableStateRef.get();
    m=MemberMap.cloneAdding(m,members.toArray(new MemberImpl[0]));
    m=MemberMap.cloneExcluding(m,clusterService.getLocalMember());
    membersRemovedInNotJoinableStateRef.set(m);
  }
  finally {
    clusterServiceLock.unlock();
  }
}
Program: 45787
Project: 45787
Buggy source:
/** 
 * Calculates and returns the expected maximum size of an evicted record-store when   {@link com.hazelcast.config.MaxSizeConfig.MaxSizePolicy#PER_NODE PER_NODE} max-size-policy is used.
 */
public double translatePerNodeSizeToRecordStoreSize(RecordStore recordStore){
}

Fixed version (ground truth):
/** 
 * Calculates and returns the expected maximum size of an evicted record-store when   {@link com.hazelcast.config.MaxSizeConfig.MaxSizePolicy#PER_NODE PER_NODE} max-size-policy is used.
 */
public double translatePerNodeSizeToRecordStoreSize(RecordStore recordStore){
  MapConfig mapConfig=recordStore.getMapContainer().getMapConfig();
  MaxSizeConfig maxSizeConfig=mapConfig.getMaxSizeConfig();
  NodeEngine nodeEngine=mapServiceContext.getNodeEngine();
  int configuredMaxSize=maxSizeConfig.getSize();
  int memberCount=nodeEngine.getClusterService().getSize(DATA_MEMBER_SELECTOR);
  int partitionCount=nodeEngine.getPartitionService().getPartitionCount();
  double perNodeMaxRecordStoreSize=(1D * configuredMaxSize * memberCount / partitionCount);
  if (perNodeMaxRecordStoreSize < 1) {
    perNodeMaxRecordStoreSize=MIN_SANE_PER_PARTITION_SIZE;
    if (misconfiguredPerNodeMaxSizeWarningLogged.compareAndSet(false,true)) {
      int minMaxSize=(int)Math.ceil((1D * partitionCount / memberCount));
      int newSize=MIN_SANE_PER_PARTITION_SIZE * partitionCount / memberCount;
      logger.warning(format("String_Node_Str" + "String_Node_Str" + "String_Node_Str",mapConfig.getName(),memberCount,partitionCount,minMaxSize,newSize));
    }
  }
  return perNodeMaxRecordStoreSize;
}
Program: 45788
Project: 45788
Buggy source:
@Test public void testWithMultipleNodes_clientReconnectsToNewNode(){
  ClientConfig clientConfig=createClientConfig();
  Config config=createNodeConfig();
  HazelcastInstance firstInstance=factory.newHazelcastInstance(config);
  HazelcastInstance client=factory.newHazelcastClient(clientConfig);
  factory.newHazelcastInstance(config);
  firstInstance.getLifecycleService().shutdown();
  assertCodeDeploymentWorking(client,new IncrementingEntryProcessor());
}

Fixed version (ground truth):
@Test public void testWithMultipleNodes_clientReconnectsToNewNode(){
  ClientConfig clientConfig=createClientConfig();
  Config config=createNodeConfig();
  HazelcastInstance firstInstance=factory.newHazelcastInstance(config);
  HazelcastInstance client=factory.newHazelcastClient(clientConfig);
  factory.newHazelcastInstance(config);
  final CountDownLatch clientReconnectedLatch=new CountDownLatch(1);
  client.getLifecycleService().addLifecycleListener(new ClientReconnectionListener(clientReconnectedLatch));
  firstInstance.getLifecycleService().shutdown();
  assertOpenEventually(clientReconnectedLatch);
  assertCodeDeploymentWorking(client,new IncrementingEntryProcessor());
}
Program: 45789
Project: 45789
Buggy source:
public void delete(Data dataKey){
  multiMapValues.remove(dataKey);
}

Fixed version (ground truth):
public boolean delete(Data dataKey){
  return multiMapValues.remove(dataKey) != null;
}
Program: 45790
Project: 45790
Buggy source:
public MultiMapContainer getOrCreateMultiMapContainer(String name){
  MultiMapContainer container=ConcurrencyUtil.getOrPutIfAbsent(containerMap,name,containerConstructor);
  container.access();
  return container;
}

Fixed version (ground truth):
public MultiMapContainer getOrCreateMultiMapContainer(String name,boolean isAccess){
  MultiMapContainer container=ConcurrencyUtil.getOrPutIfAbsent(containerMap,name,containerConstructor);
  if (isAccess) {
    container.access();
  }
  return container;
}
Program: 45791
Project: 45791
Buggy source:
@Override public void beforeRun() throws Exception {
  MultiMapContainer container=getOrCreateContainer();
  shouldBackup=container.size() > 0;
}

Fixed version (ground truth):
@Override public void beforeRun() throws Exception {
  container=getOrCreateContainer();
  shouldBackup=container.size() > 0;
}
Program: 45792
Project: 45792
Buggy source:
@Override public void run() throws Exception {
  MultiMapContainer container=getOrCreateContainer();
  response=container.clear();
}

Fixed version (ground truth):
@Override public void run() throws Exception {
  container=getOrCreateContainer();
  response=container.clear();
}
Program: 45793
Project: 45793
Buggy source:
@Override public void afterRun() throws Exception {
  ((MultiMapService)getService()).getLocalMultiMapStatsImpl(name).incrementOtherOperations();
}

Fixed version (ground truth):
@Override public void afterRun() throws Exception {
  ((MultiMapService)getService()).getLocalMultiMapStatsImpl(name).incrementOtherOperations();
  if (shouldBackup) {
    container.update();
  }
}
Program: 45794
Project: 45794
Buggy source:
@Override public void run() throws Exception {
  delete();
  shouldBackup=true;
}

Fixed version (ground truth):
@Override public void run() throws Exception {
  if (delete()) {
    getOrCreateContainer().update();
  }
  shouldBackup=true;
}
Program: 45795
Project: 45795
Buggy source:
@Override public boolean shouldWait(){
  MultiMapContainer container=getOrCreateContainer();
  if (container.isTransactionallyLocked(dataKey)) {
    return !container.canAcquireLock(dataKey,getCallerUuid(),getThreadId());
  }
  return false;
}

Fixed version (ground truth):
@Override public boolean shouldWait(){
  MultiMapContainer container=getOrCreateContainer();
  if (container.isTransactionallyLocked(dataKey)) {
    return !container.canAcquireLock(dataKey,getCallerUuid(),threadId);
  }
  return false;
}
Program: 45796
Project: 45796
Buggy source:
@Override public void run() throws Exception {
  MultiMapContainer container=getOrCreateContainer();
  resultMap=createHashMap(mergeContainers.size());
  for (  MultiMapMergeContainer mergeContainer : mergeContainers) {
    Data key=mergeContainer.getKey();
    if (!container.canAcquireLock(key,getCallerUuid(),-1)) {
      Object valueKey=getNodeEngine().getSerializationService().toObject(key);
      getLogger().info("String_Node_Str" + valueKey + "String_Node_Str"+ name+ "String_Node_Str");
      continue;
    }
    MergingEntry<Data,MultiMapMergeContainer> mergingEntry=createMergingEntry(getNodeEngine().getSerializationService(),key,mergeContainer);
    MultiMapValue result=container.merge(mergingEntry,mergePolicy);
    if (result != null) {
      resultMap.put(key,result.getCollection(false));
      publishEvent(EntryEventType.MERGED,key,result,null);
    }
  }
  response=!resultMap.isEmpty();
}

Fixed version (ground truth):
@Override public void run() throws Exception {
  MultiMapContainer container=getOrCreateContainerWithoutAccess();
  resultMap=createHashMap(mergeContainers.size());
  for (  MultiMapMergeContainer mergeContainer : mergeContainers) {
    Data key=mergeContainer.getKey();
    if (!container.canAcquireLock(key,getCallerUuid(),-1)) {
      Object valueKey=getNodeEngine().getSerializationService().toObject(key);
      getLogger().info("String_Node_Str" + valueKey + "String_Node_Str"+ name+ "String_Node_Str");
      continue;
    }
    MergingEntry<Data,MultiMapMergeContainer> mergingEntry=createMergingEntry(getNodeEngine().getSerializationService(),key,mergeContainer);
    MultiMapValue result=container.merge(mergingEntry,mergePolicy);
    if (result != null) {
      resultMap.put(key,result.getCollection(false));
      publishEvent(EntryEventType.MERGED,key,result,null);
    }
  }
  response=!resultMap.isEmpty();
}
Program: 45797
Project: 45797
Buggy source:
@Override public void afterRun() throws Exception {
  if (Boolean.TRUE.equals(response)) {
    publishEvent(EntryEventType.ADDED,dataKey,value,null);
  }
}

Fixed version (ground truth):
@Override public void afterRun() throws Exception {
  if (Boolean.TRUE.equals(response)) {
    getOrCreateContainer().update();
    publishEvent(EntryEventType.ADDED,dataKey,value,null);
  }
}
Program: 45798
Project: 45798
Buggy source:
@Override public Operation newPrepareOperation(){
  return new TxnPrepareOperation(partitionId,name,key,ttl,threadId);
}

Fixed version (ground truth):
@Override public Operation newPrepareOperation(){
  return new TxnPrepareOperation(partitionId,name,key,threadId);
}
Program: 45799
Project: 45799
Buggy source:
@Test(timeout=60000) public void testSignalWithMultipleWaiters() throws InterruptedException {
  ILock lock=callerInstance.getLock(newName());
  ICondition condition=lock.newCondition(newName());
  CountDownLatch allAwaited=new CountDownLatch(3);
  CountDownLatch allSignalled=new CountDownLatch(10);
  startThreadWaitingOnCondition(lock,condition,allAwaited,allSignalled);
  startThreadWaitingOnCondition(lock,condition,allAwaited,allSignalled);
  startThreadWaitingOnCondition(lock,condition,allAwaited,allSignalled);
  assertOpenEventually("String_Node_Str",allAwaited);
  signal(lock,condition);
  assertCountEventually("String_Node_Str",9,allSignalled,THIRTY_SECONDS);
  assertFalse(lock.isLocked());
}

Fixed version (ground truth):
@Test public void testSignalWithMultipleWaiters(){
  final ILock lock=callerInstance.getLock(newName());
  ICondition condition=lock.newCondition(newName());
  CountDownLatch allAwaited=new CountDownLatch(3);
  CountDownLatch allSignalled=new CountDownLatch(10);
  startThreadWaitingOnCondition(lock,condition,allAwaited,allSignalled);
  startThreadWaitingOnCondition(lock,condition,allAwaited,allSignalled);
  startThreadWaitingOnCondition(lock,condition,allAwaited,allSignalled);
  assertOpenEventually("String_Node_Str",allAwaited);
  signal(lock,condition);
  assertCountEventually("String_Node_Str",9,allSignalled,THIRTY_SECONDS);
  assertTrueEventually(new AssertTask(){
    @Override public void run(){
      assertFalse(lock.isLocked());
    }
  }
);
}
Program: 45800
Project: 45800
Buggy source:
@Test(timeout=60000) public void testSignalWithMultipleWaiters() throws InterruptedException {
  ILock lock=callerInstance.getLock(newName());
  ICondition condition=lock.newCondition(newName());
  CountDownLatch allAwaited=new CountDownLatch(3);
  CountDownLatch allSignalled=new CountDownLatch(10);
  startThreadWaitingOnCondition(lock,condition,allAwaited,allSignalled);
  startThreadWaitingOnCondition(lock,condition,allAwaited,allSignalled);
  startThreadWaitingOnCondition(lock,condition,allAwaited,allSignalled);
  assertOpenEventually("String_Node_Str",allAwaited);
  signal(lock,condition);
  assertCountEventually("String_Node_Str",9,allSignalled,THIRTY_SECONDS);
  assertFalse(lock.isLocked());
}

Fixed version (ground truth):
@Test public void testSignalWithMultipleWaiters(){
  final ILock lock=callerInstance.getLock(newName());
  ICondition condition=lock.newCondition(newName());
  CountDownLatch allAwaited=new CountDownLatch(3);
  CountDownLatch allSignalled=new CountDownLatch(10);
  startThreadWaitingOnCondition(lock,condition,allAwaited,allSignalled);
  startThreadWaitingOnCondition(lock,condition,allAwaited,allSignalled);
  startThreadWaitingOnCondition(lock,condition,allAwaited,allSignalled);
  assertOpenEventually("String_Node_Str",allAwaited);
  signal(lock,condition);
  assertCountEventually("String_Node_Str",9,allSignalled,THIRTY_SECONDS);
  assertTrueEventually(new AssertTask(){
    @Override public void run(){
      assertFalse(lock.isLocked());
    }
  }
);
}
Program: 45801
Project: 45801
Buggy source:
private boolean trySetRemoveOnCancelPolicy(){
  try {
    Method method=ScheduledThreadPoolExecutor.class.getMethod("String_Node_Str",Boolean.TYPE);
    method.invoke(this,true);
    return true;
  }
 catch (  Exception e) {
    return false;
  }
}

Fixed version (ground truth):
@SuppressFBWarnings("String_Node_Str") private boolean trySetRemoveOnCancelPolicy(){
  try {
    Method method=ScheduledThreadPoolExecutor.class.getMethod("String_Node_Str",Boolean.TYPE);
    method.invoke(this,true);
    return true;
  }
 catch (  Exception e) {
    return false;
  }
}
Program: 45802
Project: 45802
Buggy source:
@Test(expected=HazelcastClientNotActiveException.class) public void testExceptionAfterClientShutdown() throws Exception {
  hazelcastFactory.newHazelcastInstance();
  ClientConfig clientConfig=new ClientConfig();
  clientConfig.getNetworkConfig().setConnectionAttemptLimit(1);
  HazelcastInstance client=hazelcastFactory.newHazelcastClient(clientConfig);
  IMap<Object,Object> test=client.getMap("String_Node_Str");
  test.put("String_Node_Str","String_Node_Str");
  client.shutdown();
  System.gc();
  test.get("String_Node_Str");
}

Fixed version (ground truth):
@Test(expected=HazelcastClientNotActiveException.class) public void testExceptionAfterClientShutdown() throws Exception {
  hazelcastFactory.newHazelcastInstance();
  ClientConfig clientConfig=new ClientConfig();
  HazelcastInstance client=hazelcastFactory.newHazelcastClient(clientConfig);
  IMap<Object,Object> test=client.getMap("String_Node_Str");
  test.put("String_Node_Str","String_Node_Str");
  client.shutdown();
  System.gc();
  test.get("String_Node_Str");
}
Program: 45803
Project: 45803
Buggy source:
@Test public void testClientConnected_withFirstAuthenticationRetried() throws InterruptedException {
  SerializationConfig serializationConfig=new SerializationConfig();
  serializationConfig.addPortableFactory(1,new PortableFactory(){
    @Override public Portable create(    int classId){
      return new CustomCredentials_retried();
    }
  }
);
  Config config=new Config();
  config.setSerializationConfig(serializationConfig);
  hazelcastFactory.newHazelcastInstance(config);
  ClientConfig clientConfig=new ClientConfig();
  clientConfig.getNetworkConfig().setConnectionAttemptLimit(1);
  clientConfig.setCredentials(new CustomCredentials_retried("String_Node_Str","String_Node_Str"));
  clientConfig.setSerializationConfig(serializationConfig);
  hazelcastFactory.newHazelcastClient(clientConfig);
}

Fixed version (ground truth):
@Test public void testClientConnected_withFirstAuthenticationRetried() throws InterruptedException {
  SerializationConfig serializationConfig=new SerializationConfig();
  serializationConfig.addPortableFactory(1,new PortableFactory(){
    @Override public Portable create(    int classId){
      return new CustomCredentials_retried();
    }
  }
);
  Config config=new Config();
  config.setSerializationConfig(serializationConfig);
  hazelcastFactory.newHazelcastInstance(config);
  ClientConfig clientConfig=new ClientConfig();
  clientConfig.getNetworkConfig().setConnectionTimeout(30000);
  clientConfig.getNetworkConfig().setConnectionAttemptLimit(1);
  clientConfig.setCredentials(new CustomCredentials_retried("String_Node_Str","String_Node_Str"));
  clientConfig.setSerializationConfig(serializationConfig);
  hazelcastFactory.newHazelcastClient(clientConfig);
}
Program: 45804
Project: 45804
Buggy source:
@Override public void run(){
  responses=new MapEntries(recordStore.size());
  EntryOperator operator=operator(this,backupProcessor,getPredicate());
  Iterator<Record> iterator=recordStore.iterator(Clock.currentTimeMillis(),true);
  while (iterator.hasNext()) {
    Record record=iterator.next();
    operator.operateOnKey(record.getKey()).doPostOperateOps();
  }
}

Fixed version (ground truth):
@Override public void run(){
  EntryOperator operator=operator(this,backupProcessor,getPredicate());
  Iterator<Record> iterator=recordStore.iterator(Clock.currentTimeMillis(),true);
  while (iterator.hasNext()) {
    Record record=iterator.next();
    operator.operateOnKey(record.getKey()).doPostOperateOps();
  }
}
Program: 45805
Project: 45805
Buggy source:
@Test(expected=HazelcastClientNotActiveException.class) public void testExceptionAfterClientShutdown() throws Exception {
  hazelcastFactory.newHazelcastInstance();
  ClientConfig clientConfig=new ClientConfig();
  clientConfig.getNetworkConfig().setConnectionAttemptLimit(1);
  HazelcastInstance client=hazelcastFactory.newHazelcastClient(clientConfig);
  IMap<Object,Object> test=client.getMap("String_Node_Str");
  test.put("String_Node_Str","String_Node_Str");
  client.shutdown();
  System.gc();
  test.get("String_Node_Str");
}

Fixed version (ground truth):
@Test(expected=HazelcastClientNotActiveException.class) public void testExceptionAfterClientShutdown() throws Exception {
  hazelcastFactory.newHazelcastInstance();
  ClientConfig clientConfig=new ClientConfig();
  HazelcastInstance client=hazelcastFactory.newHazelcastClient(clientConfig);
  IMap<Object,Object> test=client.getMap("String_Node_Str");
  test.put("String_Node_Str","String_Node_Str");
  client.shutdown();
  System.gc();
  test.get("String_Node_Str");
}
Program: 45806
Project: 45806
Buggy source:
@Test public void testClientConnected_withFirstAuthenticationRetried() throws InterruptedException {
  SerializationConfig serializationConfig=new SerializationConfig();
  serializationConfig.addPortableFactory(1,new PortableFactory(){
    @Override public Portable create(    int classId){
      return new CustomCredentials_retried();
    }
  }
);
  Config config=new Config();
  config.setSerializationConfig(serializationConfig);
  hazelcastFactory.newHazelcastInstance(config);
  ClientConfig clientConfig=new ClientConfig();
  clientConfig.getNetworkConfig().setConnectionAttemptLimit(1);
  clientConfig.setCredentials(new CustomCredentials_retried("String_Node_Str","String_Node_Str"));
  clientConfig.setSerializationConfig(serializationConfig);
  hazelcastFactory.newHazelcastClient(clientConfig);
}

Fixed version (ground truth):
@Test public void testClientConnected_withFirstAuthenticationRetried() throws InterruptedException {
  SerializationConfig serializationConfig=new SerializationConfig();
  serializationConfig.addPortableFactory(1,new PortableFactory(){
    @Override public Portable create(    int classId){
      return new CustomCredentials_retried();
    }
  }
);
  Config config=new Config();
  config.setSerializationConfig(serializationConfig);
  hazelcastFactory.newHazelcastInstance(config);
  ClientConfig clientConfig=new ClientConfig();
  clientConfig.getNetworkConfig().setConnectionTimeout(30000);
  clientConfig.getNetworkConfig().setConnectionAttemptLimit(1);
  clientConfig.setCredentials(new CustomCredentials_retried("String_Node_Str","String_Node_Str"));
  clientConfig.setSerializationConfig(serializationConfig);
  hazelcastFactory.newHazelcastClient(clientConfig);
}
Program: 45807
Project: 45807
Buggy source:
@Override public boolean cancel(boolean mayInterruptIfRunning){
  boolean removeOnCancel=!executor.isShutdown() && this.removeOnCancel;
  boolean cancelled=delegate.cancel(mayInterruptIfRunning);
  if (cancelled && removeOnCancel) {
    executor.remove(this);
  }
  return cancelled;
}

Fixed version (ground truth):
@Override public boolean cancel(boolean mayInterruptIfRunning){
  boolean removeOnCancel=!executor.isShutdown();
  boolean cancelled=delegate.cancel(mayInterruptIfRunning);
  if (cancelled && removeOnCancel) {
    executor.remove(this);
  }
  return cancelled;
}
Program: 45808
Project: 45808
Buggy source:
public LoggingScheduledExecutor(ILogger logger,int corePoolSize,ThreadFactory threadFactory,boolean removeOnCancel,RejectedExecutionHandler handler){
  super(corePoolSize,threadFactory,handler);
  this.logger=checkNotNull(logger,"String_Node_Str");
  this.removeOnCancel=removeOnCancel;
}

Fixed version (ground truth):
public LoggingScheduledExecutor(ILogger logger,int corePoolSize,ThreadFactory threadFactory,boolean removeOnCancel,RejectedExecutionHandler handler){
  super(corePoolSize,threadFactory,handler);
  this.logger=checkNotNull(logger,"String_Node_Str");
  this.manualRemoveOnCancel=manualRemoveOnCancel(removeOnCancel);
}
Program: 45809
Project: 45809
Buggy source:
@Override protected <V>RunnableScheduledFuture<V> decorateTask(Callable<V> callable,RunnableScheduledFuture<V> task){
  return new LoggingDelegatingFuture<V>(callable,task,this,removeOnCancel);
}

Fixed version (ground truth):
@Override protected <V>RunnableScheduledFuture<V> decorateTask(Callable<V> callable,RunnableScheduledFuture<V> task){
  if (!manualRemoveOnCancel) {
    return super.decorateTask(callable,task);
  }
  return new RemoveOnCancelFuture<V>(callable,task,this);
}
Program: 45810
Project: 45810
Buggy source:
@Override public boolean equals(Object o){
  if (this == o) {
    return true;
  }
  if (!(o instanceof LoggingDelegatingFuture)) {
    return false;
  }
  LoggingDelegatingFuture<?> that=(LoggingDelegatingFuture<?>)o;
  return delegate.equals(that.delegate);
}

Fixed version (ground truth):
@Override public boolean equals(Object o){
  if (this == o) {
    return true;
  }
  if (!(o instanceof RemoveOnCancelFuture)) {
    return false;
  }
  RemoveOnCancelFuture<?> that=(RemoveOnCancelFuture<?>)o;
  return delegate.equals(that.delegate);
}
Program: 45811
Project: 45811
Buggy source:
@Test public void logsExecutionException_withRunnable(){
  executor=new LoggingScheduledExecutor(logger,1,factory);
  executor.submit(new FailedRunnable());
  assertTrueEventually(new AssertTask(){
    @Override public void run() throws Exception {
      assertInstanceOf(RuntimeException.class,logger.getThrowable());
      String message=logger.getMessage();
      assertTrue("String_Node_Str" + message + "String_Node_Str",message.contains("String_Node_Str"));
      Level level=logger.getLevel();
      assertEquals(SEVERE,level);
    }
  }
);
}

Fixed version (ground truth):
@Test public void logsExecutionException_withRunnable(){
  executor=new LoggingScheduledExecutor(logger,1,factory);
  executor.manualRemoveOnCancel=true;
  executor.submit(new FailedRunnable());
  assertTrueEventually(new AssertTask(){
    @Override public void run() throws Exception {
      assertInstanceOf(RuntimeException.class,logger.getThrowable());
      String message=logger.getMessage();
      assertTrue("String_Node_Str" + message + "String_Node_Str",message.contains("String_Node_Str"));
      Level level=logger.getLevel();
      assertEquals(SEVERE,level);
    }
  }
);
}
Program: 45814
Project: 45814
Buggy source:
public void onDestroy(){
}

Fixed version (ground truth):
public void onDestroy(){
  partitionIndexesToAdd.clear();
}
Program: 45815
Project: 45815
Buggy source:
private static Long get(OperatingSystemMXBean mbean,String methodName,Long defaultValue){
  try {
    Method method=mbean.getClass().getMethod(methodName);
    method.setAccessible(true);
    Object value=method.invoke(mbean);
    if (value instanceof Integer) {
      return (long)(Integer)value;
    }
    if (value instanceof Double) {
      double v=(Double)value;
      return Math.round(v * PERCENT_MULTIPLIER);
    }
    if (value instanceof Long) {
      return (Long)value;
    }
    return defaultValue;
  }
 catch (  Exception e) {
    return defaultValue;
  }
}

Fixed version (ground truth):
private static Long get(OperatingSystemMXBean mbean,String methodName,Long defaultValue){
  try {
    Method method=mbean.getClass().getMethod(methodName);
    method.setAccessible(true);
    Object value=method.invoke(mbean);
    if (value instanceof Integer) {
      return (long)(Integer)value;
    }
    if (value instanceof Double) {
      double v=(Double)value;
      return Math.round(v * PERCENT_MULTIPLIER);
    }
    if (value instanceof Long) {
      return (Long)value;
    }
    return defaultValue;
  }
 catch (  RuntimeException e) {
    return defaultValue;
  }
catch (  Exception e) {
    return defaultValue;
  }
}
Program: 45816
Project: 45816
Buggy source:
@Override public void init(NodeEngine nodeEngine,Properties properties){
  this.nodeEngine=nodeEngine;
  this.mergePolicyProvider=nodeEngine.getSplitBrainMergePolicyProvider();
}

Fixed version (ground truth):
@Override public void init(NodeEngine nodeEngine,Properties properties){
  this.nodeEngine=nodeEngine;
}
Program: 45817
Project: 45817
Buggy source:
Merger(Map<String,CardinalityEstimatorContainer> snapshot){
  this.snapshot=snapshot;
}

Fixed version (ground truth):
Merger(CardinalityEstimatorContainerCollector collector){
  super(collector,nodeEngine);
}
Program: 45818
Project: 45818
Buggy source:
@Override public Runnable prepareMergeRunnable(){
  Map<String,CardinalityEstimatorContainer> state=new HashMap<String,CardinalityEstimatorContainer>();
  for (  Map.Entry<String,CardinalityEstimatorContainer> entry : containers.entrySet()) {
    SplitBrainMergePolicy mergePolicy=getMergePolicy(entry.getKey());
    int partition=getPartitionId(entry.getKey());
    if (nodeEngine.getPartitionService().isPartitionOwner(partition) && !(mergePolicy instanceof DiscardMergePolicy)) {
      state.put(entry.getKey(),entry.getValue());
    }
  }
  return new Merger(state);
}

Fixed version (ground truth):
@Override public Runnable prepareMergeRunnable(){
  CardinalityEstimatorContainerCollector collector=new CardinalityEstimatorContainerCollector(nodeEngine,containers);
  collector.run();
  return new Merger(collector);
}
Program: 45819
Project: 45819
Buggy source:
private void addOSInfo(PhoneHomeParameterCreator parameterCreator){
  OperatingSystemMXBean osMxBean=ManagementFactory.getOperatingSystemMXBean();
  try {
    parameterCreator.addParam("String_Node_Str",osMxBean.getName());
    parameterCreator.addParam("String_Node_Str",osMxBean.getArch());
    parameterCreator.addParam("String_Node_Str",osMxBean.getVersion());
  }
 catch (  SecurityException e) {
    parameterCreator.addParam("String_Node_Str","String_Node_Str");
    parameterCreator.addParam("String_Node_Str","String_Node_Str");
    parameterCreator.addParam("String_Node_Str","String_Node_Str");
  }
}

Fixed version (ground truth):
private void addOSInfo(PhoneHomeParameterCreator parameterCreator){
  OperatingSystemMXBean osMxBean=ManagementFactory.getOperatingSystemMXBean();
  try {
    parameterCreator.addParam("String_Node_Str",osMxBean.getName()).addParam("String_Node_Str",osMxBean.getArch()).addParam("String_Node_Str",osMxBean.getVersion());
  }
 catch (  SecurityException e) {
    parameterCreator.addParam("String_Node_Str","String_Node_Str").addParam("String_Node_Str","String_Node_Str").addParam("String_Node_Str","String_Node_Str");
  }
}
Program: 45821
Project: 45821
Buggy source:
public void check(final Node hazelcastNode,final String version,final boolean isEnterprise){
  ILogger logger=hazelcastNode.getLogger(PhoneHome.class);
  if (!hazelcastNode.getProperties().getBoolean(GroupProperty.VERSION_CHECK_ENABLED)) {
    logger.warning(GroupProperty.VERSION_CHECK_ENABLED.getName() + "String_Node_Str" + GroupProperty.PHONE_HOME_ENABLED.getName()+ "String_Node_Str");
    return;
  }
  if (!hazelcastNode.getProperties().getBoolean(GroupProperty.PHONE_HOME_ENABLED)) {
    return;
  }
  if (FALSE.equals(getenv("String_Node_Str"))) {
    return;
  }
  try {
    hazelcastNode.nodeEngine.getExecutionService().scheduleWithRepetition(new Runnable(){
      public void run(){
        phoneHome(hazelcastNode,version,isEnterprise);
      }
    }
,0,1,TimeUnit.DAYS);
  }
 catch (  RejectedExecutionException e) {
    logger.warning("String_Node_Str");
  }
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") public void check(final Node hazelcastNode,final String version,final boolean isEnterprise){
  ILogger logger=hazelcastNode.getLogger(PhoneHome.class);
  if (!hazelcastNode.getProperties().getBoolean(GroupProperty.VERSION_CHECK_ENABLED)) {
    logger.warning(GroupProperty.VERSION_CHECK_ENABLED.getName() + "String_Node_Str" + GroupProperty.PHONE_HOME_ENABLED.getName()+ "String_Node_Str");
    return;
  }
  if (!hazelcastNode.getProperties().getBoolean(GroupProperty.PHONE_HOME_ENABLED)) {
    return;
  }
  if (FALSE.equals(getenv("String_Node_Str"))) {
    return;
  }
  try {
    phoneHomeFuture=hazelcastNode.nodeEngine.getExecutionService().scheduleWithRepetition("String_Node_Str",new Runnable(){
      public void run(){
        phoneHome(hazelcastNode,version,isEnterprise);
      }
    }
,0,1,TimeUnit.DAYS);
  }
 catch (  RejectedExecutionException e) {
    logger.warning("String_Node_Str");
  }
}
Program: 45822
Project: 45822
Buggy source:
public PhoneHomeParameterCreator(){
  builder=new StringBuilder();
  builder.append("String_Node_Str");
}

Fixed version (ground truth):
PhoneHomeParameterCreator(){
  builder=new StringBuilder();
  builder.append("String_Node_Str");
}