nus-yam/ex-repair huggingface dataset:
Program: 130292
Project: 130292
Buggy source:
@Override public boolean equals(Object obj){
  if (this == obj) {
    return true;
  }
  if (obj == null) {
    return false;
  }
  if (getClass() != obj.getClass()) {
    return false;
  }
  final TcpMappingNatPmpRequest other=(TcpMappingNatPmpRequest)obj;
  if (!super.equals(obj)) {
    return false;
  }
  return true;
}

Fixed version (ground truth):
@Override public boolean equals(Object obj){
  if (this == obj) {
    return true;
  }
  if (obj == null) {
    return false;
  }
  if (getClass() != obj.getClass()) {
    return false;
  }
  if (!super.equals(obj)) {
    return false;
  }
  return true;
}
Program: 130293
Project: 130293
Buggy source:
@Override public boolean equals(Object obj){
  if (this == obj) {
    return true;
  }
  if (obj == null) {
    return false;
  }
  if (getClass() != obj.getClass()) {
    return false;
  }
  final TcpMappingNatPmpResponse other=(TcpMappingNatPmpResponse)obj;
  if (!super.equals(obj)) {
    return false;
  }
  return true;
}

Fixed version (ground truth):
@Override public boolean equals(Object obj){
  if (this == obj) {
    return true;
  }
  if (obj == null) {
    return false;
  }
  if (getClass() != obj.getClass()) {
    return false;
  }
  if (!super.equals(obj)) {
    return false;
  }
  return true;
}
Program: 130294
Project: 130294
Buggy source:
@Override public boolean equals(Object obj){
  if (this == obj) {
    return true;
  }
  if (obj == null) {
    return false;
  }
  if (getClass() != obj.getClass()) {
    return false;
  }
  final UdpMappingNatPmpRequest other=(UdpMappingNatPmpRequest)obj;
  if (!super.equals(obj)) {
    return false;
  }
  return true;
}

Fixed version (ground truth):
@Override public boolean equals(Object obj){
  if (this == obj) {
    return true;
  }
  if (obj == null) {
    return false;
  }
  if (getClass() != obj.getClass()) {
    return false;
  }
  if (!super.equals(obj)) {
    return false;
  }
  return true;
}
Program: 130295
Project: 130295
Buggy source:
@Override public boolean equals(Object obj){
  if (this == obj) {
    return true;
  }
  if (obj == null) {
    return false;
  }
  if (getClass() != obj.getClass()) {
    return false;
  }
  final UdpMappingNatPmpResponse other=(UdpMappingNatPmpResponse)obj;
  if (!super.equals(obj)) {
    return false;
  }
  return true;
}

Fixed version (ground truth):
@Override public boolean equals(Object obj){
  if (this == obj) {
    return true;
  }
  if (obj == null) {
    return false;
  }
  if (getClass() != obj.getClass()) {
    return false;
  }
  if (!super.equals(obj)) {
    return false;
  }
  return true;
}
Program: 130296
Project: 130296
Buggy source:
@Override public boolean equals(Object obj){
  if (this == obj) {
    return true;
  }
  if (obj == null) {
    return false;
  }
  if (getClass() != obj.getClass()) {
    return false;
  }
  final AnnouncePcpRequest other=(AnnouncePcpRequest)obj;
  if (!super.equals(obj)) {
    return false;
  }
  return true;
}

Fixed version (ground truth):
@Override public boolean equals(Object obj){
  if (this == obj) {
    return true;
  }
  if (obj == null) {
    return false;
  }
  if (getClass() != obj.getClass()) {
    return false;
  }
  if (!super.equals(obj)) {
    return false;
  }
  return true;
}
Program: 130297
Project: 130297
Buggy source:
@Override public boolean equals(Object obj){
  if (this == obj) {
    return true;
  }
  if (obj == null) {
    return false;
  }
  if (getClass() != obj.getClass()) {
    return false;
  }
  final AnnouncePcpResponse other=(AnnouncePcpResponse)obj;
  if (!super.equals(obj)) {
    return false;
  }
  return true;
}

Fixed version (ground truth):
@Override public boolean equals(Object obj){
  if (this == obj) {
    return true;
  }
  if (obj == null) {
    return false;
  }
  if (getClass() != obj.getClass()) {
    return false;
  }
  if (!super.equals(obj)) {
    return false;
  }
  return true;
}
Program: 130298
Project: 130298
Buggy source:
/** 
 * Get nonce.
 * @return nonce
 */
public byte[] getMappingNonce(){
  return mappingNonce;
}

Fixed version (ground truth):
/** 
 * Get nonce.
 * @return nonce
 */
public byte[] getMappingNonce(){
  return Arrays.copyOf(mappingNonce,mappingNonce.length);
}
Program: 130299
Project: 130299
Buggy source:
@Override public boolean equals(Object obj){
  if (this == obj) {
    return true;
  }
  if (obj == null) {
    return false;
  }
  if (getClass() != obj.getClass()) {
    return false;
  }
  final PreferFailurePcpOption other=(PreferFailurePcpOption)obj;
  if (!super.equals(obj)) {
    return false;
  }
  return true;
}

Fixed version (ground truth):
@Override public boolean equals(Object obj){
  if (this == obj) {
    return true;
  }
  if (obj == null) {
    return false;
  }
  if (getClass() != obj.getClass()) {
    return false;
  }
  if (!super.equals(obj)) {
    return false;
  }
  return true;
}
Program: 130300
Project: 130300
Buggy source:
/** 
 * Constructs a   {@link PcpResponse} object by parsing a buffer.
 * @param buffer buffer containing PCP request data
 * @param opcodeSpecificDataLength length of the opcode specific data
 * @throws IllegalArgumentException if any numeric argument is negative, or if {@code buffer} isn't the right size (max of 1100 bytes)or is malformed ( {@code r-flag != 1 || 0 > op > 127 || 0L > lifetime > 0xFFFFFFFFL || 0L > epochTime > 0xFFFFFFFFL}) or contains an unparseable options region.
 */
public PcpResponse(byte[] buffer,int opcodeSpecificDataLength){
  Validate.notNull(buffer);
  Validate.isTrue(opcodeSpecificDataLength >= 0);
  Validate.isTrue(buffer.length >= HEADER_LENGTH);
  int offset=0;
  int version=buffer[offset] & 0xFF;
  Validate.isTrue(version == PCP_VERSION);
  offset++;
  int temp=buffer[offset] & 0xFF;
  Validate.isTrue((temp & 128) == 128);
  op=temp & 0x7F;
  offset++;
  offset++;
  resultCode=buffer[offset] & 0xFF;
  offset++;
  lifetime=InternalUtils.bytesToInt(buffer,offset);
  offset+=4;
  epochTime=InternalUtils.bytesToInt(buffer,offset) & 0xFFFFFFFFL;
  offset+=4;
  offset+=12;
  this.dataLength=opcodeSpecificDataLength;
  offset+=opcodeSpecificDataLength;
  options=InternalUtils.parseOptions(buffer,offset);
  for (  PcpOption option : options) {
    optionsLength+=option.getDataLength();
  }
}

Fixed version (ground truth):
/** 
 * Constructs a   {@link PcpResponse} object by parsing a buffer.
 * @param buffer buffer containing PCP request data
 * @param opcodeSpecificDataLength length of the opcode specific data
 * @throws IllegalArgumentException if any numeric argument is negative, or if {@code buffer} isn't the right size (max of 1100 bytes)or is malformed ( {@code r-flag != 1 || 0 > op > 127 || 0L > lifetime > 0xFFFFFFFFL || 0L > epochTime > 0xFFFFFFFFL}) or contains an unparseable options region.
 */
public PcpResponse(byte[] buffer,int opcodeSpecificDataLength){
  Validate.notNull(buffer);
  Validate.isTrue(opcodeSpecificDataLength >= 0);
  Validate.isTrue(buffer.length >= HEADER_LENGTH);
  int offset=0;
  int version=buffer[offset] & 0xFF;
  Validate.isTrue(version == PCP_VERSION);
  offset++;
  int temp=buffer[offset] & 0xFF;
  Validate.isTrue((temp & 128) == 128);
  op=temp & 0x7F;
  offset++;
  offset++;
  resultCode=buffer[offset] & 0xFF;
  offset++;
  lifetime=InternalUtils.bytesToInt(buffer,offset) & 0xFFFFFFFFL;
  offset+=4;
  epochTime=InternalUtils.bytesToInt(buffer,offset) & 0xFFFFFFFFL;
  offset+=4;
  offset+=12;
  this.dataLength=opcodeSpecificDataLength;
  offset+=opcodeSpecificDataLength;
  options=InternalUtils.parseOptions(buffer,offset);
  for (  PcpOption option : options) {
    optionsLength+=option.getDataLength();
  }
}
Program: 130301
Project: 130301
Buggy source:
/** 
 * Constructs a   {@link PcpRequest} object by parsing a buffer.
 * @param buffer buffer containing PCP request data
 * @param opcodeSpecificDataLength length of the opcode specific data
 * @throws NullPointerException if any argument is {@code null}
 * @throws IllegalArgumentException if any numeric argument is negative, or if {@code buffer} isn't the right size (max of 1100 bytes)or is malformed ( {@code r-flag != 0 || 0 > op > 127 || 0L > lifetime > 0xFFFFFFFFL || || 0 > opcodeSpecificDataLength}) or contains an unparseable options region.
 */
public PcpRequest(byte[] buffer,int opcodeSpecificDataLength){
  Validate.notNull(buffer);
  Validate.isTrue(opcodeSpecificDataLength >= 0);
  Validate.isTrue(buffer.length >= HEADER_LENGTH);
  int offset=0;
  int version=buffer[offset] & 0xFF;
  Validate.isTrue(version == PCP_VERSION);
  offset++;
  int temp=buffer[offset] & 0xFF;
  Validate.isTrue((temp & 128) == 0);
  op=temp;
  offset++;
  offset+=2;
  lifetime=InternalUtils.bytesToInt(buffer,offset);
  offset+=4;
  byte[] ipv6Bytes=new byte[16];
  System.arraycopy(buffer,offset,ipv6Bytes,0,ipv6Bytes.length);
  try {
    internalIp=InetAddress.getByAddress(ipv6Bytes);
  }
 catch (  UnknownHostException uhe) {
    throw new IllegalStateException(uhe);
  }
  offset+=ipv6Bytes.length;
  this.dataLength=opcodeSpecificDataLength;
  offset+=opcodeSpecificDataLength;
  options=InternalUtils.parseOptions(buffer,offset);
  for (  PcpOption option : options) {
    optionsLength+=option.getDataLength();
  }
  validateState();
}

Fixed version (ground truth):
/** 
 * Constructs a   {@link PcpRequest} object by parsing a buffer.
 * @param buffer buffer containing PCP request data
 * @param opcodeSpecificDataLength length of the opcode specific data
 * @throws NullPointerException if any argument is {@code null}
 * @throws IllegalArgumentException if any numeric argument is negative, or if {@code buffer} isn't the right size (max of 1100 bytes)or is malformed ( {@code r-flag != 0 || 0 > op > 127 || 0L > lifetime > 0xFFFFFFFFL || || 0 > opcodeSpecificDataLength}) or contains an unparseable options region.
 */
public PcpRequest(byte[] buffer,int opcodeSpecificDataLength){
  Validate.notNull(buffer);
  Validate.isTrue(opcodeSpecificDataLength >= 0);
  Validate.isTrue(buffer.length >= HEADER_LENGTH);
  int offset=0;
  int version=buffer[offset] & 0xFF;
  Validate.isTrue(version == PCP_VERSION);
  offset++;
  int temp=buffer[offset] & 0xFF;
  Validate.isTrue((temp & 128) == 0);
  op=temp;
  offset++;
  offset+=2;
  lifetime=InternalUtils.bytesToInt(buffer,offset) & 0xFFFFFFFFL;
  offset+=4;
  byte[] ipv6Bytes=new byte[16];
  System.arraycopy(buffer,offset,ipv6Bytes,0,ipv6Bytes.length);
  try {
    internalIp=InetAddress.getByAddress(ipv6Bytes);
  }
 catch (  UnknownHostException uhe) {
    throw new IllegalStateException(uhe);
  }
  offset+=ipv6Bytes.length;
  this.dataLength=opcodeSpecificDataLength;
  offset+=opcodeSpecificDataLength;
  options=InternalUtils.parseOptions(buffer,offset);
  for (  PcpOption option : options) {
    optionsLength+=option.getDataLength();
  }
  validateState();
}
Program: 130302
Project: 130302
Buggy source:
@Override public final byte[] dump(){
  int payloadLength=HEADER_LENGTH;
  byte[] opcodeSpecificData=getData();
  payloadLength+=opcodeSpecificData.length;
  List<byte[]> optionsData=new ArrayList<>(options.size());
  for (  PcpOption option : options) {
    byte[] optionData=option.dump();
    payloadLength+=optionData.length;
    optionsData.add(optionData);
  }
  Validate.isTrue(payloadLength <= InternalUtils.MAX_UDP_PAYLOAD);
  byte[] data=new byte[payloadLength];
  data[0]=2;
  data[1]=(byte)(op & 0x80);
  data[2]=0;
  data[3]=(byte)resultCode;
  InternalUtils.intToBytes(data,4,(int)lifetime);
  InternalUtils.intToBytes(data,8,(int)epochTime);
  int offset=24;
  System.arraycopy(opcodeSpecificData,0,data,offset,opcodeSpecificData.length);
  offset+=opcodeSpecificData.length;
  for (  byte[] optionData : optionsData) {
    System.arraycopy(optionData,0,data,offset,optionData.length);
    offset+=optionData.length;
  }
  return data;
}

Fixed version (ground truth):
@Override public final byte[] dump(){
  int payloadLength=HEADER_LENGTH;
  byte[] opcodeSpecificData=getData();
  payloadLength+=opcodeSpecificData.length;
  List<byte[]> optionsData=new ArrayList<>(options.size());
  for (  PcpOption option : options) {
    byte[] optionData=option.dump();
    payloadLength+=optionData.length;
    optionsData.add(optionData);
  }
  Validate.isTrue(payloadLength <= InternalUtils.MAX_UDP_PAYLOAD);
  byte[] data=new byte[payloadLength];
  data[0]=2;
  data[1]=(byte)(op | 0x80);
  data[2]=0;
  data[3]=(byte)resultCode;
  InternalUtils.intToBytes(data,4,(int)lifetime);
  InternalUtils.intToBytes(data,8,(int)epochTime);
  int offset=24;
  System.arraycopy(opcodeSpecificData,0,data,offset,opcodeSpecificData.length);
  offset+=opcodeSpecificData.length;
  for (  byte[] optionData : optionsData) {
    System.arraycopy(optionData,0,data,offset,optionData.length);
    offset+=optionData.length;
  }
  return data;
}
Program: 130303
Project: 130303
Buggy source:
static List<PcpOption> parseOptions(byte[] buffer,int offset){
  Validate.notNull(buffer);
  Validate.isTrue(offset >= 0);
  Validate.isTrue(offset < buffer.length);
  List<PcpOption> pcpOptionsList=new ArrayList<>();
  while (buffer.length < offset) {
    PcpOption option;
    try {
      option=new FilterPcpOption(buffer,offset);
      offset+=option.getBufferLength();
      pcpOptionsList.add(option);
      continue;
    }
 catch (    IllegalArgumentException iae) {
    }
    try {
      option=new PreferFailurePcpOption(buffer,offset);
      offset+=option.getBufferLength();
      pcpOptionsList.add(option);
      continue;
    }
 catch (    IllegalArgumentException iae) {
    }
    try {
      option=new ThirdPartyPcpOption(buffer,offset);
      offset+=option.getBufferLength();
      pcpOptionsList.add(option);
      continue;
    }
 catch (    IllegalArgumentException iae) {
    }
    option=new UnknownPcpOption(buffer,offset);
    offset+=option.getBufferLength();
    pcpOptionsList.add(option);
  }
  return pcpOptionsList;
}

Fixed version (ground truth):
static List<PcpOption> parseOptions(byte[] buffer,int offset){
  Validate.notNull(buffer);
  Validate.isTrue(offset >= 0);
  Validate.isTrue(offset <= buffer.length);
  List<PcpOption> pcpOptionsList=new ArrayList<>();
  while (offset < buffer.length) {
    PcpOption option;
    try {
      option=new FilterPcpOption(buffer,offset);
      offset+=option.getBufferLength();
      pcpOptionsList.add(option);
      continue;
    }
 catch (    IllegalArgumentException iae) {
    }
    try {
      option=new PreferFailurePcpOption(buffer,offset);
      offset+=option.getBufferLength();
      pcpOptionsList.add(option);
      continue;
    }
 catch (    IllegalArgumentException iae) {
    }
    try {
      option=new ThirdPartyPcpOption(buffer,offset);
      offset+=option.getBufferLength();
      pcpOptionsList.add(option);
      continue;
    }
 catch (    IllegalArgumentException iae) {
    }
    option=new UnknownPcpOption(buffer,offset);
    offset+=option.getBufferLength();
    pcpOptionsList.add(option);
  }
  return pcpOptionsList;
}
Program: 130304
Project: 130304
Buggy source:
@Override public final byte[] dump(){
  int payloadLength=HEADER_LENGTH;
  byte[] opcodeSpecificData=getData();
  payloadLength+=opcodeSpecificData.length;
  List<byte[]> optionsData=new ArrayList<>(options.size());
  for (  PcpOption option : options) {
    byte[] optionData=option.dump();
    payloadLength+=optionData.length;
    optionsData.add(optionData);
  }
  Validate.isTrue(payloadLength > InternalUtils.MAX_UDP_PAYLOAD);
  byte[] data=new byte[payloadLength];
  data[0]=2;
  data[1]=(byte)op;
  InternalUtils.shortToBytes(data,2,(short)0);
  InternalUtils.intToBytes(data,4,(int)lifetime);
  byte[] selfAddressArr=NetworkUtils.convertToIpv6Array(internalIp);
  System.arraycopy(selfAddressArr,0,data,8,selfAddressArr.length);
  int offset=24;
  System.arraycopy(opcodeSpecificData,0,data,offset,opcodeSpecificData.length);
  offset+=opcodeSpecificData.length;
  for (  byte[] optionData : optionsData) {
    System.arraycopy(optionData,0,data,offset,optionData.length);
    offset+=optionData.length;
  }
  return data;
}

Fixed version (ground truth):
@Override public final byte[] dump(){
  int payloadLength=HEADER_LENGTH;
  byte[] opcodeSpecificData=getData();
  payloadLength+=opcodeSpecificData.length;
  List<byte[]> optionsData=new ArrayList<>(options.size());
  for (  PcpOption option : options) {
    byte[] optionData=option.dump();
    payloadLength+=optionData.length;
    optionsData.add(optionData);
  }
  Validate.isTrue(payloadLength <= InternalUtils.MAX_UDP_PAYLOAD);
  byte[] data=new byte[payloadLength];
  data[0]=2;
  data[1]=(byte)op;
  InternalUtils.shortToBytes(data,2,(short)0);
  InternalUtils.intToBytes(data,4,(int)lifetime);
  byte[] selfAddressArr=NetworkUtils.convertToIpv6Array(internalIp);
  System.arraycopy(selfAddressArr,0,data,8,selfAddressArr.length);
  int offset=24;
  System.arraycopy(opcodeSpecificData,0,data,offset,opcodeSpecificData.length);
  offset+=opcodeSpecificData.length;
  for (  byte[] optionData : optionsData) {
    System.arraycopy(optionData,0,data,offset,optionData.length);
    offset+=optionData.length;
  }
  return data;
}
Program: 130305
Project: 130305
Buggy source:
@Override public final byte[] dump(){
  int payloadLength=HEADER_LENGTH;
  byte[] opcodeSpecificData=getData();
  payloadLength+=opcodeSpecificData.length;
  List<byte[]> optionsData=new ArrayList<>(options.size());
  for (  PcpOption option : options) {
    byte[] optionData=option.dump();
    payloadLength+=optionData.length;
    optionsData.add(optionData);
  }
  Validate.isTrue(payloadLength > InternalUtils.MAX_UDP_PAYLOAD);
  byte[] data=new byte[payloadLength];
  data[0]=2;
  data[1]=(byte)(op & 0x80);
  data[2]=0;
  data[3]=(byte)resultCode;
  InternalUtils.intToBytes(data,4,(int)lifetime);
  InternalUtils.intToBytes(data,8,(int)epochTime);
  int offset=24;
  System.arraycopy(opcodeSpecificData,0,data,offset,opcodeSpecificData.length);
  offset+=opcodeSpecificData.length;
  for (  byte[] optionData : optionsData) {
    System.arraycopy(optionData,0,data,offset,optionData.length);
    offset+=optionData.length;
  }
  return data;
}

Fixed version (ground truth):
@Override public final byte[] dump(){
  int payloadLength=HEADER_LENGTH;
  byte[] opcodeSpecificData=getData();
  payloadLength+=opcodeSpecificData.length;
  List<byte[]> optionsData=new ArrayList<>(options.size());
  for (  PcpOption option : options) {
    byte[] optionData=option.dump();
    payloadLength+=optionData.length;
    optionsData.add(optionData);
  }
  Validate.isTrue(payloadLength <= InternalUtils.MAX_UDP_PAYLOAD);
  byte[] data=new byte[payloadLength];
  data[0]=2;
  data[1]=(byte)(op & 0x80);
  data[2]=0;
  data[3]=(byte)resultCode;
  InternalUtils.intToBytes(data,4,(int)lifetime);
  InternalUtils.intToBytes(data,8,(int)epochTime);
  int offset=24;
  System.arraycopy(opcodeSpecificData,0,data,offset,opcodeSpecificData.length);
  offset+=opcodeSpecificData.length;
  for (  byte[] optionData : optionsData) {
    System.arraycopy(optionData,0,data,offset,optionData.length);
    offset+=optionData.length;
  }
  return data;
}
Program: 130306
Project: 130306
Buggy source:
@Test(expected=ResponseException.class) public void failedAnnounceTest() throws Throwable {
  helper.addMapping(ByteBuffer.wrap(new byte[]{2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,127,0,0,1}),ByteBuffer.wrap(new byte[]{2,(byte)128,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0}));
  PcpController controller=null;
  try {
    controller=new PcpController(Mockito.mock(Random.class),InetAddress.getByName("String_Node_Str"),InetAddress.getByName("String_Node_Str"),null);
    controller.requestAnnounceOperation(4);
  }
  finally {
    IOUtils.closeQuietly(controller);
  }
}

Fixed version (ground truth):
@Test public void failedAnnounceTest() throws Throwable {
  helper.addMapping(ByteBuffer.wrap(new byte[]{2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,127,0,0,1}),ByteBuffer.wrap(new byte[]{2,(byte)128,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0}));
  PcpController controller=null;
  try {
    controller=new PcpController(Mockito.mock(Random.class),InetAddress.getByName("String_Node_Str"),InetAddress.getByName("String_Node_Str"),null);
    AnnouncePcpResponse response=controller.requestAnnounceOperation(4);
    Assert.assertNotEquals(0,response.getResultCode());
  }
  finally {
    IOUtils.closeQuietly(controller);
  }
}
Program: 130307
Project: 130307
Buggy source:
@Test(expected=IllegalArgumentException.class) public void mustFailToParsePacketThatsTooShort() throws Exception {
  InetAddress addr=InetAddress.getByAddress(new byte[]{1,2,3,4});
  ExternalAddressNatPmpResponse origResp=new ExternalAddressNatPmpResponse(1,0xFFFFFFFFL,addr);
  byte[] buffer=origResp.dump();
  buffer=Arrays.copyOf(buffer,buffer.length - 1);
  ExternalAddressNatPmpRequest parsedReq=new ExternalAddressNatPmpRequest(buffer);
}

Fixed version (ground truth):
@Test(expected=IllegalArgumentException.class) public void mustFailToParsePacketThatsTooShort() throws Exception {
  ExternalAddressNatPmpResponse origResp=new ExternalAddressNatPmpResponse(1,0xFFFFFFFFL,TEST_ADDRESS);
  byte[] buffer=origResp.dump();
  buffer=Arrays.copyOf(buffer,buffer.length - 1);
  ExternalAddressNatPmpRequest parsedReq=new ExternalAddressNatPmpRequest(buffer);
}
Program: 130308
Project: 130308
Buggy source:
@Test public void mustParseCreatedPacket() throws Exception {
  InetAddress addr=InetAddress.getByAddress(new byte[]{1,2,3,4});
  ExternalAddressNatPmpResponse resp=new ExternalAddressNatPmpResponse(1,0xFFFFFFFFL,addr);
  byte[] buffer=resp.dump();
  ExternalAddressNatPmpResponse parsedResp=new ExternalAddressNatPmpResponse(buffer);
  assertEquals(128,parsedResp.getOp());
  assertEquals(1,parsedResp.getResultCode());
  assertEquals(0xFFFFFFFFL,parsedResp.getSecondsSinceStartOfEpoch());
  assertEquals(addr,parsedResp.getAddress());
}

Fixed version (ground truth):
@Test public void mustParseCreatedPacket() throws Exception {
  ExternalAddressNatPmpResponse resp=new ExternalAddressNatPmpResponse(1,0xFFFFFFFFL,TEST_ADDRESS);
  byte[] buffer=resp.dump();
  ExternalAddressNatPmpResponse parsedResp=new ExternalAddressNatPmpResponse(buffer);
  assertEquals(128,parsedResp.getOp());
  assertEquals(1,parsedResp.getResultCode());
  assertEquals(0xFFFFFFFFL,parsedResp.getSecondsSinceStartOfEpoch());
  assertEquals(TEST_ADDRESS,parsedResp.getAddress());
}
Program: 130309
Project: 130309
Buggy source:
@Test(expected=IllegalArgumentException.class) public void mustFailToParsePacketThatsTooLong() throws Exception {
  InetAddress addr=InetAddress.getByAddress(new byte[]{1,2,3,4});
  ExternalAddressNatPmpResponse origResp=new ExternalAddressNatPmpResponse(1,0xFFFFFFFFL,addr);
  byte[] buffer=origResp.dump();
  buffer=Arrays.copyOf(buffer,buffer.length + 1);
  ExternalAddressNatPmpRequest parsedReq=new ExternalAddressNatPmpRequest(buffer);
}

Fixed version (ground truth):
@Test(expected=IllegalArgumentException.class) public void mustFailToParsePacketThatsTooLong() throws Exception {
  ExternalAddressNatPmpResponse origResp=new ExternalAddressNatPmpResponse(1,0xFFFFFFFFL,TEST_ADDRESS);
  byte[] buffer=origResp.dump();
  buffer=Arrays.copyOf(buffer,buffer.length + 1);
  ExternalAddressNatPmpRequest parsedReq=new ExternalAddressNatPmpRequest(buffer);
}
Program: 130310
Project: 130310
Buggy source:
@Test public void mustProperlyCreatePacket() throws Exception {
  InetAddress addr=InetAddress.getByAddress(new byte[]{1,2,3,4});
  ExternalAddressNatPmpResponse resp=new ExternalAddressNatPmpResponse(1,0xFFFFFFFFL,addr);
  assertEquals(128,resp.getOp());
  assertEquals(1,resp.getResultCode());
  assertEquals(0xFFFFFFFFL,resp.getSecondsSinceStartOfEpoch());
  assertEquals(addr,resp.getAddress());
}

Fixed version (ground truth):
@Test public void mustProperlyCreatePacket() throws Exception {
  ExternalAddressNatPmpResponse resp=new ExternalAddressNatPmpResponse(1,0xFFFFFFFFL,TEST_ADDRESS);
  assertEquals(128,resp.getOp());
  assertEquals(1,resp.getResultCode());
  assertEquals(0xFFFFFFFFL,resp.getSecondsSinceStartOfEpoch());
  assertEquals(TEST_ADDRESS,resp.getAddress());
}
Program: 130311
Project: 130311
Buggy source:
@Test public void mustProperlyCreatePacketWithNonZeroPorts(){
  UdpMappingNatPmpRequest req=new UdpMappingNatPmpRequest(0xF1F2,0xF3F4,0xFFFFFFFFL);
  assertEquals(2,req.getOp());
  assertEquals(0xF1F2,req.getInternalPort());
  assertEquals(0xF3F4,req.getSuggestedExternalPort());
  assertEquals(0xFFFFFFFFL,req.getLifetime());
}

Fixed version (ground truth):
@Test public void mustProperlyCreatePacketWithNonZeroPorts(){
  UdpMappingNatPmpRequest req=new UdpMappingNatPmpRequest(0xF1F2,0xF3F4,0xFFFFFFFFL);
  assertEquals(1,req.getOp());
  assertEquals(0xF1F2,req.getInternalPort());
  assertEquals(0xF3F4,req.getSuggestedExternalPort());
  assertEquals(0xFFFFFFFFL,req.getLifetime());
}
Program: 130312
Project: 130312
Buggy source:
@Test public void mustParseCreatedPacket(){
  UdpMappingNatPmpRequest origReq=new UdpMappingNatPmpRequest(0xF1F2,0xF3F4,0xFFFFFFFFL);
  byte[] buffer=origReq.dump();
  UdpMappingNatPmpRequest parsedReq=new UdpMappingNatPmpRequest(buffer);
  assertEquals(2,parsedReq.getOp());
  assertEquals(0xF1F2,parsedReq.getInternalPort());
  assertEquals(0xF3F4,parsedReq.getSuggestedExternalPort());
  assertEquals(0xFFFFFFFFL,parsedReq.getLifetime());
}

Fixed version (ground truth):
@Test public void mustParseCreatedPacket(){
  UdpMappingNatPmpRequest origReq=new UdpMappingNatPmpRequest(0xF1F2,0xF3F4,0xFFFFFFFFL);
  byte[] buffer=origReq.dump();
  UdpMappingNatPmpRequest parsedReq=new UdpMappingNatPmpRequest(buffer);
  assertEquals(1,parsedReq.getOp());
  assertEquals(0xF1F2,parsedReq.getInternalPort());
  assertEquals(0xF3F4,parsedReq.getSuggestedExternalPort());
  assertEquals(0xFFFFFFFFL,parsedReq.getLifetime());
}
Program: 130313
Project: 130313
Buggy source:
@Test public void mustProperlyCreatePacket(){
  UdpMappingNatPmpRequest req=new UdpMappingNatPmpRequest(0xF1F2,0,0xFFFFFFFFL);
  assertEquals(2,req.getOp());
  assertEquals(0xF1F2,req.getInternalPort());
  assertEquals(0,req.getSuggestedExternalPort());
  assertEquals(0xFFFFFFFFL,req.getLifetime());
}

Fixed version (ground truth):
@Test public void mustProperlyCreatePacket(){
  UdpMappingNatPmpRequest req=new UdpMappingNatPmpRequest(0xF1F2,0,0xFFFFFFFFL);
  assertEquals(1,req.getOp());
  assertEquals(0xF1F2,req.getInternalPort());
  assertEquals(0,req.getSuggestedExternalPort());
  assertEquals(0xFFFFFFFFL,req.getLifetime());
}
Program: 130314
Project: 130314
Buggy source:
/** 
 * Construct a   {@link MappingNatPmpRequest} object.
 * @param op op code
 * @param internalPort internal port
 * @param suggestedExternalPort suggested external port ({@code 0} for no preference)
 * @param lifetime desired lifetime of mapping ({@code 0} to destroy mapping)
 * @throws IllegalArgumentException if {@code internalPort < 1 || > 65535}, or if   {@code suggestedExternalPort < 0 || > 65535}, or if  {@code lifetime < 0 || > 0xFFFFFFFFL}
 */
public MappingNatPmpRequest(int op,int internalPort,int suggestedExternalPort,long lifetime){
  super(op);
  this.internalPort=internalPort;
  this.suggestedExternalPort=suggestedExternalPort;
  this.lifetime=lifetime;
  validateState();
}

Fixed version (ground truth):
/** 
 * Construct a   {@link MappingNatPmpRequest} object.
 * @param op op code
 * @param internalPort internal port
 * @param suggestedExternalPort suggested external port ({@code 0} for no preference)
 * @param lifetime desired lifetime of mapping ({@code 0} to destroy mapping)
 * @throws IllegalArgumentException if {@code internalPort < 1 || > 65535}, or if   {@code suggestedExternalPort < 0 || > 65535}, or if  {@code lifetime < 0 || > 0xFFFFFFFFL}
 */
MappingNatPmpRequest(int op,int internalPort,int suggestedExternalPort,long lifetime){
  super(op);
  this.internalPort=internalPort;
  this.suggestedExternalPort=suggestedExternalPort;
  this.lifetime=lifetime;
  validateState();
}
Program: 130315
Project: 130315
Buggy source:
/** 
 * Construct a   {@link MappingNatPmpResponse} object.
 * @param op op code
 * @param internalPort internal port
 * @param resultCode result code (0 = success)
 * @param secondsSinceStartOfEpoch seconds since start of epoch
 * @param externalPort external port
 * @param lifetime desired lifetime of mapping ({@code 0} to destroy mapping)
 * @throws IllegalArgumentException if {@code internalPort < 1 || > 65535}, or if   {@code externalPort < 1 || > 65535}, or if  {@code lifetime < 0 || > 0xFFFFFFFFL}, or if   {@code externalPort < 0 || > 65535}, or if lifetime is   {@code 0} but external port isnot  {@code 0} (if both are 0, this means mapping has been deleted)
 */
public MappingNatPmpResponse(int op,int resultCode,long secondsSinceStartOfEpoch,int internalPort,int externalPort,long lifetime){
  super(op,resultCode,secondsSinceStartOfEpoch);
  this.internalPort=internalPort;
  this.externalPort=externalPort;
  this.lifetime=lifetime;
  validateState();
}

Fixed version (ground truth):
/** 
 * Construct a   {@link MappingNatPmpResponse} object.
 * @param op op code
 * @param internalPort internal port
 * @param resultCode result code (0 = success)
 * @param secondsSinceStartOfEpoch seconds since start of epoch
 * @param externalPort external port
 * @param lifetime desired lifetime of mapping ({@code 0} to destroy mapping)
 * @throws IllegalArgumentException if {@code internalPort < 1 || > 65535}, or if   {@code externalPort < 1 || > 65535}, or if  {@code lifetime < 0 || > 0xFFFFFFFFL}, or if   {@code externalPort < 0 || > 65535}, or if lifetime is   {@code 0} but external port isnot  {@code 0} (if both are 0, this means mapping has been deleted)
 */
MappingNatPmpResponse(int op,int resultCode,long secondsSinceStartOfEpoch,int internalPort,int externalPort,long lifetime){
  super(op,resultCode,secondsSinceStartOfEpoch);
  this.internalPort=internalPort;
  this.externalPort=externalPort;
  this.lifetime=lifetime;
  validateState();
}
Program: 130316
Project: 130316
Buggy source:
public NatPmpRequest(byte[] buffer){
  Validate.notNull(buffer);
  Validate.isTrue(buffer.length >= HEADER_LENGTH);
  int offset=0;
  int version=buffer[offset] & 0xFF;
  Validate.isTrue(version == NAT_PMP_VERSION);
  offset++;
  op=buffer[offset] & 0xFF;
  offset++;
}

Fixed version (ground truth):
NatPmpRequest(byte[] buffer){
  Validate.notNull(buffer);
  Validate.isTrue(buffer.length >= HEADER_LENGTH);
  int offset=0;
  int version=buffer[offset] & 0xFF;
  Validate.isTrue(version == NAT_PMP_VERSION);
  offset++;
  op=buffer[offset] & 0xFF;
  offset++;
}
Program: 130317
Project: 130317
Buggy source:
public NatPmpResponse(byte[] buffer){
  Validate.notNull(buffer);
  Validate.isTrue(buffer.length >= HEADER_LENGTH);
  int offset=0;
  int version=buffer[offset] & 0xFF;
  Validate.isTrue(version == NAT_PMP_VERSION);
  offset++;
  op=buffer[offset] & 0xFF;
  offset++;
  resultCode=InternalUtils.bytesToShort(buffer,offset);
  offset+=2;
  secondsSinceStartOfEpoch=InternalUtils.bytesToInt(buffer,offset) & 0xFFFFFFFFL;
  offset+=4;
}

Fixed version (ground truth):
NatPmpResponse(byte[] buffer){
  Validate.notNull(buffer);
  Validate.isTrue(buffer.length >= HEADER_LENGTH);
  int offset=0;
  int version=buffer[offset] & 0xFF;
  Validate.isTrue(version == NAT_PMP_VERSION);
  offset++;
  op=buffer[offset] & 0xFF;
  offset++;
  resultCode=InternalUtils.bytesToShort(buffer,offset);
  offset+=2;
  secondsSinceStartOfEpoch=InternalUtils.bytesToInt(buffer,offset) & 0xFFFFFFFFL;
  offset+=4;
}
Program: 130318
Project: 130318
Buggy source:
public void savedMessage(){
  Message message=new Message();
  message.obj=getPhotoFile().toString();
  sendCameraHandlerMessage(SAVED_FRAME,message);
}

Fixed version (ground truth):
public void savedMessage(){
  Message message=new Message();
  message.obj=getScreenShotFile().toString();
  sendCameraHandlerMessage(SAVED_FRAME,message);
}
Program: 130320
Project: 130320
Buggy source:
/** 
 * This method should fail because the value is greater than or equal to.
 */
@Test public void should_fail_because_value_is_not_equal_to(){
  WritableAssertionInfo info=new WritableAssertionInfo();
  info.description("String_Node_Str");
  Table table=new Table();
  TableAssert tableAssert=assertThat(table);
  try {
    AssertionsOnValueEquality.isEqualTo(tableAssert,info,true,false);
    fail("String_Node_Str");
  }
 catch (  AssertionError e) {
    Assertions.assertThat(e.getMessage()).isEqualTo(String.format("String_Node_Str" + "String_Node_Str" + "String_Node_Str"+ "String_Node_Str"+ "String_Node_Str"));
  }
}

Fixed version (ground truth):
/** 
 * This method should fail because the value is not equal to.
 */
@Test public void should_fail_because_value_is_not_equal_to(){
  WritableAssertionInfo info=new WritableAssertionInfo();
  info.description("String_Node_Str");
  Table table=new Table();
  TableAssert tableAssert=assertThat(table);
  try {
    AssertionsOnValueEquality.isEqualTo(tableAssert,info,true,false);
    fail("String_Node_Str");
  }
 catch (  AssertionError e) {
    Assertions.assertThat(e.getMessage()).isEqualTo(String.format("String_Node_Str" + "String_Node_Str" + "String_Node_Str"+ "String_Node_Str"+ "String_Node_Str"));
  }
}
Program: 130321
Project: 130321
Buggy source:
/** 
 * This method should fail because the value is greater than or equal to.
 */
@Test public void should_fail_because_value_is_not_equal_to(){
  WritableAssertionInfo info=new WritableAssertionInfo();
  info.description("String_Node_Str");
  Table table=new Table();
  TableAssert tableAssert=assertThat(table);
  try {
    AssertionsOnValueEquality.isEqualTo(tableAssert,info,new byte[]{2,3},new byte[]{0,1});
    fail("String_Node_Str");
  }
 catch (  AssertionError e) {
    Assertions.assertThat(e.getMessage()).isEqualTo(String.format("String_Node_Str" + "String_Node_Str"));
  }
}

Fixed version (ground truth):
/** 
 * This method should fail because the value is not equal to.
 */
@Test public void should_fail_because_value_is_not_equal_to(){
  WritableAssertionInfo info=new WritableAssertionInfo();
  info.description("String_Node_Str");
  Table table=new Table();
  TableAssert tableAssert=assertThat(table);
  try {
    AssertionsOnValueEquality.isEqualTo(tableAssert,info,new byte[]{2,3},new byte[]{0,1});
    fail("String_Node_Str");
  }
 catch (  AssertionError e) {
    Assertions.assertThat(e.getMessage()).isEqualTo(String.format("String_Node_Str" + "String_Node_Str"));
  }
}
Program: 130322
Project: 130322
Buggy source:
/** 
 * This method should fail because the value is greater than or equal to.
 */
@Test public void should_fail_because_value_is_not_equal_to(){
  WritableAssertionInfo info=new WritableAssertionInfo();
  info.description("String_Node_Str");
  Table table=new Table();
  TableAssert tableAssert=assertThat(table);
  try {
    AssertionsOnValueEquality.isEqualTo(tableAssert,info,Date.valueOf("String_Node_Str"),DateTimeValue.of(DateValue.of(2007,12,23)));
    fail("String_Node_Str");
  }
 catch (  AssertionError e) {
    Assertions.assertThat(e.getMessage()).isEqualTo(String.format("String_Node_Str" + "String_Node_Str" + "String_Node_Str"+ "String_Node_Str"+ "String_Node_Str"));
  }
  try {
    AssertionsOnValueEquality.isEqualTo(tableAssert,info,Timestamp.valueOf("String_Node_Str"),DateTimeValue.of(DateValue.of(2007,12,23),TimeValue.of(9,1)));
    fail("String_Node_Str");
  }
 catch (  AssertionError e) {
    Assertions.assertThat(e.getMessage()).isEqualTo(String.format("String_Node_Str" + "String_Node_Str" + "String_Node_Str"+ "String_Node_Str"+ "String_Node_Str"));
  }
}

Fixed version (ground truth):
/** 
 * This method should fail because the value is not equal to.
 */
@Test public void should_fail_because_value_is_not_equal_to(){
  WritableAssertionInfo info=new WritableAssertionInfo();
  info.description("String_Node_Str");
  Table table=new Table();
  TableAssert tableAssert=assertThat(table);
  try {
    AssertionsOnValueEquality.isEqualTo(tableAssert,info,Date.valueOf("String_Node_Str"),DateTimeValue.of(DateValue.of(2007,12,23)));
    fail("String_Node_Str");
  }
 catch (  AssertionError e) {
    Assertions.assertThat(e.getMessage()).isEqualTo(String.format("String_Node_Str" + "String_Node_Str" + "String_Node_Str"+ "String_Node_Str"+ "String_Node_Str"));
  }
  try {
    AssertionsOnValueEquality.isEqualTo(tableAssert,info,Timestamp.valueOf("String_Node_Str"),DateTimeValue.of(DateValue.of(2007,12,23),TimeValue.of(9,1)));
    fail("String_Node_Str");
  }
 catch (  AssertionError e) {
    Assertions.assertThat(e.getMessage()).isEqualTo(String.format("String_Node_Str" + "String_Node_Str" + "String_Node_Str"+ "String_Node_Str"+ "String_Node_Str"));
  }
}
Program: 130323
Project: 130323
Buggy source:
/** 
 * This method should fail because the value is greater than or equal to.
 */
@Test public void should_fail_because_value_is_not_equal_to(){
  WritableAssertionInfo info=new WritableAssertionInfo();
  info.description("String_Node_Str");
  Table table=new Table();
  TableAssert tableAssert=assertThat(table);
  try {
    AssertionsOnValueEquality.isEqualTo(tableAssert,info,Date.valueOf("String_Node_Str"),DateValue.of(2007,12,23));
    fail("String_Node_Str");
  }
 catch (  AssertionError e) {
    Assertions.assertThat(e.getMessage()).isEqualTo(String.format("String_Node_Str" + "String_Node_Str" + "String_Node_Str"+ "String_Node_Str"+ "String_Node_Str"));
  }
  try {
    AssertionsOnValueEquality.isEqualTo(tableAssert,info,Timestamp.valueOf("String_Node_Str"),DateValue.of(2007,12,23));
    fail("String_Node_Str");
  }
 catch (  AssertionError e) {
    Assertions.assertThat(e.getMessage()).isEqualTo(String.format("String_Node_Str" + "String_Node_Str" + "String_Node_Str"+ "String_Node_Str"+ "String_Node_Str"));
  }
}

Fixed version (ground truth):
/** 
 * This method should fail because the value is not equal to.
 */
@Test public void should_fail_because_value_is_not_equal_to(){
  WritableAssertionInfo info=new WritableAssertionInfo();
  info.description("String_Node_Str");
  Table table=new Table();
  TableAssert tableAssert=assertThat(table);
  try {
    AssertionsOnValueEquality.isEqualTo(tableAssert,info,Date.valueOf("String_Node_Str"),DateValue.of(2007,12,23));
    fail("String_Node_Str");
  }
 catch (  AssertionError e) {
    Assertions.assertThat(e.getMessage()).isEqualTo(String.format("String_Node_Str" + "String_Node_Str" + "String_Node_Str"+ "String_Node_Str"+ "String_Node_Str"));
  }
  try {
    AssertionsOnValueEquality.isEqualTo(tableAssert,info,Timestamp.valueOf("String_Node_Str"),DateValue.of(2007,12,23));
    fail("String_Node_Str");
  }
 catch (  AssertionError e) {
    Assertions.assertThat(e.getMessage()).isEqualTo(String.format("String_Node_Str" + "String_Node_Str" + "String_Node_Str"+ "String_Node_Str"+ "String_Node_Str"));
  }
}
Program: 130324
Project: 130324
Buggy source:
/** 
 * This method should fail because the value is greater than or equal to.
 */
@Test public void should_fail_because_value_is_not_equal_to(){
  WritableAssertionInfo info=new WritableAssertionInfo();
  info.description("String_Node_Str");
  Table table=new Table();
  TableAssert tableAssert=assertThat(table);
  try {
    AssertionsOnValueEquality.isEqualTo(tableAssert,info,9,8);
    fail("String_Node_Str");
  }
 catch (  AssertionError e) {
    Assertions.assertThat(e.getMessage()).isEqualTo(String.format("String_Node_Str" + "String_Node_Str" + "String_Node_Str"+ "String_Node_Str"+ "String_Node_Str"));
  }
}

Fixed version (ground truth):
/** 
 * This method should fail because the value is not equal to.
 */
@Test public void should_fail_because_value_is_not_equal_to(){
  WritableAssertionInfo info=new WritableAssertionInfo();
  info.description("String_Node_Str");
  Table table=new Table();
  TableAssert tableAssert=assertThat(table);
  try {
    AssertionsOnValueEquality.isEqualTo(tableAssert,info,9,8);
    fail("String_Node_Str");
  }
 catch (  AssertionError e) {
    Assertions.assertThat(e.getMessage()).isEqualTo(String.format("String_Node_Str" + "String_Node_Str" + "String_Node_Str"+ "String_Node_Str"+ "String_Node_Str"));
  }
}
Program: 130326
Project: 130326
Buggy source:
/** 
 * This method should fail because the value is greater than or equal to.
 */
@Test public void should_fail_because_value_is_not_equal_to(){
  WritableAssertionInfo info=new WritableAssertionInfo();
  info.description("String_Node_Str");
  Table table=new Table();
  TableAssert tableAssert=assertThat(table);
  try {
    AssertionsOnValueEquality.isEqualTo(tableAssert,info,Time.valueOf("String_Node_Str"),TimeValue.of(9,1));
    fail("String_Node_Str");
  }
 catch (  AssertionError e) {
    Assertions.assertThat(e.getMessage()).isEqualTo(String.format("String_Node_Str" + "String_Node_Str" + "String_Node_Str"+ "String_Node_Str"+ "String_Node_Str"));
  }
}

Fixed version (ground truth):
/** 
 * This method should fail because the value is not equal to.
 */
@Test public void should_fail_because_value_is_not_equal_to(){
  WritableAssertionInfo info=new WritableAssertionInfo();
  info.description("String_Node_Str");
  Table table=new Table();
  TableAssert tableAssert=assertThat(table);
  try {
    AssertionsOnValueEquality.isEqualTo(tableAssert,info,Time.valueOf("String_Node_Str"),TimeValue.of(9,1));
    fail("String_Node_Str");
  }
 catch (  AssertionError e) {
    Assertions.assertThat(e.getMessage()).isEqualTo(String.format("String_Node_Str" + "String_Node_Str" + "String_Node_Str"+ "String_Node_Str"+ "String_Node_Str"));
  }
}
Program: 130327
Project: 130327
Buggy source:
/** 
 * This method should fail because the value is greater than or equal to.
 */
@Test public void should_fail_because_value_is_equal_to(){
  WritableAssertionInfo info=new WritableAssertionInfo();
  info.description("String_Node_Str");
  Table table=new Table();
  TableAssert tableAssert=assertThat(table);
  try {
    AssertionsOnValueNonEquality.isNotEqualTo(tableAssert,info,true,true);
    fail("String_Node_Str");
  }
 catch (  AssertionError e) {
    Assertions.assertThat(e.getMessage()).isEqualTo(String.format("String_Node_Str" + "String_Node_Str" + "String_Node_Str"+ "String_Node_Str"+ "String_Node_Str"));
  }
}

Fixed version (ground truth):
/** 
 * This method should fail because the value is equal to.
 */
@Test public void should_fail_because_value_is_equal_to(){
  WritableAssertionInfo info=new WritableAssertionInfo();
  info.description("String_Node_Str");
  Table table=new Table();
  TableAssert tableAssert=assertThat(table);
  try {
    AssertionsOnValueNonEquality.isNotEqualTo(tableAssert,info,true,true);
    fail("String_Node_Str");
  }
 catch (  AssertionError e) {
    Assertions.assertThat(e.getMessage()).isEqualTo(String.format("String_Node_Str" + "String_Node_Str" + "String_Node_Str"+ "String_Node_Str"+ "String_Node_Str"));
  }
}
Program: 130328
Project: 130328
Buggy source:
/** 
 * This method should fail because the value is greater than or equal to.
 */
@Test public void should_fail_because_value_is_equal_to(){
  WritableAssertionInfo info=new WritableAssertionInfo();
  info.description("String_Node_Str");
  Table table=new Table();
  TableAssert tableAssert=assertThat(table);
  try {
    AssertionsOnValueNonEquality.isNotEqualTo(tableAssert,info,new byte[]{0,1},new byte[]{0,1});
    fail("String_Node_Str");
  }
 catch (  AssertionError e) {
    Assertions.assertThat(e.getMessage()).isEqualTo(String.format("String_Node_Str" + "String_Node_Str"));
  }
}

Fixed version (ground truth):
/** 
 * This method should fail because the value is equal to.
 */
@Test public void should_fail_because_value_is_equal_to(){
  WritableAssertionInfo info=new WritableAssertionInfo();
  info.description("String_Node_Str");
  Table table=new Table();
  TableAssert tableAssert=assertThat(table);
  try {
    AssertionsOnValueNonEquality.isNotEqualTo(tableAssert,info,new byte[]{0,1},new byte[]{0,1});
    fail("String_Node_Str");
  }
 catch (  AssertionError e) {
    Assertions.assertThat(e.getMessage()).isEqualTo(String.format("String_Node_Str" + "String_Node_Str"));
  }
}
Program: 130329
Project: 130329
Buggy source:
/** 
 * This method should fail because the value is greater than or equal to.
 */
@Test public void should_fail_because_value_is_equal_to(){
  WritableAssertionInfo info=new WritableAssertionInfo();
  info.description("String_Node_Str");
  Table table=new Table();
  TableAssert tableAssert=assertThat(table);
  try {
    AssertionsOnValueNonEquality.isNotEqualTo(tableAssert,info,Date.valueOf("String_Node_Str"),DateTimeValue.of(DateValue.of(2007,12,23)));
    fail("String_Node_Str");
  }
 catch (  AssertionError e) {
    Assertions.assertThat(e.getMessage()).isEqualTo(String.format("String_Node_Str" + "String_Node_Str" + "String_Node_Str"+ "String_Node_Str"+ "String_Node_Str"));
  }
  try {
    AssertionsOnValueNonEquality.isNotEqualTo(tableAssert,info,Timestamp.valueOf("String_Node_Str"),DateTimeValue.of(DateValue.of(2007,12,23),TimeValue.of(9,1)));
    fail("String_Node_Str");
  }
 catch (  AssertionError e) {
    Assertions.assertThat(e.getMessage()).isEqualTo(String.format("String_Node_Str" + "String_Node_Str" + "String_Node_Str"+ "String_Node_Str"+ "String_Node_Str"));
  }
}

Fixed version (ground truth):
/** 
 * This method should fail because the value is equal to.
 */
@Test public void should_fail_because_value_is_equal_to(){
  WritableAssertionInfo info=new WritableAssertionInfo();
  info.description("String_Node_Str");
  Table table=new Table();
  TableAssert tableAssert=assertThat(table);
  try {
    AssertionsOnValueNonEquality.isNotEqualTo(tableAssert,info,Date.valueOf("String_Node_Str"),DateTimeValue.of(DateValue.of(2007,12,23)));
    fail("String_Node_Str");
  }
 catch (  AssertionError e) {
    Assertions.assertThat(e.getMessage()).isEqualTo(String.format("String_Node_Str" + "String_Node_Str" + "String_Node_Str"+ "String_Node_Str"+ "String_Node_Str"));
  }
  try {
    AssertionsOnValueNonEquality.isNotEqualTo(tableAssert,info,Timestamp.valueOf("String_Node_Str"),DateTimeValue.of(DateValue.of(2007,12,23),TimeValue.of(9,1)));
    fail("String_Node_Str");
  }
 catch (  AssertionError e) {
    Assertions.assertThat(e.getMessage()).isEqualTo(String.format("String_Node_Str" + "String_Node_Str" + "String_Node_Str"+ "String_Node_Str"+ "String_Node_Str"));
  }
}
Program: 130330
Project: 130330
Buggy source:
/** 
 * This method should fail because the value is greater than or equal to.
 */
@Test public void should_fail_because_value_is_equal_to(){
  WritableAssertionInfo info=new WritableAssertionInfo();
  info.description("String_Node_Str");
  Table table=new Table();
  TableAssert tableAssert=assertThat(table);
  try {
    AssertionsOnValueNonEquality.isNotEqualTo(tableAssert,info,Date.valueOf("String_Node_Str"),DateValue.of(2007,12,23));
    fail("String_Node_Str");
  }
 catch (  AssertionError e) {
    Assertions.assertThat(e.getMessage()).isEqualTo(String.format("String_Node_Str" + "String_Node_Str" + "String_Node_Str"+ "String_Node_Str"+ "String_Node_Str"));
  }
  try {
    AssertionsOnValueNonEquality.isNotEqualTo(tableAssert,info,Timestamp.valueOf("String_Node_Str"),DateValue.of(2007,12,23));
    fail("String_Node_Str");
  }
 catch (  AssertionError e) {
    Assertions.assertThat(e.getMessage()).isEqualTo(String.format("String_Node_Str" + "String_Node_Str" + "String_Node_Str"+ "String_Node_Str"+ "String_Node_Str"));
  }
}

Fixed version (ground truth):
/** 
 * This method should fail because the value is equal to.
 */
@Test public void should_fail_because_value_is_equal_to(){
  WritableAssertionInfo info=new WritableAssertionInfo();
  info.description("String_Node_Str");
  Table table=new Table();
  TableAssert tableAssert=assertThat(table);
  try {
    AssertionsOnValueNonEquality.isNotEqualTo(tableAssert,info,Date.valueOf("String_Node_Str"),DateValue.of(2007,12,23));
    fail("String_Node_Str");
  }
 catch (  AssertionError e) {
    Assertions.assertThat(e.getMessage()).isEqualTo(String.format("String_Node_Str" + "String_Node_Str" + "String_Node_Str"+ "String_Node_Str"+ "String_Node_Str"));
  }
  try {
    AssertionsOnValueNonEquality.isNotEqualTo(tableAssert,info,Timestamp.valueOf("String_Node_Str"),DateValue.of(2007,12,23));
    fail("String_Node_Str");
  }
 catch (  AssertionError e) {
    Assertions.assertThat(e.getMessage()).isEqualTo(String.format("String_Node_Str" + "String_Node_Str" + "String_Node_Str"+ "String_Node_Str"+ "String_Node_Str"));
  }
}