nus-yam/ex-repair huggingface dataset:
Program: 55411
Project: 55411
Buggy source:
@Test public void testDoubleValues() throws IOException, InterruptedException {
  supplyMap(Double.class,Double.class,mapProxy -> {
    mapProxy.put(1.0,1.0);
    mapProxy.put(2.0,2.0);
    assertEquals(1.0,mapProxy.get(1.0),0);
    assertEquals(2.0,mapProxy.get(2.0),0);
    assertEquals(2,mapProxy.size());
  }
);
}

Fixed version (ground truth):
@Test public void testDoubleValues() throws IOException, InterruptedException {
  supplyMap(Double.class,Double.class,mapProxy -> {
    mapProxy.put(1.0,1.0);
    mapProxy.put(2.0,2.0);
    mapProxy.put(3.0,0.0);
    assertEquals(1.0,mapProxy.get(1.0),0);
    assertEquals(2.0,mapProxy.get(2.0),0);
    assertEquals(0.0,mapProxy.get(3.0),0);
    assertEquals(3,mapProxy.size());
  }
);
}
Program: 55412
Project: 55412
Buggy source:
@Test public void testFloatValues() throws IOException, InterruptedException {
  supplyMap(Float.class,Float.class,mapProxy -> {
    mapProxy.put(1.0f,1.0f);
    mapProxy.put(2.0f,2.0f);
    assertEquals(1.0f,mapProxy.get(1.0f),0);
    assertEquals(2.0f,mapProxy.get(2.0f),0);
    assertEquals(2,mapProxy.size());
  }
);
}

Fixed version (ground truth):
@Test public void testFloatValues() throws IOException, InterruptedException {
  supplyMap(Float.class,Float.class,mapProxy -> {
    mapProxy.put(1.0f,1.0f);
    mapProxy.put(2.0f,2.0f);
    mapProxy.put(3.0f,0.0f);
    assertEquals(1.0f,mapProxy.get(1.0f),0);
    assertEquals(2.0f,mapProxy.get(2.0f),0);
    assertEquals(0.0f,mapProxy.get(3.0f),0);
    assertEquals(3,mapProxy.size());
  }
);
}
Program: 55413
Project: 55413
Buggy source:
/** 
 * write and exceptions and rolls back if no data was written
 */
void writeData(@NotNull Consumer<WireOut> c){
  outWire.writeDocument(false,out -> {
    final long position=outWire.bytes().writePosition();
    try {
      c.accept(outWire);
    }
 catch (    Exception exception) {
      LOG.error("String_Node_Str",exception);
      outWire.bytes().writePosition(position);
      outWire.writeEventName(() -> "String_Node_Str").throwable(exception);
    }
    if (position == outWire.bytes().writePosition()) {
      outWire.writeEventName(reply).marshallable(EMPTY);
    }
  }
);
  if (YamlLogging.showServerWrites)   try {
    System.out.println("String_Node_Str" + Wires.fromSizePrefixedBlobs(outWire.bytes(),0,outWire.bytes().writePosition()));
  }
 catch (  Exception e) {
    System.out.println("String_Node_Str" + outWire.bytes().toDebugString());
  }
}

Fixed version (ground truth):
/** 
 * write and exceptions and rolls back if no data was written
 */
void writeData(Bytes inBytes,@NotNull Consumer<WireOut> c){
  outWire.writeDocument(false,out -> {
    final long readPosition=inBytes.readPosition();
    final long position=outWire.bytes().writePosition();
    try {
      c.accept(outWire);
    }
 catch (    Throwable t) {
      inBytes.readPosition(readPosition);
      LOG.info("String_Node_Str" + inBytes.toDebugString(),"String_Node_Str" + c,t);
      outWire.bytes().writePosition(position);
      outWire.writeEventName(() -> "String_Node_Str").throwable(t);
    }
    if (position == outWire.bytes().writePosition()) {
      outWire.writeEventName(reply).marshallable(EMPTY);
    }
  }
);
  if (YamlLogging.showServerWrites)   try {
    System.out.println("String_Node_Str" + Wires.fromSizePrefixedBlobs(outWire.bytes(),0,outWire.bytes().writePosition()));
  }
 catch (  Exception e) {
    System.out.println("String_Node_Str" + outWire.bytes().toDebugString());
  }
}
Program: 55414
Project: 55414
Buggy source:
HostPort(final String host,final int port){
  this.host=host;
  this.port=port;
}

Fixed version (ground truth):
HostPort(@NotNull final String host,final int port){
  this.host=host;
  this.port=port;
}
Program: 55416
Project: 55416
Buggy source:
private static String toUri(final RequestContext context){
  final StringBuilder uri=new StringBuilder("String_Node_Str" + context.name() + "String_Node_Str"+ "String_Node_Str");
  if (context.keyType() != String.class)   uri.append("String_Node_Str").append(context.keyType().getName());
  if (context.valueType() != String.class)   uri.append("String_Node_Str").append(context.valueType().getName());
  return uri.toString();
}

Fixed version (ground truth):
private static String toUri(final RequestContext context){
  final StringBuilder uri=new StringBuilder(context.fullName() + "String_Node_Str" + "String_Node_Str");
  if (context.keyType() != String.class)   uri.append("String_Node_Str").append(context.keyType().getName());
  if (context.valueType() != String.class)   uri.append("String_Node_Str").append(context.valueType().getName());
  return uri.toString();
}
Program: 55418
Project: 55418
Buggy source:
@Override public boolean runOnce(){
  TcpChannelHub hub=ReplicationHub.this.hub;
  hub.outBytesLock().lock();
  try {
    ReplicationHub.this.writeMetaDataForKnownTID(tid0.get());
    mi.forEach(e -> hub.outWire().writeDocument(false,wireOut -> wireOut.writeEventName(replicationEvent).typedMarshallable(e)));
    hub.writeSocket(hub.outWire());
  }
 catch (  InterruptedException e) {
    throw Jvm.rethrow(e);
  }
 finally {
    hub.outBytesLock().unlock();
  }
  return !isClosed.get();
}

Fixed version (ground truth):
@Override public boolean runOnce(){
  TcpChannelHub hub=ReplicationHub.this.hub;
  hub.outBytesLock().lock();
  try {
    mi.forEach(e -> {
      sendEventAsyncWithoutLock(replicationEvent,(Consumer<ValueOut>)(v -> v.typedMarshallable(e)));
    }
);
  }
 catch (  InterruptedException e) {
    throw Jvm.rethrow(e);
  }
 finally {
    hub.outBytesLock().unlock();
  }
  return !isClosed.get();
}
Program: 55419
Project: 55419
Buggy source:
@Nullable public AcceptorEventHandler start(int port,@NotNull final AssetTree asset) throws IOException {
  eg.start();
  AcceptorEventHandler eah=new AcceptorEventHandler(port,() -> new EngineWireHandler(WireType.wire,asset),VanillaSessionDetails::new);
  eg.addHandler(eah);
  this.eah=eah;
  return eah;
}

Fixed version (ground truth):
@Nullable public AcceptorEventHandler start(int port,@NotNull final AssetTree asset) throws IOException {
  eg.start();
  AcceptorEventHandler eah=new AcceptorEventHandler(port,() -> new EngineWireHandler(WireType.wire,asset,isClosed),VanillaSessionDetails::new);
  eg.addHandler(eah);
  this.eah=eah;
  return eah;
}
Program: 55420
Project: 55420
Buggy source:
@Override public void close(){
  stop();
  closeQuietly(eg);
  eg=null;
  closeQuietly(eah);
  eah=null;
}

Fixed version (ground truth):
@Override public void close(){
  isClosed.set(true);
  stop();
  closeQuietly(eg);
  eg=null;
  closeQuietly(eah);
  eah=null;
}
Program: 55422
Project: 55422
Buggy source:
public EngineWireHandler(@NotNull final Function<Bytes,Wire> byteToWire,@NotNull final AssetTree assetTree){
  super(byteToWire);
  this.sessionProvider=assetTree.root().getView(SessionProvider.class);
  this.assetTree=assetTree;
  this.mapWireHandler=new MapWireHandler<>();
  this.queueWireHandler=null;
  this.metaDataConsumer=wireInConsumer();
  this.keySetHandler=new CollectionWireHandlerProcessor<>();
  this.entrySetHandler=new CollectionWireHandlerProcessor<>();
  this.valuesHandler=new CollectionWireHandlerProcessor<>();
  this.subscriptionHandler=new SubscriptionHandlerProcessor();
  this.topicPublisherHandler=new TopicPublisherHandler();
  this.publisherHandler=new PublisherHandler();
  this.replicationHandler=new ReplicationHandler();
}

Fixed version (ground truth):
public EngineWireHandler(@NotNull final Function<Bytes,Wire> byteToWire,@NotNull final AssetTree assetTree,@NotNull final AtomicBoolean isClosed){
  super(byteToWire);
  this.sessionProvider=assetTree.root().getView(SessionProvider.class);
  this.eventLoop=assetTree.root().findOrCreateView(EventLoop.class);
  this.hostIdentifier=assetTree.root().findOrCreateView(HostIdentifier.class);
  this.assetTree=assetTree;
  this.mapWireHandler=new MapWireHandler<>();
  this.queueWireHandler=null;
  this.metaDataConsumer=wireInConsumer();
  this.keySetHandler=new CollectionWireHandlerProcessor<>();
  this.entrySetHandler=new CollectionWireHandlerProcessor<>();
  this.valuesHandler=new CollectionWireHandlerProcessor<>();
  this.subscriptionHandler=new SubscriptionHandlerProcessor();
  this.topicPublisherHandler=new TopicPublisherHandler();
  this.publisherHandler=new PublisherHandler();
  this.replicationHandler=new ReplicationHandler();
  this.isClosed=isClosed;
  eventLoop.start();
}
Program: 55423
Project: 55423
Buggy source:
@NotNull private Consumer<WireIn> wireInConsumer(){
  return (wire) -> {
    isSystemMessage=wire.bytes().readRemaining() == 0;
    if (isSystemMessage) {
      if (LOG.isDebugEnabled())       LOG.debug("String_Node_Str");
      return;
    }
    try {
      readCsp(wire);
      readTid(wire);
      if (hasCspChanged(cspText)) {
        if (LOG.isDebugEnabled())         LOG.debug("String_Node_Str" + wire.bytes().toHexString());
        requestContext=RequestContext.requestContext(cspText);
        viewType=requestContext.viewType();
        asset=this.assetTree.acquireAsset(viewType,requestContext);
        view=asset.acquireView(requestContext);
        mapView=this.assetTree.acquireAsset(MapView.class,requestContext);
        requestContext.keyType();
        if (viewType == MapView.class || viewType == EntrySetView.class || viewType == ValuesCollection.class || viewType == KeySetView.class || viewType == ObjectKVSSubscription.class || viewType == ObjectKVSSubscription.class || viewType == TopicPublisher.class || viewType == Publisher.class || viewType == Replication.class) {
          final Class type=requestContext.type() == null ? String.class : requestContext.keyType();
          final Class type2=requestContext.type2() == null ? String.class : requestContext.valueType();
          wireAdapter=new GenericWireAdapter(type,type2);
        }
 else         throw new UnsupportedOperationException("String_Node_Str");
      }
    }
 catch (    Exception e) {
      LOG.error("String_Node_Str",e);
      rethrow(e);
    }
  }
;
}

Fixed version (ground truth):
@NotNull private Consumer<WireIn> wireInConsumer(){
  return (wire) -> {
    isSystemMessage=wire.bytes().readRemaining() == 0;
    if (isSystemMessage) {
      if (LOG.isDebugEnabled())       LOG.debug("String_Node_Str");
      return;
    }
    try {
      readCsp(wire);
      readTid(wire);
      if (hasCspChanged(cspText)) {
        if (LOG.isDebugEnabled())         LOG.debug("String_Node_Str" + wire.bytes().toHexString());
        requestContext=RequestContext.requestContext(cspText);
        viewType=requestContext.viewType();
        asset=this.assetTree.acquireAsset(viewType,requestContext);
        view=asset.acquireView(requestContext);
        requestContext.keyType();
        if (viewType == MapView.class || viewType == EntrySetView.class || viewType == ValuesCollection.class || viewType == KeySetView.class || viewType == ObjectKVSSubscription.class || viewType == ObjectKVSSubscription.class || viewType == TopicPublisher.class || viewType == Publisher.class || viewType == Replication.class) {
          final Class type=requestContext.type() == null ? String.class : requestContext.keyType();
          final Class type2=requestContext.type2() == null ? String.class : requestContext.valueType();
          wireAdapter=new GenericWireAdapter(type,type2);
        }
 else         throw new UnsupportedOperationException("String_Node_Str");
      }
    }
 catch (    Exception e) {
      LOG.error("String_Node_Str",e);
      rethrow(e);
    }
  }
;
}
Program: 55424
Project: 55424
Buggy source:
@Override public void readMarshallable(WireIn wire) throws IllegalStateException {
  StringBuilder clusterName=new StringBuilder();
  StringBuilder hostDescription=new StringBuilder();
  while (wire.hasMore()) {
    wire.readEventName(clusterName).marshallable(host -> {
      Map<String,HostDetails> hdMap=clusterMap.computeIfAbsent(clusterName.toString(),k -> new ConcurrentSkipListMap<>());
      host.readEventName(hostDescription).marshallable(details -> {
        HostDetails hd=new HostDetails();
        hd.readMarshallable(details);
        hdMap.put(hostDescription.toString(),hd);
      }
);
    }
);
  }
}

Fixed version (ground truth):
@Override public void readMarshallable(WireIn wire) throws IllegalStateException {
  StringBuilder clusterName=new StringBuilder();
  StringBuilder hostDescription=new StringBuilder();
  while (wire.hasMore()) {
    wire.readEventName(clusterName).marshallable(host -> {
      Map<String,HostDetails> hdMap=clusterMap.computeIfAbsent(clusterName.toString(),k -> new ConcurrentSkipListMap<>());
      while (wire.hasMore()) {
        host.readEventName(hostDescription).marshallable(details -> {
          HostDetails hd=new HostDetails();
          hd.readMarshallable(details);
          hdMap.put(hostDescription.toString(),hd);
        }
);
      }
    }
);
  }
}
Program: 55425
Project: 55425
Buggy source:
public void bootstrap(EngineReplication replication,int localIdentifer) throws InterruptedException {
  final byte remoteIdentifier=proxyReturnByte(identifierReply,identifier);
  final ModificationIterator mi=replication.acquireModificationIterator(remoteIdentifier);
  final long lastModificationTime=replication.lastModificationTime(remoteIdentifier);
  final Bootstrap bootstrap=new Bootstrap();
  bootstrap.lastUpdatedTime(lastModificationTime);
  bootstrap.identifier((byte)localIdentifer);
  final Function<ValueIn,Bootstrap> typedMarshallable=ValueIn::typedMarshallable;
  final Consumer<ValueOut> valueOutConsumer=o -> o.typedMarshallable(bootstrap);
  final Bootstrap b=(Bootstrap)proxyReturnWireConsumerInOut(bootstap,bootstrapReply,valueOutConsumer,typedMarshallable);
  try {
    startSubscription(replication,localIdentifer);
    mi.setModificationNotifier(() -> {
      eventLoop.unpause();
    }
);
    eventLoop.addHandler(new EventHandler(){
      @Override public boolean runOnce(){
        TcpChannelHub hub=ReplicationHub.this.hub;
        hub.outBytesLock().lock();
        try {
          mi.forEach(e -> {
            sendEventAsyncWithoutLock(replicationEvent,(Consumer<ValueOut>)(v -> v.typedMarshallable(e)));
          }
);
        }
 catch (        InterruptedException e) {
          throw Jvm.rethrow(e);
        }
 finally {
          hub.outBytesLock().unlock();
        }
        return !isClosed.get();
      }
      @Override public HandlerPriority priority(){
        return HandlerPriority.MEDIUM;
      }
    }
);
    mi.dirtyEntries(b.lastUpdatedTime());
  }
 catch (  Throwable t) {
    LOG.error("String_Node_Str",t);
  }
}

Fixed version (ground truth):
public void bootstrap(EngineReplication replication,int localIdentifer) throws InterruptedException {
  final byte remoteIdentifier=proxyReturnByte(identifierReply,identifier);
  final ModificationIterator mi=replication.acquireModificationIterator(remoteIdentifier);
  final long lastModificationTime=replication.lastModificationTime(remoteIdentifier);
  final Bootstrap bootstrap=new Bootstrap();
  bootstrap.lastUpdatedTime(lastModificationTime);
  bootstrap.identifier((byte)localIdentifer);
  final Function<ValueIn,Bootstrap> typedMarshallable=ValueIn::typedMarshallable;
  final Consumer<ValueOut> valueOutConsumer=o -> o.typedMarshallable(bootstrap);
  final Bootstrap b=(Bootstrap)proxyReturnWireConsumerInOut(bootstap,bootstrapReply,valueOutConsumer,typedMarshallable);
  try {
    subscribe(replication,localIdentifer);
    publish(mi,b);
  }
 catch (  Throwable t) {
    LOG.error("String_Node_Str",t);
  }
}
Program: 55426
Project: 55426
Buggy source:
@Override public boolean runOnce(){
  TcpChannelHub hub=ReplicationHub.this.hub;
  hub.outBytesLock().lock();
  try {
    mi.forEach(e -> {
      sendEventAsyncWithoutLock(replicationEvent,(Consumer<ValueOut>)(v -> v.typedMarshallable(e)));
    }
);
  }
 catch (  InterruptedException e) {
    throw Jvm.rethrow(e);
  }
 finally {
    hub.outBytesLock().unlock();
  }
  return !isClosed.get();
}

Fixed version (ground truth):
@Override public boolean runOnce(){
  hub.lock(() -> mi.forEach(e -> sendEventAsyncWithoutLock(replicationEvent,(Consumer<ValueOut>)v -> v.typedMarshallable(e))));
  return !isClosed.get();
}
Program: 55427
Project: 55427
Buggy source:
@AfterClass public static void after(){
  serverEndpoint1.close();
  serverEndpoint2.close();
  tree1.close();
  tree2.close();
}

Fixed version (ground truth):
@AfterClass public static void after(){
  if (serverEndpoint1 != null)   serverEndpoint1.close();
  if (serverEndpoint2 != null)   serverEndpoint2.close();
  if (tree1 != null)   tree1.close();
  if (tree2 != null)   tree2.close();
}
Program: 55428
Project: 55428
Buggy source:
@Override public void registerTopicSubscriber(RequestContext rc,TopicSubscriber<K,V> subscriber){
}

Fixed version (ground truth):
@Override public void registerTopicSubscriber(RequestContext rc,TopicSubscriber<K,V> subscriber){
  final long startTime=System.currentTimeMillis();
  if (hub.outBytesLock().isHeldByCurrentThread())   throw new IllegalStateException("String_Node_Str");
  hub.outBytesLock().lock();
  try {
    tid=writeMetaDataStartTime(startTime);
    subscribersToTid.put(subscriber,tid);
    hub.outWire().writeDocument(false,wireOut -> wireOut.writeEventName(registerTopicSubscriber).marshallable(m -> {
      m.write(() -> "String_Node_Str").typeLiteral(rc.keyType());
      m.write(() -> "String_Node_Str").typeLiteral(rc.valueType());
    }
));
    hub.asyncReadSocket(tid,w -> w.readDocument(null,d -> {
      ValueIn valueIn=d.read(reply);
      valueIn.marshallable(m -> {
        final String topic=m.read(() -> "String_Node_Str").text();
        final ReadMarshallable message=m.read(() -> "String_Node_Str").typedMarshallable();
        this.onEvent(topic,message,subscriber);
      }
);
    }
));
    hub.writeSocket(hub.outWire());
  }
  finally {
    hub.outBytesLock().unlock();
  }
}
Program: 55429
Project: 55429
Buggy source:
private void logToStandardOutMessageSent(@NotNull Wire wire,@NotNull ByteBuffer outBuffer){
  if (!YamlLogging.clientWrites || !Jvm.isDebug())   return;
  Bytes<?> bytes=wire.bytes();
  final long position=bytes.writePosition();
  final long limit=bytes.writeLimit();
  try {
    bytes.writeLimit(outBuffer.limit());
    bytes.writePosition(outBuffer.position());
    if (YamlLogging.clientWrites) {
      try {
        System.out.println(((!YamlLogging.title.isEmpty()) ? "String_Node_Str" + YamlLogging.title + "String_Node_Str" : "String_Node_Str") + "String_Node_Str" + YamlLogging.writeMessage+ (YamlLogging.writeMessage.isEmpty() ? "String_Node_Str" : "String_Node_Str")+ "String_Node_Str"+ "String_Node_Str"+ ((wire instanceof TextWire) ? Wires.fromSizePrefixedBlobs(bytes) : BytesUtil.toHexString(bytes,bytes.writePosition(),bytes.writeRemaining()))+ "String_Node_Str");
        YamlLogging.title="String_Node_Str";
        YamlLogging.writeMessage="String_Node_Str";
      }
 catch (      Exception e) {
        LOG.error(Bytes.toString(bytes),e);
      }
    }
  }
  finally {
    bytes.writeLimit(limit);
    bytes.writePosition(position);
  }
}

Fixed version (ground truth):
private void logToStandardOutMessageSent(@NotNull Wire wire,@NotNull ByteBuffer outBuffer){
  if (!YamlLogging.clientWrites || !Jvm.isDebug())   return;
  Bytes<?> bytes=wire.bytes();
  final long position=bytes.writePosition();
  final long limit=bytes.writeLimit();
  try {
    bytes.writeLimit(outBuffer.limit());
    bytes.writePosition(outBuffer.position());
    if (YamlLogging.clientWrites) {
      try {
        System.out.println(((!YamlLogging.title.isEmpty()) ? "String_Node_Str" + YamlLogging.title + "String_Node_Str" : "String_Node_Str") + "String_Node_Str" + YamlLogging.writeMessage+ (YamlLogging.writeMessage.isEmpty() ? "String_Node_Str" : "String_Node_Str")+ "String_Node_Str"+ "String_Node_Str"+ ((wire instanceof TextWire) ? Wires.fromSizePrefixedBlobs(bytes,bytes.writePosition(),bytes.writeLimit()) : BytesUtil.toHexString(bytes,bytes.writePosition(),bytes.writeRemaining()))+ "String_Node_Str");
        YamlLogging.title="String_Node_Str";
        YamlLogging.writeMessage="String_Node_Str";
      }
 catch (      Exception e) {
        LOG.error(Bytes.toString(bytes),e);
      }
    }
  }
  finally {
    bytes.writeLimit(limit);
    bytes.writePosition(position);
  }
}
Program: 55430
Project: 55430
Buggy source:
private void processData(final long tid,final boolean isReady,final int header,final int messageSize,Wire inWire) throws IOException {
  Object o=isReady ? map.remove(tid) : map.get(tid);
  if (o == null) {
    if (omap != null && omap.containsValue(tid)) {
      LOG.warn("String_Node_Str" + tid);
      o=omap.get(tid);
    }
 else {
      Jvm.pause(10);
      o=isReady ? map.remove(tid) : map.get(tid);
      if (o != null)       LOG.warn("String_Node_Str" + tid);
    }
  }
 else {
    if (omap != null) {
      omap.put(tid,o);
    }
  }
  if (o == null) {
    LOG.info("String_Node_Str" + tid);
    return;
  }
  if (o instanceof Consumer) {
    final Consumer<Wire> consumer=(Consumer<Wire>)o;
    blockingRead(inWire,messageSize);
    logToStandardOutMessageReceived(inWire);
    consumer.accept(inWire);
  }
 else {
    final Bytes bytes=(Bytes)o;
synchronized (bytes) {
      bytes.clear();
      final ByteBuffer byteBuffer=(ByteBuffer)bytes.underlyingObject();
      byteBuffer.clear();
      bytes.writeInt(0,header);
      byteBuffer.position(SIZE_OF_SIZE);
      byteBuffer.limit(SIZE_OF_SIZE + messageSize);
      readBuffer(byteBuffer);
      bytes.readLimit(byteBuffer.position());
      bytes.notifyAll();
    }
  }
}

Fixed version (ground truth):
private void processData(final long tid,final boolean isReady,final int header,final int messageSize,Wire inWire) throws IOException {
  long startTime=0;
  Object o;
  for (; ; ) {
    o=isReady ? map.remove(tid) : map.get(tid);
    if (o != null)     break;
    if (startTime == 0)     startTime=System.currentTimeMillis();
    if (System.currentTimeMillis() - startTime > 1000) {
      LOG.error("String_Node_Str" + tid);
      blockingRead(inWire,messageSize);
      return;
    }
  }
  if (o instanceof Consumer) {
    final Consumer<Wire> consumer=(Consumer<Wire>)o;
    blockingRead(inWire,messageSize);
    logToStandardOutMessageReceived(inWire);
    consumer.accept(inWire);
  }
 else {
    final Bytes bytes=(Bytes)o;
synchronized (bytes) {
      bytes.clear();
      final ByteBuffer byteBuffer=(ByteBuffer)bytes.underlyingObject();
      byteBuffer.clear();
      bytes.writeInt(0,header);
      byteBuffer.position(SIZE_OF_SIZE);
      byteBuffer.limit(SIZE_OF_SIZE + messageSize);
      readBuffer(byteBuffer);
      bytes.readLimit(byteBuffer.position());
      bytes.notifyAll();
    }
  }
}
Program: 55431
Project: 55431
Buggy source:
@NotNull @Override public String toString(){
  return fullName();
}

Fixed version (ground truth):
@Override public String toString(){
  return "String_Node_Str" + underlyingType;
}
Program: 55432
Project: 55432
Buggy source:
@Ignore("String_Node_Str") @Test public void testMapsAsValues() throws IOException, InterruptedException {
  supplyMap(Integer.class,Map.class,mapProxy -> {
    final Map value=new HashMap<String,String>();
{
      value.put("String_Node_Str","String_Node_Str");
      value.put("String_Node_Str","String_Node_Str");
      mapProxy.put(1,value);
    }
{
      value.put("String_Node_Str","String_Node_Str");
      value.put("String_Node_Str","String_Node_Str");
      mapProxy.put(2,value);
    }
    final Object k1=mapProxy.get(1);
    assertEquals("String_Node_Str",mapProxy.get(1).get("String_Node_Str"));
    assertEquals(null,mapProxy.get(1).get("String_Node_Str"));
    assertEquals(null,mapProxy.get(1).get("String_Node_Str"));
    assertEquals("String_Node_Str",mapProxy.get(2).get("String_Node_Str"));
    assertEquals("String_Node_Str",mapProxy.get(2).get("String_Node_Str"));
    assertEquals(2,mapProxy.size());
  }
);
}

Fixed version (ground truth):
@Test public void testMapsAsValues() throws IOException, InterruptedException {
  supplyMap(Integer.class,Map.class,map -> {
    final Map value=new HashMap<String,String>();
{
      value.put("String_Node_Str","String_Node_Str");
      value.put("String_Node_Str","String_Node_Str");
      map.put(1,value);
    }
{
      value.put("String_Node_Str","String_Node_Str");
      value.put("String_Node_Str","String_Node_Str");
      map.put(2,value);
    }
    assertEquals("String_Node_Str",map.get(1).get("String_Node_Str"));
    assertEquals("String_Node_Str",map.get(1).get("String_Node_Str"));
    assertEquals(null,map.get(1).get("String_Node_Str"));
    assertEquals(null,map.get(1).get("String_Node_Str"));
    assertEquals("String_Node_Str",map.get(2).get("String_Node_Str"));
    assertEquals("String_Node_Str",map.get(2).get("String_Node_Str"));
    assertEquals(2,map.size());
  }
);
}
Program: 55433
Project: 55433
Buggy source:
public ClientWiredStatelessChronicleCollection(@NotNull final String channelName,@NotNull final ClientWiredStatelessTcpConnectionHub hub,final long cid,@NotNull final Function<ValueIn,U> wireToSet,@NotNull final String type,@NotNull Supplier<E> factory){
  super(channelName,hub,type,cid);
  this.consumer=wireToSet;
  this.factory=factory;
}

Fixed version (ground truth):
public ClientWiredStatelessChronicleCollection(@NotNull final String channelName,@NotNull final ClientWiredStatelessTcpConnectionHub hub,final long cid,@NotNull final Function<ValueIn,U> wireToSet,@NotNull Supplier<E> factory,String csp){
  super(channelName,hub,cid,csp);
  this.consumer=wireToSet;
  this.factory=factory;
}
Program: 55434
Project: 55434
Buggy source:
public ClientWiredStatelessChronicleSet(@NotNull String channelName,@NotNull ClientWiredStatelessTcpConnectionHub hub,long cid,@NotNull Function<ValueIn,U> wireToSet,@NotNull String type){
  super(channelName,hub,cid,wireToSet,type,HashSet::new);
}

Fixed version (ground truth):
public ClientWiredStatelessChronicleSet(@NotNull String channelName,@NotNull ClientWiredStatelessTcpConnectionHub hub,long cid,@NotNull Function<ValueIn,U> wireToSet,String csp){
  super(channelName,hub,cid,wireToSet,HashSet::new,csp);
}
Program: 55435
Project: 55435
Buggy source:
@Override protected void process(@NotNull final Wire in,@NotNull final Wire out) throws StreamCorruptedException {
  logYamlToStandardOut(in);
  in.readDocument(this.metaDataConsumer,(  WireIn dataWire) -> {
    try {
      if (mapHandler != null) {
        if (viewType == MapView.class) {
          mapWireHandler.process(in,out,(MapView)view,cspText,tid,mapHandler);
          return;
        }
        if (viewType == EntrySetView.class) {
          entrySetHandler.process(in,out,(EntrySetView)view,cspText,mapHandler.getEntryToWire(),mapHandler.getWireToEntry(),HashSet::new,tid);
          return;
        }
        if (viewType == KeySetView.class) {
          keySetHandler.process(in,out,(KeySetView)view,cspText,mapHandler.getKeyToWire(),mapHandler.getWireToKey(),HashSet::new,tid);
          return;
        }
        if (viewType == ValuesView.class) {
          valuesHander.process(in,out,(ValuesView)view,cspText,mapHandler.getKeyToWire(),mapHandler.getWireToKey(),ArrayList::new,tid);
          return;
        }
      }
      if (endsWith(cspText,"String_Node_Str") && queueWireHandler != null) {
        queueWireHandler.process(in,out);
      }
    }
 catch (    Exception e) {
      LOG.error("String_Node_Str",e);
    }
  }
);
}

Fixed version (ground truth):
@Override protected void process(@NotNull final Wire in,@NotNull final Wire out) throws StreamCorruptedException {
  logYamlToStandardOut(in);
  in.readDocument(this.metaDataConsumer,(  WireIn dataWire) -> {
    try {
      if (mapHandler != null) {
        final Class viewType=requestContext.viewType();
        if (viewType == MapView.class) {
          mapWireHandler.process(in,out,(MapView)view,cspText,tid,mapHandler,requestContext);
          return;
        }
        if (viewType == EntrySetView.class) {
          entrySetHandler.process(in,out,(EntrySetView)view,cspText,mapHandler.getEntryToWire(),mapHandler.getWireToEntry(),HashSet::new,tid);
          return;
        }
        if (viewType == KeySetView.class) {
          keySetHandler.process(in,out,(KeySetView)view,cspText,mapHandler.getKeyToWire(),mapHandler.getWireToKey(),HashSet::new,tid);
          return;
        }
        if (viewType == ValuesView.class) {
          valuesHander.process(in,out,(ValuesView)view,cspText,mapHandler.getKeyToWire(),mapHandler.getWireToKey(),ArrayList::new,tid);
          return;
        }
      }
      if (endsWith(cspText,"String_Node_Str") && queueWireHandler != null) {
        queueWireHandler.process(in,out);
      }
    }
 catch (    Exception e) {
      LOG.error("String_Node_Str",e);
    }
  }
);
}
Program: 55436
Project: 55436
Buggy source:
@NotNull private Consumer<WireIn> getWireInConsumer() throws IOException {
  return (metaDataWire) -> {
    try {
      readCsp(metaDataWire);
      readTid(metaDataWire);
      if (!cspText.equals(lastCsp)) {
        lastCsp=cspText;
        serviceName=serviceName(cspText);
        final RequestContext requestContext=RequestContext.requestContext(cspText);
        final Asset asset=Chassis.acquireAsset(requestContext);
        view=asset.acquireView(requestContext);
        viewType=requestContext.viewType();
        requestContext.keyType();
        if (viewType == MapView.class || viewType == EntrySetView.class || viewType == ValuesView.class || viewType == KeySetView.class)         mapHandler=new GenericMapHandler(requestContext.keyType(),requestContext.valueType());
 else         throw new UnsupportedOperationException("String_Node_Str");
      }
    }
 catch (    Exception e) {
      rethrow(e);
    }
  }
;
}

Fixed version (ground truth):
@NotNull private Consumer<WireIn> getWireInConsumer() throws IOException {
  return (metaDataWire) -> {
    try {
      readCsp(metaDataWire);
      readTid(metaDataWire);
      if (hasCspChanged(cspText)) {
        requestContext=RequestContext.requestContext(cspText);
        final Asset asset=Chassis.acquireAsset(requestContext);
        view=asset.acquireView(requestContext);
        requestContext.keyType();
        final Class viewType=requestContext.viewType();
        if (viewType == MapView.class || viewType == EntrySetView.class || viewType == ValuesView.class || viewType == KeySetView.class)         mapHandler=new GenericMapHandler(requestContext.keyType(),requestContext.valueType());
 else         throw new UnsupportedOperationException("String_Node_Str");
      }
    }
 catch (    Exception e) {
      rethrow(e);
    }
  }
;
}
Program: 55437
Project: 55437
Buggy source:
/** 
 * peeks the csp or if it has a cid converts the cid into a Csp and returns that
 */
private void readCsp(@NotNull final WireIn wireIn){
  final StringBuilder keyName=Wires.acquireStringBuilder();
  final ValueIn read=wireIn.readEventName(keyName);
  if (csp.contentEquals(keyName)) {
    read.textTo(cspText);
  }
 else   if (cid.contentEquals(keyName)) {
    final long cid=read.int64();
    final CharSequence s=cidToCsp.get(cid);
    cspText.setLength(0);
    cspText.append(s);
  }
}

Fixed version (ground truth):
/** 
 * peeks the csp or if it has a cid converts the cid into a Csp and returns that
 */
private void readCsp(@NotNull final WireIn wireIn){
  final StringBuilder keyName=Wires.acquireStringBuilder();
  cspText.setLength(0);
  final ValueIn read=wireIn.readEventName(keyName);
  if (csp.contentEquals(keyName)) {
    read.textTo(cspText);
  }
 else   if (cid.contentEquals(keyName)) {
    final long cid=read.int64();
    final CharSequence s=cidToCsp.get(cid);
    cspText.append(s);
  }
}
Program: 55438
Project: 55438
Buggy source:
public void process(@NotNull final Wire in,@NotNull final Wire out,@NotNull Map<K,V> map,@NotNull final CharSequence csp,long tid,@NotNull final MapHandler<K,V> mapHandler) throws StreamCorruptedException {
  this.vToWire=mapHandler.getValueToWire();
  this.wireToK=mapHandler.getWireToKey();
  this.wireToV=mapHandler.getWireToValue();
  try {
    this.inWire=in;
    this.outWire=out;
    this.map=map;
    charSequenceValue=map instanceof ChronicleMap && CharSequence.class == ((ChronicleMap)map).valueClass();
    this.csp=csp;
    this.tid=tid;
    dataConsumer.accept(in);
  }
 catch (  Exception e) {
    LOG.error("String_Node_Str",e);
  }
}

Fixed version (ground truth):
public void process(@NotNull final Wire in,@NotNull final Wire out,@NotNull Map<K,V> map,@NotNull final CharSequence csp,long tid,@NotNull final MapHandler<K,V> mapHandler,@NotNull final RequestContext requestContext) throws StreamCorruptedException {
  this.vToWire=mapHandler.getValueToWire();
  this.wireToK=mapHandler.getWireToKey();
  this.wireToV=mapHandler.getWireToValue();
  this.requestContext=requestContext;
  try {
    this.inWire=in;
    this.outWire=out;
    this.map=map;
    charSequenceValue=map instanceof ChronicleMap && CharSequence.class == ((ChronicleMap)map).valueClass();
    this.csp=csp;
    this.tid=tid;
    dataConsumer.accept(in);
  }
 catch (  Exception e) {
    LOG.error("String_Node_Str",e);
  }
}
Program: 55439
Project: 55439
Buggy source:
private void createProxy(final String type){
  outWire.writeEventName(reply).type("String_Node_Str").writeValue().marshallable(w -> {
    CharSequence root=csp.subSequence(0,csp.length() - "String_Node_Str".length());
    final StringBuilder csp=acquireStringBuilder().append(root).append(type);
    w.writeEventName(CoreFields.csp).text(csp);
    w.writeEventName(CoreFields.cid).int64(createCid(csp));
  }
);
}

Fixed version (ground truth):
private void createProxy(final String type){
  outWire.writeEventName(reply).type("String_Node_Str").writeValue().marshallable(w -> {
    cpsBuff.setLength(0);
    cpsBuff.append("String_Node_Str").append(requestContext.name());
    cpsBuff.append("String_Node_Str");
    cpsBuff.append("String_Node_Str").append(type);
    cpsBuff.append("String_Node_Str");
    cpsBuff.append("String_Node_Str").append(requestContext.keyType().getSimpleName());
    cpsBuff.append("String_Node_Str");
    cpsBuff.append("String_Node_Str").append(requestContext.valueType().getSimpleName());
    w.writeEventName(CoreFields.csp).text(cpsBuff);
    w.writeEventName(CoreFields.cid).int64(createCid(cpsBuff));
  }
);
}
Program: 55440
Project: 55440
Buggy source:
@NotNull @Override public Collection<V> values(){
  long cid=proxyReturnWireConsumer(values,read -> {
    final StringBuilder type=Wires.acquireStringBuilder();
    read.type(type);
    return read.applyToMarshallable(w -> {
      final String csp1=csp(w).toString();
      final long cid0=CoreFields.cid(w);
      cidToCsp.put(cid0,csp1);
      return cid0;
    }
);
  }
);
  final Function<ValueIn,V> conumer=valueIn -> valueIn.object(vClass);
  return new ClientWiredStatelessChronicleCollection<>(channelName,hub,cid,conumer,"String_Node_Str",ArrayList::new);
}

Fixed version (ground truth):
@NotNull @Override public Collection<V> values(){
  long cid=proxyReturnWireConsumer(values,read -> {
    final StringBuilder type=Wires.acquireStringBuilder();
    read.type(type);
    return read.applyToMarshallable(w -> {
      final String csp1=csp(w).toString();
      final long cid0=CoreFields.cid(w);
      cidToCsp.put(cid0,csp1);
      return cid0;
    }
);
  }
);
  final Function<ValueIn,V> conumer=valueIn -> valueIn.object(vClass);
  return new ClientWiredStatelessChronicleCollection<>(channelName,hub,cid,conumer,ArrayList::new,"String_Node_Str" + channelName + "String_Node_Str"+ "String_Node_Str");
}
Program: 55441
Project: 55441
Buggy source:
public ClientWiredStatelessChronicleMap(@NotNull final ClientWiredChronicleMapStatelessBuilder config,@NotNull final Class<K> kClass,@NotNull final Class<V> vClass,@NotNull final String channelName,@NotNull final ClientWiredStatelessTcpConnectionHub hub){
  super(channelName,hub,"String_Node_Str" + kClass.getSimpleName() + "String_Node_Str"+ vClass.getSimpleName(),0);
  this.putReturnsNull=config.putReturnsNull();
  this.removeReturnsNull=config.removeReturnsNull();
  this.kClass=kClass;
  this.vClass=vClass;
}

Fixed version (ground truth):
public ClientWiredStatelessChronicleMap(@NotNull final ClientWiredChronicleMapStatelessBuilder config,@NotNull final Class<K> kClass,@NotNull final Class<V> vClass,@NotNull final String channelName,@NotNull final ClientWiredStatelessTcpConnectionHub hub){
  super(channelName,hub,0,"String_Node_Str" + channelName + "String_Node_Str"+ "String_Node_Str"+ kClass.getSimpleName()+ "String_Node_Str"+ vClass.getSimpleName());
  this.putReturnsNull=config.putReturnsNull();
  this.removeReturnsNull=config.removeReturnsNull();
  this.kClass=kClass;
  this.vClass=vClass;
}
Program: 55442
Project: 55442
Buggy source:
@NotNull public Set<K> keySet(){
  long cid=proxyReturnWireConsumer(keySet,read -> {
    final long[] cidRef=new long[1];
    final StringBuilder type=Wires.acquireStringBuilder();
    read.type(type);
    read.marshallable(w -> {
      final String csp1=csp(w).toString();
      final long cid0=cid(w);
      cidToCsp.put(cid0,csp1);
      cidRef[0]=cid0;
    }
);
    return cidRef[0];
  }
);
  return new ClientWiredStatelessChronicleSet<>(channelName,hub,cid,valueIn -> valueIn.object(kClass),"String_Node_Str");
}

Fixed version (ground truth):
@NotNull public Set<K> keySet(){
  long cid=proxyReturnWireConsumer(keySet,read -> {
    final long[] cidRef=new long[1];
    final StringBuilder type=Wires.acquireStringBuilder();
    read.type(type);
    read.marshallable(w -> {
      final String csp1=csp(w).toString();
      final long cid0=cid(w);
      cidToCsp.put(cid0,csp1);
      cidRef[0]=cid0;
    }
);
    return cidRef[0];
  }
);
  return new ClientWiredStatelessChronicleSet<>(channelName,hub,cid,valueIn -> valueIn.object(kClass),"String_Node_Str" + channelName + "String_Node_Str");
}
Program: 55443
Project: 55443
Buggy source:
@NotNull public Set<Map.Entry<K,V>> entrySet(){
  long cid=proxyReturnWireConsumer(entrySet,read -> {
    final StringBuilder type=Wires.acquireStringBuilder();
    read.type(type);
    return read.applyToMarshallable(w -> {
      final String csp1=csp(w).toString();
      final long cid0=cid(w);
      cidToCsp.put(cid0,csp1);
      return cid0;
    }
);
  }
);
  Function<ValueIn,Map.Entry<K,V>> conumer=valueIn -> valueIn.applyToMarshallable(r -> {
    final K k=r.read(() -> "String_Node_Str").object(kClass);
    final V v=r.read(() -> "String_Node_Str").object(vClass);
    return new Map.Entry<K,V>(){
      @Override public K getKey(){
        return k;
      }
      @Override public V getValue(){
        return v;
      }
      @Override public V setValue(      Object value){
        throw new UnsupportedOperationException();
      }
    }
;
  }
);
  return new ClientWiredStatelessChronicleSet<>(channelName,hub,cid,conumer,"String_Node_Str");
}

Fixed version (ground truth):
@NotNull public Set<Map.Entry<K,V>> entrySet(){
  long cid=proxyReturnWireConsumer(entrySet,read -> {
    final StringBuilder type=Wires.acquireStringBuilder();
    read.type(type);
    return read.applyToMarshallable(w -> {
      final String csp1=csp(w).toString();
      final long cid0=cid(w);
      cidToCsp.put(cid0,csp1);
      return cid0;
    }
);
  }
);
  Function<ValueIn,Map.Entry<K,V>> conumer=valueIn -> valueIn.applyToMarshallable(r -> {
    final K k=r.read(() -> "String_Node_Str").object(kClass);
    final V v=r.read(() -> "String_Node_Str").object(vClass);
    return new Map.Entry<K,V>(){
      @Override public K getKey(){
        return k;
      }
      @Override public V getValue(){
        return v;
      }
      @Override public V setValue(      Object value){
        throw new UnsupportedOperationException();
      }
    }
;
  }
);
  return new ClientWiredStatelessChronicleSet<>(channelName,hub,cid,conumer,"String_Node_Str" + channelName + "String_Node_Str");
}
Program: 55444
Project: 55444
Buggy source:
/** 
 * @param channelName
 * @param hub
 * @param type        the type of wire handler for example "MAP" or "QUEUE"
 * @param cid         used by proxies such as the entry-set
 */
public MapStatelessClient(@NotNull String channelName,@NotNull ClientWiredStatelessTcpConnectionHub hub,@NotNull String type,long cid){
  super(channelName,hub,type,cid);
}

Fixed version (ground truth):
/** 
 * @param channelName
 * @param hub
 * @param cid         used by proxies such as the entry-set
 * @param csp
 */
public MapStatelessClient(@NotNull String channelName,@NotNull ClientWiredStatelessTcpConnectionHub hub,long cid,String csp){
  super(channelName,hub,cid,csp);
}
Program: 55445
Project: 55445
Buggy source:
@NotNull @Override public Collection<V> values(){
  final StringBuilder csp=Wires.acquireStringBuilder();
  long cid=proxyReturnWireConsumer(values,read -> {
    final StringBuilder type=Wires.acquireAnotherStringBuilder(csp);
    read.type(type);
    return read.applyToMarshallable(w -> {
      final long cid0=CoreFields.cid(w);
      cidToCsp.put(cid0,stringEvent(CoreFields.csp,csp,w).toString());
      return cid0;
    }
);
  }
);
  final Function<ValueIn,V> conumer=valueIn -> valueIn.object(vClass);
  return new ClientWiredStatelessChronicleCollection<>(channelName,hub,cid,conumer,ArrayList::new,"String_Node_Str" + channelName + "String_Node_Str"+ "String_Node_Str");
}

Fixed version (ground truth):
@NotNull @Override public Collection<V> values(){
  final StringBuilder csp=Wires.acquireStringBuilder();
  long cid=proxyReturnWireConsumer(values,read -> {
    final StringBuilder type=Wires.acquireAnotherStringBuilder(csp);
    read.type(type);
    return read.applyToMarshallable(w -> {
      stringEvent(CoreFields.csp,csp,w);
      final long cid0=CoreFields.cid(w);
      cidToCsp.put(cid0,csp.toString());
      return cid0;
    }
);
  }
);
  final Function<ValueIn,V> conumer=valueIn -> valueIn.object(vClass);
  return new ClientWiredStatelessChronicleCollection<>(channelName,hub,cid,conumer,ArrayList::new,"String_Node_Str" + channelName + "String_Node_Str"+ "String_Node_Str");
}
Program: 55446
Project: 55446
Buggy source:
@NotNull public Set<K> keySet(){
  final StringBuilder csp=Wires.acquireStringBuilder();
  long cid=proxyReturnWireConsumer(keySet,read -> {
    final StringBuilder type=Wires.acquireAnotherStringBuilder(csp);
    read.type(type);
    return read.applyToMarshallable(w -> {
      final long cid0=CoreFields.cid(w);
      cidToCsp.put(cid0,stringEvent(CoreFields.csp,csp,w).toString());
      return cid0;
    }
);
  }
);
  return new ClientWiredStatelessChronicleSet<>(channelName,hub,cid,valueIn -> valueIn.object(kClass),csp.toString());
}

Fixed version (ground truth):
@NotNull public Set<K> keySet(){
  final StringBuilder csp=Wires.acquireStringBuilder();
  long cid=proxyReturnWireConsumer(keySet,read -> {
    final StringBuilder type=Wires.acquireAnotherStringBuilder(csp);
    read.type(type);
    return read.applyToMarshallable(w -> {
      stringEvent(CoreFields.csp,csp,w);
      final long cid0=CoreFields.cid(w);
      cidToCsp.put(cid0,csp.toString());
      return cid0;
    }
);
  }
);
  return new ClientWiredStatelessChronicleSet<>(channelName,hub,cid,valueIn -> valueIn.object(kClass),csp.toString());
}
Program: 55447
Project: 55447
Buggy source:
@NotNull public Set<Map.Entry<K,V>> entrySet(){
  final StringBuilder csp=Wires.acquireStringBuilder();
  long cid=proxyReturnWireConsumer(entrySet,read -> {
    final StringBuilder type=Wires.acquireAnotherStringBuilder(csp);
    read.type(type);
    return read.applyToMarshallable(w -> {
      final long cid0=CoreFields.cid(w);
      cidToCsp.put(cid0,stringEvent(CoreFields.csp,csp,w).toString());
      return cid0;
    }
);
  }
);
  Function<ValueIn,Map.Entry<K,V>> conumer=valueIn -> valueIn.applyToMarshallable(r -> {
    final K k=r.read(() -> "String_Node_Str").object(kClass);
    final V v=r.read(() -> "String_Node_Str").object(vClass);
    return new Map.Entry<K,V>(){
      @Override public K getKey(){
        return k;
      }
      @Override public V getValue(){
        return v;
      }
      @Override public V setValue(      Object value){
        throw new UnsupportedOperationException();
      }
    }
;
  }
);
  return new ClientWiredStatelessChronicleSet<>(channelName,hub,cid,conumer,csp.toString());
}

Fixed version (ground truth):
@NotNull public Set<Map.Entry<K,V>> entrySet(){
  final StringBuilder csp=Wires.acquireStringBuilder();
  long cid=proxyReturnWireConsumer(entrySet,read -> {
    final StringBuilder type=Wires.acquireAnotherStringBuilder(csp);
    read.type(type);
    return read.applyToMarshallable(w -> {
      stringEvent(CoreFields.csp,csp,w);
      final long cid0=CoreFields.cid(w);
      cidToCsp.put(cid0,csp.toString());
      return cid0;
    }
);
  }
);
  Function<ValueIn,Map.Entry<K,V>> conumer=valueIn -> valueIn.applyToMarshallable(r -> {
    final K k=r.read(() -> "String_Node_Str").object(kClass);
    final V v=r.read(() -> "String_Node_Str").object(vClass);
    return new Map.Entry<K,V>(){
      @Override public K getKey(){
        return k;
      }
      @Override public V getValue(){
        return v;
      }
      @Override public V setValue(      Object value){
        throw new UnsupportedOperationException();
      }
    }
;
  }
);
  return new ClientWiredStatelessChronicleSet<>(channelName,hub,cid,conumer,csp.toString());
}
Program: 55448
Project: 55448
Buggy source:
@Test public void testPutAll() throws IOException, InterruptedException {
  supplyMap(Integer.class,String.class,mapProxy -> {
    final Set<Map.Entry<Integer,String>> entries=mapProxy.entrySet();
    assertEquals(0,entries.size());
    assertEquals(true,entries.isEmpty());
    Map<Integer,String> data=new HashMap<>();
    data.put(1,"String_Node_Str");
    data.put(2,"String_Node_Str");
    mapProxy.putAll(data);
    final Set<Map.Entry<Integer,String>> e=mapProxy.entrySet();
    final Iterator<Map.Entry<Integer,String>> iterator=e.iterator();
    Map.Entry<Integer,String> entry=iterator.next();
    if (entry.getKey() == 1) {
      assertEquals("String_Node_Str",entry.getValue());
      entry=iterator.next();
      assertEquals("String_Node_Str",entry.getValue());
    }
 else     if (entry.getKey() == 2) {
      assertEquals("String_Node_Str",entry.getValue());
      entry=iterator.next();
      assertEquals("String_Node_Str",entry.getValue());
    }
    assertEquals(2,mapProxy.size());
  }
);
}

Fixed version (ground truth):
@Test public void testPutAll() throws IOException, InterruptedException {
  supplyMap(Integer.class,String.class,mapProxy -> {
    yamlLoggger(() -> {
      final Set<Map.Entry<Integer,String>> entries=mapProxy.entrySet();
      assertEquals(0,entries.size());
      assertEquals(true,entries.isEmpty());
      Map<Integer,String> data=new HashMap<>();
      data.put(1,"String_Node_Str");
      data.put(2,"String_Node_Str");
      mapProxy.putAll(data);
      final Set<Map.Entry<Integer,String>> e=mapProxy.entrySet();
      final Iterator<Map.Entry<Integer,String>> iterator=e.iterator();
      Map.Entry<Integer,String> entry=iterator.next();
      if (entry.getKey() == 1) {
        assertEquals("String_Node_Str",entry.getValue());
        entry=iterator.next();
        assertEquals("String_Node_Str",entry.getValue());
      }
 else       if (entry.getKey() == 2) {
        assertEquals("String_Node_Str",entry.getValue());
        entry=iterator.next();
        assertEquals("String_Node_Str",entry.getValue());
      }
      assertEquals(2,mapProxy.size());
    }
);
  }
);
}