nus-yam/ex-repair huggingface dataset:
Program: 97718
Project: 97718
Buggy source:
public void testEvaluatesToTheTheLogicalConjunctionOfManyOtherMatchers(){
  assertThat("String_Node_Str",allOf(equalTo("String_Node_Str"),equalTo("String_Node_Str"),equalTo("String_Node_Str"),equalTo("String_Node_Str"),equalTo("String_Node_Str")));
  assertThat("String_Node_Str",not(allOf(equalTo("String_Node_Str"),equalTo("String_Node_Str"),equalTo("String_Node_Str"),equalTo("String_Node_Str"),equalTo("String_Node_Str"))));
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") public void testEvaluatesToTheTheLogicalConjunctionOfManyOtherMatchers(){
  assertThat("String_Node_Str",allOf(equalTo("String_Node_Str"),equalTo("String_Node_Str"),equalTo("String_Node_Str"),equalTo("String_Node_Str"),equalTo("String_Node_Str")));
  assertThat("String_Node_Str",not(allOf(equalTo("String_Node_Str"),equalTo("String_Node_Str"),equalTo("String_Node_Str"),equalTo("String_Node_Str"),equalTo("String_Node_Str"))));
}
Program: 97719
Project: 97719
Buggy source:
public void testEvaluatesToTheTheLogicalDisjunctionOfTwoOtherMatchers(){
  assertThat("String_Node_Str",anyOf(equalTo("String_Node_Str"),equalTo("String_Node_Str")));
  assertThat("String_Node_Str",anyOf(equalTo("String_Node_Str"),equalTo("String_Node_Str")));
  assertThat("String_Node_Str",anyOf(equalTo("String_Node_Str"),equalTo("String_Node_Str")));
  assertThat("String_Node_Str",not(anyOf(equalTo("String_Node_Str"),equalTo("String_Node_Str"))));
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") public void testEvaluatesToTheTheLogicalDisjunctionOfTwoOtherMatchers(){
  assertThat("String_Node_Str",anyOf(equalTo("String_Node_Str"),equalTo("String_Node_Str")));
  assertThat("String_Node_Str",anyOf(equalTo("String_Node_Str"),equalTo("String_Node_Str")));
  assertThat("String_Node_Str",anyOf(equalTo("String_Node_Str"),equalTo("String_Node_Str")));
  assertThat("String_Node_Str",not(anyOf(equalTo("String_Node_Str"),equalTo("String_Node_Str"))));
}
Program: 97720
Project: 97720
Buggy source:
public void testEvaluatesToTheTheLogicalDisjunctionOfManyOtherMatchers(){
  assertThat("String_Node_Str",anyOf(equalTo("String_Node_Str"),equalTo("String_Node_Str"),equalTo("String_Node_Str"),equalTo("String_Node_Str"),equalTo("String_Node_Str")));
  assertThat("String_Node_Str",not(anyOf(equalTo("String_Node_Str"),equalTo("String_Node_Str"),equalTo("String_Node_Str"),equalTo("String_Node_Str"),equalTo("String_Node_Str"))));
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") public void testEvaluatesToTheTheLogicalDisjunctionOfManyOtherMatchers(){
  assertThat("String_Node_Str",anyOf(equalTo("String_Node_Str"),equalTo("String_Node_Str"),equalTo("String_Node_Str"),equalTo("String_Node_Str"),equalTo("String_Node_Str")));
  assertThat("String_Node_Str",not(anyOf(equalTo("String_Node_Str"),equalTo("String_Node_Str"),equalTo("String_Node_Str"),equalTo("String_Node_Str"),equalTo("String_Node_Str"))));
}
Program: 97721
Project: 97721
Buggy source:
public void testHasAReadableDescription(){
  assertDescription("String_Node_Str",anyOf(equalTo("String_Node_Str"),equalTo("String_Node_Str"),equalTo("String_Node_Str")));
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") public void testHasAReadableDescription(){
  assertDescription("String_Node_Str",anyOf(equalTo("String_Node_Str"),equalTo("String_Node_Str"),equalTo("String_Node_Str")));
}
Program: 97722
Project: 97722
Buggy source:
protected Matcher<?> createMatcher(){
  return anything();
}

Fixed version (ground truth):
@Override protected Matcher<?> createMatcher(){
  return anything();
}
Program: 97723
Project: 97723
Buggy source:
protected Matcher<?> createMatcher(){
  return equalTo("String_Node_Str");
}

Fixed version (ground truth):
@Override protected Matcher<?> createMatcher(){
  return equalTo("String_Node_Str");
}
Program: 97724
Project: 97724
Buggy source:
public boolean equals(Object obj){
  return false;
}

Fixed version (ground truth):
@Override public boolean equals(Object obj){
  return false;
}
Program: 97725
Project: 97725
Buggy source:
public void testIncludesTheResultOfCallingToStringOnItsArgumentInTheDescription(){
  final String argumentDescription="String_Node_Str";
  Object argument=new Object(){
    public String toString(){
      return argumentDescription;
    }
  }
;
  assertDescription("String_Node_Str" + argumentDescription + "String_Node_Str",equalTo(argument));
}

Fixed version (ground truth):
public void testIncludesTheResultOfCallingToStringOnItsArgumentInTheDescription(){
  final String argumentDescription="String_Node_Str";
  Object argument=new Object(){
    @Override public String toString(){
      return argumentDescription;
    }
  }
;
  assertDescription("String_Node_Str" + argumentDescription + "String_Node_Str",equalTo(argument));
}
Program: 97726
Project: 97726
Buggy source:
public String toString(){
  return argumentDescription;
}

Fixed version (ground truth):
@Override public String toString(){
  return argumentDescription;
}
Program: 97727
Project: 97727
Buggy source:
public void testHonoursIsEqualImplementationEvenWithNullValues(){
  Object alwaysEqual=new Object(){
    public boolean equals(    Object obj){
      return true;
    }
  }
;
  Object neverEqual=new Object(){
    public boolean equals(    Object obj){
      return false;
    }
  }
;
  assertThat(alwaysEqual,equalTo(null));
  assertThat(neverEqual,not(equalTo(null)));
}

Fixed version (ground truth):
public void testHonoursIsEqualImplementationEvenWithNullValues(){
  Object alwaysEqual=new Object(){
    @Override public boolean equals(    Object obj){
      return true;
    }
  }
;
  Object neverEqual=new Object(){
    @Override public boolean equals(    Object obj){
      return false;
    }
  }
;
  assertThat(alwaysEqual,equalTo(null));
  assertThat(neverEqual,not(equalTo(null)));
}
Program: 97728
Project: 97728
Buggy source:
protected Matcher<?> createMatcher(){
  return not("String_Node_Str");
}

Fixed version (ground truth):
@Override protected Matcher<?> createMatcher(){
  return not("String_Node_Str");
}
Program: 97729
Project: 97729
Buggy source:
protected Matcher<?> createMatcher(){
  return nullValue();
}

Fixed version (ground truth):
@Override protected Matcher<?> createMatcher(){
  return nullValue();
}
Program: 97730
Project: 97730
Buggy source:
protected Matcher<?> createMatcher(){
  return sameInstance("String_Node_Str");
}

Fixed version (ground truth):
@Override protected Matcher<?> createMatcher(){
  return sameInstance("String_Node_Str");
}
Program: 97731
Project: 97731
Buggy source:
protected Matcher<?> createMatcher(){
  return is("String_Node_Str");
}

Fixed version (ground truth):
@Override protected Matcher<?> createMatcher(){
  return is("String_Node_Str");
}
Program: 97732
Project: 97732
Buggy source:
public void testProvidesConvenientShortcutForIsInstanceOf(){
  assertMatches("String_Node_Str",is(String.class),"String_Node_Str");
  assertDoesNotMatch("String_Node_Str",is(Integer.class),"String_Node_Str");
  assertDoesNotMatch("String_Node_Str",is(Integer.class),null);
}

Fixed version (ground truth):
public void testProvidesConvenientShortcutForIsInstanceOf(){
  assertTrue("String_Node_Str",is(String.class).matches("String_Node_Str"));
  assertFalse("String_Node_Str",is(Integer.class).matches(new Object()));
  assertFalse("String_Node_Str",is(Integer.class).matches(null));
}
Program: 97733
Project: 97733
Buggy source:
public boolean equals(Object obj){
  return obj instanceof SampleBaseClass && value.equals(((SampleBaseClass)obj).value);
}

Fixed version (ground truth):
@Override public boolean equals(Object obj){
  return obj instanceof SampleBaseClass && value.equals(((SampleBaseClass)obj).value);
}
Program: 97734
Project: 97734
Buggy source:
public String toString(){
  return value;
}

Fixed version (ground truth):
@Override public String toString(){
  return value;
}
Program: 97735
Project: 97735
Buggy source:
protected void setUp() throws Exception {
  super.setUp();
  factoryWriter=new EasyMock2FactoryWriter(output,"String_Node_Str","String_Node_Str");
}

Fixed version (ground truth):
@Override protected void setUp() throws Exception {
  super.setUp();
  factoryWriter=new EasyMock2FactoryWriter(output,"String_Node_Str","String_Node_Str");
}
Program: 97736
Project: 97736
Buggy source:
protected Matcher<?> createMatcher(){
  double irrelevant=0.1;
  return closeTo(irrelevant,irrelevant);
}

Fixed version (ground truth):
@Override protected Matcher<?> createMatcher(){
  double irrelevant=0.1;
  return closeTo(irrelevant,irrelevant);
}
Program: 97737
Project: 97737
Buggy source:
protected Matcher<?> createMatcher(){
  return typeCompatibleWith(BaseClass.class);
}

Fixed version (ground truth):
@Override protected Matcher<?> createMatcher(){
  return typeCompatibleWith(BaseClass.class);
}
Program: 97738
Project: 97738
Buggy source:
protected Matcher<?> createMatcher(){
  return eventFrom(null);
}

Fixed version (ground truth):
@Override protected Matcher<?> createMatcher(){
  return eventFrom(null);
}
Program: 97739
Project: 97739
Buggy source:
protected Matcher<?> createMatcher(){
  return equalToIgnoringCase("String_Node_Str");
}

Fixed version (ground truth):
@Override protected Matcher<?> createMatcher(){
  return equalToIgnoringCase("String_Node_Str");
}
Program: 97740
Project: 97740
Buggy source:
protected Matcher<?> createMatcher(){
  return matcher;
}

Fixed version (ground truth):
@Override protected Matcher<?> createMatcher(){
  return matcher;
}
Program: 97741
Project: 97741
Buggy source:
protected Matcher<?> createMatcher(){
  return m;
}

Fixed version (ground truth):
@Override protected Matcher<?> createMatcher(){
  return m;
}
Program: 97742
Project: 97742
Buggy source:
protected Matcher<?> createMatcher(){
  return stringContains;
}

Fixed version (ground truth):
@Override protected Matcher<?> createMatcher(){
  return stringContains;
}
Program: 97743
Project: 97743
Buggy source:
protected Matcher<?> createMatcher(){
  return stringEndsWith;
}

Fixed version (ground truth):
@Override protected Matcher<?> createMatcher(){
  return stringEndsWith;
}
Program: 97744
Project: 97744
Buggy source:
protected Matcher<?> createMatcher(){
  return stringStartsWith;
}

Fixed version (ground truth):
@Override protected Matcher<?> createMatcher(){
  return stringStartsWith;
}
Program: 97745
Project: 97745
Buggy source:
private Document parse(String xml) throws Exception {
  DocumentBuilderFactory documentBuilderFactory=DocumentBuilderFactory.newInstance();
  documentBuilderFactory.setNamespaceAware(true);
  DocumentBuilder documentBuilder=documentBuilderFactory.newDocumentBuilder();
  return documentBuilder.parse(new ByteArrayInputStream(xml.getBytes()));
}

Fixed version (ground truth):
private static Document parse(String xml) throws Exception {
  DocumentBuilderFactory documentBuilderFactory=DocumentBuilderFactory.newInstance();
  documentBuilderFactory.setNamespaceAware(true);
  DocumentBuilder documentBuilder=documentBuilderFactory.newDocumentBuilder();
  return documentBuilder.parse(new ByteArrayInputStream(xml.getBytes()));
}
Program: 97746
Project: 97746
Buggy source:
/** 
 * Evaluates to true only if ALL of the passed in matchers evaluate to true.
 */
@Factory public static <T>Matcher<T> allOf(Iterable<Matcher<? extends T>> matchers){
  return new AllOf<T>(matchers);
}

Fixed version (ground truth):
/** 
 * Evaluates to true only if ALL of the passed in matchers evaluate to true.
 */
@Factory public static <T>Matcher<T> allOf(Iterable<? extends Matcher<? extends T>> matchers){
  return new AllOf<T>(matchers);
}
Program: 97747
Project: 97747
Buggy source:
public AllOf(Iterable<Matcher<? extends T>> matchers){
  this.matchers=matchers;
}

Fixed version (ground truth):
public AllOf(Iterable<? extends Matcher<? extends T>> matchers){
  this.matchers=matchers;
}
Program: 97748
Project: 97748
Buggy source:
public AnyOf(Iterable<Matcher<? extends T>> matchers){
  this.matchers=matchers;
}

Fixed version (ground truth):
public AnyOf(Iterable<? extends Matcher<? extends T>> matchers){
  this.matchers=matchers;
}
Program: 97749
Project: 97749
Buggy source:
/** 
 * Evaluates to true if ANY of the passed in matchers evaluate to true.
 */
@Factory public static <T>Matcher<T> anyOf(Iterable<Matcher<? extends T>> matchers){
  return new AnyOf<T>(matchers);
}

Fixed version (ground truth):
/** 
 * Evaluates to true if ANY of the passed in matchers evaluate to true.
 */
@Factory public static <T>Matcher<T> anyOf(Iterable<? extends Matcher<? extends T>> matchers){
  return new AnyOf<T>(matchers);
}
Program: 97750
Project: 97750
Buggy source:
@Factory public static Matcher<Node> hasXPath(String xPath,NamespaceContext namespaceContext){
  return hasXPath(xPath,namespaceContext,null);
}

Fixed version (ground truth):
@Factory public static Matcher<Node> hasXPath(String xPath,NamespaceContext namespaceContext){
  return new HasXPath(xPath,namespaceContext,null,XPathConstants.NODE);
}
Program: 97751
Project: 97751
Buggy source:
public boolean matchesSafely(Node item){
  try {
    String result=(String)compiledXPath.evaluate(item,XPathConstants.STRING);
    if (result == null) {
      return false;
    }
 else     if (valueMatcher == null) {
      return !result.equals("String_Node_Str");
    }
 else {
      return valueMatcher.matches(result);
    }
  }
 catch (  XPathExpressionException e) {
    return false;
  }
}

Fixed version (ground truth):
public boolean matchesSafely(Node item){
  try {
    Object result=compiledXPath.evaluate(item,evaluationMode);
    if (result == null) {
      return false;
    }
 else     if (valueMatcher == null) {
      return true;
    }
 else {
      return valueMatcher.matches(result);
    }
  }
 catch (  XPathExpressionException e) {
    return false;
  }
}
Program: 97752
Project: 97752
Buggy source:
/** 
 * @param xPathExpression XPath expression.
 * @param namespaceContext Resolves XML namespace prefixes in the XPath expression
 * @param valueMatcher Matcher to use at given XPath.May be null to specify that the XPath must exist but the value is irrelevant.
 */
public HasXPath(String xPathExpression,NamespaceContext namespaceContext,Matcher<String> valueMatcher){
  try {
    XPath xPath=XPathFactory.newInstance().newXPath();
    if (namespaceContext != null) {
      xPath.setNamespaceContext(namespaceContext);
    }
    compiledXPath=xPath.compile(xPathExpression);
    this.xpathString=xPathExpression;
    this.valueMatcher=valueMatcher;
  }
 catch (  XPathExpressionException e) {
    throw new IllegalArgumentException("String_Node_Str" + xPathExpression,e);
  }
}

Fixed version (ground truth):
private HasXPath(String xPathExpression,NamespaceContext namespaceContext,Matcher<?> valueMatcher,QName mode){
  try {
    XPath xPath=XPathFactory.newInstance().newXPath();
    if (namespaceContext != null) {
      xPath.setNamespaceContext(namespaceContext);
    }
    compiledXPath=xPath.compile(xPathExpression);
    this.xpathString=xPathExpression;
    this.valueMatcher=valueMatcher;
    this.evaluationMode=mode;
  }
 catch (  XPathExpressionException e) {
    throw new IllegalArgumentException("String_Node_Str" + xPathExpression,e);
  }
}
Program: 97753
Project: 97753
Buggy source:
public void testMatchesWithNamespace() throws Exception {
  NamespaceContext ns=new NamespaceContext(){
    public String getNamespaceURI(    String prefix){
      return ("String_Node_Str".equals(prefix) ? "String_Node_Str" : null);
    }
    public String getPrefix(    String namespaceURI){
      return ("String_Node_Str".equals(namespaceURI) ? "String_Node_Str" : null);
    }
    public Iterator<String> getPrefixes(    String namespaceURI){
      HashSet<String> prefixes=new HashSet<String>();
      String prefix=getPrefix(namespaceURI);
      if (prefix != null) {
        prefixes.add(prefix);
      }
      return prefixes.iterator();
    }
  }
;
  assertThat(xml,hasXPath("String_Node_Str",ns));
  assertThat(xml,hasXPath("String_Node_Str",ns,equalTo("String_Node_Str")));
  assertThat(xml,hasXPath("String_Node_Str",ns,equalTo("String_Node_Str")));
}

Fixed version (ground truth):
public void testMatchesWithNamespace() throws Exception {
  assertThat(xml,hasXPath("String_Node_Str",ns));
  assertThat(xml,hasXPath("String_Node_Str",ns,equalTo("String_Node_Str")));
  assertThat(xml,hasXPath("String_Node_Str",ns,equalTo("String_Node_Str")));
}
Program: 97754
Project: 97754
Buggy source:
protected void setUp() throws Exception {
  super.setUp();
  xml=parse("String_Node_Str" + "String_Node_Str" + "String_Node_Str"+ "String_Node_Str"+ "String_Node_Str"+ "String_Node_Str");
}

Fixed version (ground truth):
protected void setUp() throws Exception {
  super.setUp();
  xml=parse("String_Node_Str" + "String_Node_Str" + "String_Node_Str"+ "String_Node_Str"+ "String_Node_Str"+ "String_Node_Str"+ "String_Node_Str"+ "String_Node_Str");
  ns=new NamespaceContext(){
    public String getNamespaceURI(    String prefix){
      return ("String_Node_Str".equals(prefix) ? "String_Node_Str" : null);
    }
    public String getPrefix(    String namespaceURI){
      return ("String_Node_Str".equals(namespaceURI) ? "String_Node_Str" : null);
    }
    public Iterator<String> getPrefixes(    String namespaceURI){
      HashSet<String> prefixes=new HashSet<String>();
      String prefix=getPrefix(namespaceURI);
      if (prefix != null) {
        prefixes.add(prefix);
      }
      return prefixes.iterator();
    }
  }
;
}
Program: 97755
Project: 97755
Buggy source:
public void testFailsIfNodeIsMissing() throws Exception {
  assertThat(xml,not(hasXPath("String_Node_Str",equalTo("String_Node_Str"))));
  assertThat(xml,not(hasXPath("String_Node_Str")));
}

Fixed version (ground truth):
public void testFailsIfNodeIsMissing() throws Exception {
  assertThat(xml,not(hasXPath("String_Node_Str",ns,equalTo("String_Node_Str"))));
  assertThat(xml,not(hasXPath("String_Node_Str",ns)));
}
Program: 97756
Project: 97756
Buggy source:
/** 
 * This is a shortcut to the frequently used is(instanceOf(SomeClass.class)). eg. assertThat(cheese, is(instanceOf(Cheddar.class))) vs  assertThat(cheese, is(Cheddar.class))
 */
@Factory public static Matcher<Object> is(Class type){
  return is(instanceOf(type));
}

Fixed version (ground truth):
/** 
 * This is a shortcut to the frequently used is(instanceOf(SomeClass.class)). eg. assertThat(cheese, is(instanceOf(Cheddar.class))) vs  assertThat(cheese, is(Cheddar.class))
 */
@Factory public static Matcher<Object> is(Class<?> type){
  return is(instanceOf(type));
}
Program: 97758
Project: 97758
Buggy source:
/** 
 * Set the   {@link Future}, which will unlock the   {@link Socket#fire} method once the connection has been fully established. \
 * @param {@link Future}
 */
void connectedFuture(Future f);

Fixed version (ground truth):
/** 
 * Set the   {@link Future}, which will unlock the   {@link Socket#fire} method once the connection has been fully established.
 * @param {@link Future}
 */
void connectedFuture(Future f);
Program: 97759
Project: 97759
Buggy source:
public AtmosphereSocketRuntime(WebSocketTransport webSocket,Options options,DefaultFuture rootFuture,List<FunctionWrapper> functions){
  super(webSocket,options,rootFuture,functions);
}

Fixed version (ground truth):
public AtmosphereSocketRuntime(Transport transport,Options options,DefaultFuture rootFuture,List<FunctionWrapper> functions){
  super(transport,options,rootFuture,functions);
}
Program: 97760
Project: 97760
Buggy source:
public SocketRuntime createRuntime(Options options,List<FunctionWrapper> functions){
  return new SocketRuntime(WebSocketTransport.class.cast(transportInUse),options,socketRuntime.future(),functions);
}

Fixed version (ground truth):
public SocketRuntime createRuntime(DefaultFuture future,Options options,List<FunctionWrapper> functions){
  return new SocketRuntime(transportInUse,options,future,functions);
}
Program: 97762
Project: 97762
Buggy source:
public SocketRuntime(Options options,DefaultFuture rootFuture,List<FunctionWrapper> functions){
  this(null,options,rootFuture,functions);
}

Fixed version (ground truth):
public SocketRuntime(Transport transport,Options options,DefaultFuture rootFuture,List<FunctionWrapper> functions){
  this.transport=transport;
  this.options=options;
  this.rootFuture=rootFuture;
  this.functions=functions;
}
Program: 97763
Project: 97763
Buggy source:
public Future write(Request request,Object data) throws IOException {
  Object object=invokeEncoder(request.encoders(),data);
  if (webSocketTransport != null) {
    webSocketWrite(request,object,data);
  }
 else {
    try {
      Response r=httpWrite(request,object,data).get(rootFuture.time,rootFuture.tu);
      String m=r.getResponseBody();
      if (!m.isEmpty()) {
        TransportsUtil.invokeFunction(request.decoders(),functions,String.class,m,MESSAGE.name(),request.functionResolver());
      }
    }
 catch (    TimeoutException t) {
      logger.trace("String_Node_Str",t);
      rootFuture.te=t;
    }
catch (    Throwable t) {
      logger.error("String_Node_Str",t);
    }
  }
  return rootFuture.done();
}

Fixed version (ground truth):
public Future write(Request request,Object data) throws IOException {
  Object object=invokeEncoder(request.encoders(),data);
  if (WebSocketTransport.class.isAssignableFrom(transport.getClass())) {
    webSocketWrite(request,object,data);
  }
 else {
    try {
      Response r=httpWrite(request,object,data).get(rootFuture.time(),rootFuture.timeUnit());
      String m=r.getResponseBody();
      if (!m.isEmpty()) {
        TransportsUtil.invokeFunction(request.decoders(),functions,String.class,m,MESSAGE.name(),request.functionResolver());
      }
    }
 catch (    TimeoutException t) {
      logger.trace("String_Node_Str",t);
      rootFuture.timeoutException(t);
    }
catch (    Throwable t) {
      logger.error("String_Node_Str",t);
    }
  }
  return rootFuture.done();
}
Program: 97764
Project: 97764
Buggy source:
public void webSocketWrite(Request request,Object object,Object data) throws IOException {
  if (InputStream.class.isAssignableFrom(object.getClass())) {
    InputStream is=(InputStream)object;
    ByteArrayOutputStream bs=new ByteArrayOutputStream();
    byte[] buffer=new byte[8192];
    int n=0;
    while (-1 != (n=is.read(buffer))) {
      bs.write(buffer,0,n);
    }
    webSocketTransport.webSocket().sendMessage(bs.toByteArray());
  }
 else   if (Reader.class.isAssignableFrom(object.getClass())) {
    Reader is=(Reader)object;
    StringWriter bs=new StringWriter();
    char[] chars=new char[8192];
    int n=0;
    while (-1 != (n=is.read(chars))) {
      bs.write(chars,0,n);
    }
    webSocketTransport.webSocket().sendTextMessage(bs.getBuffer().toString());
  }
 else   if (String.class.isAssignableFrom(object.getClass())) {
    webSocketTransport.webSocket().sendTextMessage(object.toString());
  }
 else   if (byte[].class.isAssignableFrom(object.getClass())) {
    webSocketTransport.webSocket().sendMessage((byte[])object);
  }
 else {
    throw new IllegalStateException("String_Node_Str" + data);
  }
}

Fixed version (ground truth):
public void webSocketWrite(Request request,Object object,Object data) throws IOException {
  WebSocketTransport webSocketTransport=WebSocketTransport.class.cast(transport);
  if (InputStream.class.isAssignableFrom(object.getClass())) {
    InputStream is=(InputStream)object;
    ByteArrayOutputStream bs=new ByteArrayOutputStream();
    byte[] buffer=new byte[8192];
    int n=0;
    while (-1 != (n=is.read(buffer))) {
      bs.write(buffer,0,n);
    }
    webSocketTransport.webSocket().sendMessage(bs.toByteArray());
  }
 else   if (Reader.class.isAssignableFrom(object.getClass())) {
    Reader is=(Reader)object;
    StringWriter bs=new StringWriter();
    char[] chars=new char[8192];
    int n=0;
    while (-1 != (n=is.read(chars))) {
      bs.write(chars,0,n);
    }
    webSocketTransport.webSocket().sendTextMessage(bs.getBuffer().toString());
  }
 else   if (String.class.isAssignableFrom(object.getClass())) {
    webSocketTransport.webSocket().sendTextMessage(object.toString());
  }
 else   if (byte[].class.isAssignableFrom(object.getClass())) {
    webSocketTransport.webSocket().sendMessage((byte[])object);
  }
 else {
    throw new IllegalStateException("String_Node_Str" + data);
  }
}
Program: 97765
Project: 97765
Buggy source:
public SerialSocketRuntime(Options options,DefaultFuture rootFuture,SerializedSocket serializedSocket,List<FunctionWrapper> functions){
  this(null,options,rootFuture,serializedSocket,functions);
}

Fixed version (ground truth):
public SerialSocketRuntime(Transport transport,Options options,DefaultFuture rootFuture,SerializedSocket serializedSocket,List<FunctionWrapper> functions){
  super(transport,options,rootFuture,functions);
  this.serializedSocket=serializedSocket;
}
Program: 97767
Project: 97767
Buggy source:
@Override public SocketRuntime createRuntime(){
  return new SerialSocketRuntime(options,new DefaultFuture(this),this,functions);
}

Fixed version (ground truth):
@Override public SocketRuntime createRuntime(DefaultFuture future,Options options,List<FunctionWrapper> functions){
  return new SerialSocketRuntime(transportInUse,options,new DefaultFuture(this),this,functions);
}
Program: 97768
Project: 97768
Buggy source:
/** 
 * {@inheritDoc}
 */
@Override public STATE onBodyPartReceived(HttpResponseBodyPart bodyPart) throws Exception {
  if (isBinary) {
    byte[] payload=bodyPart.getBodyPartBytes();
    if (payload[0] == 0x20) {
      if (!protocolReceived) {
        String m=new String(bodyPart.getBodyPartBytes(),charSet).trim();
        if (!m.isEmpty()) {
          TransportsUtil.invokeFunction(decoders,functions,payload.getClass(),payload,MESSAGE.name(),resolver);
          protocolReceived=true;
        }
      }
    }
 else {
      TransportsUtil.invokeFunction(decoders,functions,payload.getClass(),payload,MESSAGE.name(),resolver);
    }
  }
 else {
    String m=new String(bodyPart.getBodyPartBytes(),charSet).trim();
    if (!m.isEmpty()) {
      TransportsUtil.invokeFunction(decoders,functions,m.getClass(),m,MESSAGE.name(),resolver);
    }
  }
  return AsyncHandler.STATE.CONTINUE;
}

Fixed version (ground truth):
/** 
 * {@inheritDoc}
 */
@Override public STATE onBodyPartReceived(HttpResponseBodyPart bodyPart) throws Exception {
  if (isBinary) {
    byte[] payload=bodyPart.getBodyPartBytes();
    if (protocolEnabled && !protocolReceived) {
      String m=new String(bodyPart.getBodyPartBytes(),charSet).trim();
      if (!m.isEmpty()) {
        TransportsUtil.invokeFunction(decoders,functions,payload.getClass(),payload,MESSAGE.name(),resolver);
        protocolReceived=true;
      }
      return AsyncHandler.STATE.CONTINUE;
    }
 else     if (whiteSpace(payload)) {
      logger.trace("String_Node_Str");
    }
 else {
      TransportsUtil.invokeFunction(decoders,functions,payload.getClass(),payload,MESSAGE.name(),resolver);
    }
  }
 else {
    String m=new String(bodyPart.getBodyPartBytes(),charSet).trim();
    if (!m.isEmpty()) {
      TransportsUtil.invokeFunction(decoders,functions,m.getClass(),m,MESSAGE.name(),resolver);
    }
  }
  if (connectdFuture != null)   connectdFuture.done();
  return AsyncHandler.STATE.CONTINUE;
}
Program: 97769
Project: 97769
Buggy source:
/** 
 * {@inheritDoc}
 */
@Override public AsyncHandler.STATE onStatusReceived(HttpResponseStatus responseStatus) throws Exception {
  if (connectdFuture != null)   connectdFuture.done();
  TransportsUtil.invokeFunction(TRANSPORT,decoders,functions,Request.TRANSPORT.class,name(),TRANSPORT.name(),resolver);
  errorHandled.set(false);
  closed.set(false);
  Event newStatus=status.equals(Socket.STATUS.INIT) ? OPEN : REOPENED;
  TransportsUtil.invokeFunction(newStatus,decoders,functions,String.class,newStatus.name(),newStatus.name(),resolver);
  TransportsUtil.invokeFunction(MESSAGE,decoders,functions,Integer.class,new Integer(responseStatus.getStatusCode()),STATUS.name(),resolver);
  return AsyncHandler.STATE.CONTINUE;
}

Fixed version (ground truth):
/** 
 * {@inheritDoc}
 */
@Override public AsyncHandler.STATE onStatusReceived(HttpResponseStatus responseStatus) throws Exception {
  TransportsUtil.invokeFunction(TRANSPORT,decoders,functions,Request.TRANSPORT.class,name(),TRANSPORT.name(),resolver);
  errorHandled.set(false);
  closed.set(false);
  Event newStatus=status.equals(Socket.STATUS.INIT) ? OPEN : REOPENED;
  TransportsUtil.invokeFunction(newStatus,decoders,functions,String.class,newStatus.name(),newStatus.name(),resolver);
  TransportsUtil.invokeFunction(MESSAGE,decoders,functions,Integer.class,new Integer(responseStatus.getStatusCode()),STATUS.name(),resolver);
  return AsyncHandler.STATE.CONTINUE;
}
Program: 97770
Project: 97770
Buggy source:
public StreamTransport(RequestBuilder requestBuilder,Options options,Request request,List<FunctionWrapper> functions){
  this.decoders=request.decoders();
  if (decoders.size() == 0) {
    decoders.add(new Decoder<String,Object>(){
      @Override public Object decode(      Event e,      String s){
        return s;
      }
    }
);
  }
  this.functions=functions;
  this.resolver=request.functionResolver();
  this.options=options;
  this.requestBuilder=requestBuilder;
  this.request=request;
  isBinary=request.headers().get("String_Node_Str") != null ? request.headers().get("String_Node_Str").contains("String_Node_Str") : false;
}

Fixed version (ground truth):
public StreamTransport(RequestBuilder requestBuilder,Options options,Request request,List<FunctionWrapper> functions){
  this.decoders=request.decoders();
  if (decoders.size() == 0) {
    decoders.add(new Decoder<String,Object>(){
      @Override public Object decode(      Event e,      String s){
        return s;
      }
    }
);
  }
  this.functions=functions;
  this.resolver=request.functionResolver();
  this.options=options;
  this.requestBuilder=requestBuilder;
  this.request=request;
  protocolEnabled=request.queryString().get("String_Node_Str") != null;
  isBinary=request.headers().get("String_Node_Str") != null ? request.headers().get("String_Node_Str").contains("String_Node_Str") : false;
}
Program: 97771
Project: 97771
Buggy source:
/** 
 * Build an   {@link Options}
 * @return {@link Options}
 */
public abstract Options build();

Fixed version (ground truth):
/** 
 * Build an   {@link Options}
 * @return {@link Options}
 */
public abstract U build();
Program: 97772
Project: 97772
Buggy source:
/** 
 * {@inheritDoc}
 */
@Override public AtmosphereRequest build(){
  if (trackMessageLength) {
    decoders().add(0,new TrackMessageSizeDecoder());
  }
  decoders().add(0,new Decoder<String,String>(){
    private AtomicBoolean protocolReceived=new AtomicBoolean();
    /** 
 * Handle the Atmosphere's Protocol.
 */
    @Override public String decode(    Event e,    String s){
      if (e.equals(Event.MESSAGE) && !protocolReceived.getAndSet(true)) {
        try {
          String[] proto=s.trim().split("String_Node_Str");
          List<String> l=new ArrayList<String>();
          l.add(proto[0]);
          queryString.put("String_Node_Str",l);
          l=new ArrayList<String>();
          l.add(proto[1]);
          queryString.put("String_Node_Str",l);
          s=null;
        }
 catch (        Exception ex) {
          logger.warn("String_Node_Str",s);
          logger.warn("String_Node_Str",e);
        }
      }
      return s;
    }
  }
);
  return new AtmosphereRequest(this);
}

Fixed version (ground truth):
/** 
 * {@inheritDoc}
 */
@Override public AtmosphereRequest build(){
  if (trackMessageLength) {
    decoders().add(0,new TrackMessageSizeDecoder());
  }
  decoders().add(0,new Decoder<String,String>(){
    private AtomicBoolean protocolReceived=new AtomicBoolean();
    /** 
 * Handle the Atmosphere's Protocol.
 */
    @Override public String decode(    Event e,    String s){
      if (e.equals(Event.MESSAGE) && !protocolReceived.getAndSet(true)) {
        try {
          String[] proto=s.trim().split("String_Node_Str");
          List<String> l=new ArrayList<String>();
          l.add(proto[0]);
          queryString.put("String_Node_Str",l);
          l=new ArrayList<String>();
          l.add(proto[1]);
          queryString.put("String_Node_Str",l);
          decoders.remove(this);
          s=null;
        }
 catch (        Exception ex) {
          logger.warn("String_Node_Str",s);
          logger.warn("String_Node_Str",e);
        }
      }
      return s;
    }
  }
);
  decoders().add(0,new Decoder<byte[],byte[]>(){
    private AtomicBoolean protocolReceived=new AtomicBoolean();
    /** 
 * Handle the Atmosphere's Protocol.
 */
    @Override public byte[] decode(    Event e,    byte[] b){
      if (e.equals(Event.MESSAGE) && !protocolReceived.getAndSet(true)) {
        try {
          String[] proto=new String(b,"String_Node_Str").trim().split("String_Node_Str");
          List<String> l=new ArrayList<String>();
          l.add(proto[0]);
          queryString.put("String_Node_Str",l);
          l=new ArrayList<String>();
          l.add(proto[1]);
          queryString.put("String_Node_Str",l);
          decoders.remove(this);
          b=null;
        }
 catch (        Exception ex) {
          logger.warn("String_Node_Str",new String(b));
          logger.warn("String_Node_Str",e);
        }
      }
      return b;
    }
  }
);
  return new AtmosphereRequest(this);
}
Program: 97773
Project: 97773
Buggy source:
/** 
 * Handle the Atmosphere's Protocol.
 */
@Override public String decode(Event e,String s){
  if (e.equals(Event.MESSAGE) && !protocolReceived.getAndSet(true)) {
    try {
      String[] proto=s.trim().split("String_Node_Str");
      List<String> l=new ArrayList<String>();
      l.add(proto[0]);
      queryString.put("String_Node_Str",l);
      l=new ArrayList<String>();
      l.add(proto[1]);
      queryString.put("String_Node_Str",l);
      s=null;
    }
 catch (    Exception ex) {
      logger.warn("String_Node_Str",s);
      logger.warn("String_Node_Str",e);
    }
  }
  return s;
}

Fixed version (ground truth):
/** 
 * Handle the Atmosphere's Protocol.
 */
@Override public byte[] decode(Event e,byte[] b){
  if (e.equals(Event.MESSAGE) && !protocolReceived.getAndSet(true)) {
    try {
      String[] proto=new String(b,"String_Node_Str").trim().split("String_Node_Str");
      List<String> l=new ArrayList<String>();
      l.add(proto[0]);
      queryString.put("String_Node_Str",l);
      l=new ArrayList<String>();
      l.add(proto[1]);
      queryString.put("String_Node_Str",l);
      decoders.remove(this);
      b=null;
    }
 catch (    Exception ex) {
      logger.warn("String_Node_Str",new String(b));
      logger.warn("String_Node_Str",e);
    }
  }
  return b;
}
Program: 97774
Project: 97774
Buggy source:
private HttpResponse execute(URI uri,HttpRequestBase request) throws IOException, URISyntaxException {
  request.addHeader("String_Node_Str","String_Node_Str");
  HttpResponse response=httpClient.execute(adjustAddress(uri,request),localContext);
  if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
    EntityUtils.consumeQuietly(response.getEntity());
    throw new IllegalStateException("String_Node_Str" + response.getStatusLine().getStatusCode() + "String_Node_Str");
  }
  return response;
}

Fixed version (ground truth):
private HttpResponse execute(URI uri,HttpRequestBase request) throws IOException, URISyntaxException {
  request.addHeader("String_Node_Str","String_Node_Str");
  HttpResponse response=httpClient.execute(adjustAddress(uri,request),localContext);
  if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
    EntityUtils.toString(response.getEntity());
    throw new IllegalStateException("String_Node_Str" + response.getStatusLine().getStatusCode() + "String_Node_Str");
  }
  return response;
}
Program: 97776
Project: 97776
Buggy source:
@Override public void parameters(final String[] par,final SnipeData v){
  v.sendMessage(TextColors.RED,"String_Node_Str");
}

Fixed version (ground truth):
@Override public void parameters(final String[] par,final SnipeData v){
  if (par.length != 0) {
    v.sendMessage(TextColors.RED,"String_Node_Str");
  }
}
Program: 97778
Project: 97778
Buggy source:
private void ball(SnipeData v,Location<World> targetBlock){
  double brushSize=v.getBrushSize();
  double brushSizeSquared=brushSize * brushSize;
  int tx=targetBlock.getBlockX();
  int ty=targetBlock.getBlockY();
  int tz=targetBlock.getBlockZ();
  int minx=GenericMath.floor(targetBlock.getBlockX() - brushSize);
  int maxx=GenericMath.floor(targetBlock.getBlockX() + brushSize) + 1;
  int miny=Math.max(GenericMath.floor(targetBlock.getBlockY() - brushSize),0);
  int maxy=Math.min(GenericMath.floor(targetBlock.getBlockY() + brushSize) + 1,WORLD_HEIGHT);
  int minz=GenericMath.floor(targetBlock.getBlockZ() - brushSize);
  int maxz=GenericMath.floor(targetBlock.getBlockZ() + brushSize) + 1;
  this.undo=new Undo(GenericMath.floor(4 * Math.PI * (brushSize + 1)* (brushSize + 1)* (brushSize + 1) / 3));
  for (int x=minx; x <= maxx; x++) {
    double xs=(tx - x) * (tx - x);
    for (int y=miny; y <= maxy; y++) {
      double ys=(ty - y) * (ty - y);
      for (int z=minz; z <= maxz; z++) {
        double zs=(tz - z) * (tz - z);
        if (xs + ys + zs < brushSizeSquared) {
          perform(v,x,y,z);
        }
      }
    }
  }
  v.owner().storeUndo(this.undo);
  this.undo=null;
}

Fixed version (ground truth):
private void ball(SnipeData v,Location<World> targetBlock){
  double brushSize=v.getBrushSize();
  double brushSizeSquared=brushSize * brushSize;
  int tx=targetBlock.getBlockX();
  int ty=targetBlock.getBlockY();
  int tz=targetBlock.getBlockZ();
  int minx=GenericMath.floor(targetBlock.getBlockX() - brushSize);
  int maxx=GenericMath.floor(targetBlock.getBlockX() + brushSize) + 1;
  int miny=Math.max(GenericMath.floor(targetBlock.getBlockY() - brushSize),0);
  int maxy=Math.min(GenericMath.floor(targetBlock.getBlockY() + brushSize) + 1,WORLD_HEIGHT);
  int minz=GenericMath.floor(targetBlock.getBlockZ() - brushSize);
  int maxz=GenericMath.floor(targetBlock.getBlockZ() + brushSize) + 1;
  this.undo=new Undo(GenericMath.floor(4 * Math.PI * (brushSize + 1)* (brushSize + 1)* (brushSize + 1) / 3));
  for (int x=maxx; x >= minx; x--) {
    double xs=(tx - x) * (tx - x);
    for (int y=maxy; y >= miny; y--) {
      double ys=(ty - y) * (ty - y);
      for (int z=maxz; z >= minz; z--) {
        double zs=(tz - z) * (tz - z);
        if (xs + ys + zs < brushSizeSquared) {
          perform(v,x,y,z);
        }
      }
    }
  }
  v.owner().storeUndo(this.undo);
  this.undo=null;
}
Program: 97779
Project: 97779
Buggy source:
private void ellipse(final SnipeData v,Location<World> targetBlock,Direction axis){
  double xrads=this.xrad * this.xrad;
  double yrads=this.yrad * this.yrad;
  int tx=targetBlock.getBlockX();
  int tz=targetBlock.getBlockZ();
  int minx=GenericMath.floor(targetBlock.getBlockX() - this.xrad);
  int maxx=GenericMath.floor(targetBlock.getBlockX() + this.xrad) + 1;
  int minz=GenericMath.floor(targetBlock.getBlockZ() - this.yrad);
  int maxz=GenericMath.floor(targetBlock.getBlockZ() + this.yrad) + 1;
  this.undo=new Undo(GenericMath.floor(Math.PI * (this.xrad + 1) * (this.yrad + 1)));
  for (int x=minx; x <= maxx; x++) {
    double xs=(tx - x) * (tx - x);
    for (int z=minz; z <= maxz; z++) {
      double zs=(tz - z) * (tz - z);
      if (xs / xrads + zs / yrads < 1) {
        if (axis == Direction.UP) {
          perform(v,x,targetBlock.getBlockY(),z);
        }
 else         if (axis == Direction.NORTH) {
          perform(v,x,z,targetBlock.getBlockZ());
        }
 else         if (axis == Direction.EAST) {
          perform(v,targetBlock.getBlockX(),x,z);
        }
      }
    }
  }
  v.owner().storeUndo(this.undo);
  this.undo=null;
}

Fixed version (ground truth):
private void ellipse(final SnipeData v,Location<World> targetBlock,Direction axis){
  double xrads=this.xrad * this.xrad;
  double yrads=this.yrad * this.yrad;
  int tx=targetBlock.getBlockX();
  int tz=targetBlock.getBlockZ();
  int minx=GenericMath.floor(targetBlock.getBlockX() - this.xrad);
  int maxx=(int)Math.ceil(targetBlock.getBlockX() + this.xrad);
  int minz=GenericMath.floor(targetBlock.getBlockZ() - this.yrad);
  int maxz=(int)Math.ceil(targetBlock.getBlockZ() + this.yrad);
  this.undo=new Undo(GenericMath.floor(Math.PI * (this.xrad + 1) * (this.yrad + 1)));
  for (int x=minx; x <= maxx; x++) {
    double xs=(tx - x) * (tx - x);
    for (int z=minz; z <= maxz; z++) {
      double zs=(tz - z) * (tz - z);
      if (xs / xrads + zs / yrads < 1) {
        if (axis == Direction.UP) {
          perform(v,x,targetBlock.getBlockY(),z);
        }
 else         if (axis == Direction.NORTH) {
          perform(v,x,z,targetBlock.getBlockZ());
        }
 else         if (axis == Direction.EAST) {
          perform(v,targetBlock.getBlockX(),x,z);
        }
      }
    }
  }
  v.owner().storeUndo(this.undo);
  this.undo=null;
}
Program: 97781
Project: 97781
Buggy source:
private void ellipsoid(final SnipeData v,Location<World> targetBlock){
  double xrads=this.xrad * this.xrad;
  double yrads=this.yrad * this.yrad;
  double zrads=this.zrad * this.zrad;
  int tx=targetBlock.getBlockX();
  int ty=targetBlock.getBlockY();
  int tz=targetBlock.getBlockZ();
  int minx=GenericMath.floor(targetBlock.getBlockX() - this.xrad);
  int maxx=GenericMath.floor(targetBlock.getBlockX() + this.xrad) + 1;
  int miny=Math.max(GenericMath.floor(targetBlock.getBlockY() - this.yrad),0);
  int maxy=Math.min(GenericMath.floor(targetBlock.getBlockY() + this.yrad) + 1,WORLD_HEIGHT);
  int minz=GenericMath.floor(targetBlock.getBlockZ() - this.zrad);
  int maxz=GenericMath.floor(targetBlock.getBlockZ() + this.zrad) + 1;
  this.undo=new Undo(GenericMath.floor(4 * Math.PI * (this.xrad + 1)* (this.yrad + 1)* (this.zrad + 1) / 3));
  for (int x=minx; x <= maxx; x++) {
    double xs=(tx - x) * (tx - x);
    for (int y=miny; y <= maxy; y++) {
      double ys=(ty - y) * (ty - y);
      for (int z=minz; z <= maxz; z++) {
        double zs=(tz - z) * (tz - z);
        if (xs / xrads + ys / yrads + zs / zrads < 1) {
          perform(v,x,y,z);
        }
      }
    }
  }
  v.owner().storeUndo(this.undo);
  this.undo=null;
}

Fixed version (ground truth):
private void ellipsoid(final SnipeData v,Location<World> targetBlock){
  double xrads=this.xrad * this.xrad;
  double yrads=this.yrad * this.yrad;
  double zrads=this.zrad * this.zrad;
  int tx=targetBlock.getBlockX();
  int ty=targetBlock.getBlockY();
  int tz=targetBlock.getBlockZ();
  int minx=GenericMath.floor(targetBlock.getBlockX() - this.xrad);
  int maxx=GenericMath.floor(targetBlock.getBlockX() + this.xrad) + 1;
  int miny=Math.max(GenericMath.floor(targetBlock.getBlockY() - this.yrad),0);
  int maxy=Math.min(GenericMath.floor(targetBlock.getBlockY() + this.yrad) + 1,WORLD_HEIGHT);
  int minz=GenericMath.floor(targetBlock.getBlockZ() - this.zrad);
  int maxz=GenericMath.floor(targetBlock.getBlockZ() + this.zrad) + 1;
  this.undo=new Undo(GenericMath.floor(4 * Math.PI * (this.xrad + 1)* (this.yrad + 1)* (this.zrad + 1) / 3));
  for (int x=maxx; x >= minx; x--) {
    double xs=(tx - x) * (tx - x);
    for (int y=maxy; y >= miny; y--) {
      double ys=(ty - y) * (ty - y);
      for (int z=maxz; z >= minz; z--) {
        double zs=(tz - z) * (tz - z);
        if (xs / xrads + ys / yrads + zs / zrads < 1) {
          perform(v,x,y,z);
        }
      }
    }
  }
  v.owner().storeUndo(this.undo);
  this.undo=null;
}
Program: 97782
Project: 97782
Buggy source:
private void spawn(final SnipeData v){
  for (int x=0; x < v.getBrushSize(); x++) {
    Entity e=this.world.createEntity(this.entityType,this.lastBlock.getBlockPosition());
    this.world.spawnEntity(e,this.cause);
  }
}

Fixed version (ground truth):
private void spawn(final SnipeData v){
  Cause cause=Cause.builder().named(NamedCause.of("String_Node_Str",SpawnCause.builder().type(SpawnTypes.PLUGIN).build())).from(this.cause).build();
  for (int x=0; x < v.getBrushSize(); x++) {
    Entity e=this.world.createEntity(this.entityType,this.lastBlock.getBlockPosition());
    this.world.spawnEntity(e,cause);
  }
}
Program: 97783
Project: 97783
Buggy source:
@Override public final void parameters(final String[] par,final SnipeData v){
  if (par.length == 0 || par[0].equalsIgnoreCase("String_Node_Str")) {
    v.sendMessage(TextColors.AQUA + "String_Node_Str");
    StringBuilder types=new StringBuilder();
    for (    EntityType type : Sponge.getRegistry().getAllOf(EntityType.class)) {
      types.append("String_Node_Str").append(type.getId());
    }
    v.sendMessage(types.toString().substring(2));
  }
 else {
    Optional<EntityType> selection=Sponge.getRegistry().getType(EntityType.class,par[0]);
    if (!selection.isPresent()) {
      v.sendMessage(TextColors.RED + "String_Node_Str");
    }
 else {
      this.entityType=selection.get();
      v.sendMessage(TextColors.GREEN + "String_Node_Str" + this.entityType.getName());
    }
  }
}

Fixed version (ground truth):
@Override public final void parameters(final String[] par,final SnipeData v){
  if (par.length == 0 || par[0].equalsIgnoreCase("String_Node_Str")) {
    v.sendMessage(TextColors.AQUA,"String_Node_Str");
    StringBuilder types=new StringBuilder();
    for (    EntityType type : Sponge.getRegistry().getAllOf(EntityType.class)) {
      types.append("String_Node_Str").append(type.getId().replace("String_Node_Str","String_Node_Str"));
    }
    v.sendMessage(types.toString().substring(2));
  }
 else {
    Optional<EntityType> selection=Sponge.getRegistry().getType(EntityType.class,par[0]);
    if (!selection.isPresent()) {
      v.sendMessage(TextColors.RED,"String_Node_Str");
    }
 else {
      this.entityType=selection.get();
      v.sendMessage(TextColors.GREEN,"String_Node_Str" + this.entityType.getName());
    }
  }
}
Program: 97784
Project: 97784
Buggy source:
@Override public final void info(final Message vm){
  vm.brushMessage(TextColors.LIGHT_PURPLE + "String_Node_Str" + "String_Node_Str"+ this.entityType.getName()+ "String_Node_Str");
  vm.size();
}

Fixed version (ground truth):
@Override public final void info(final Message vm){
  vm.custom(TextColors.LIGHT_PURPLE,"String_Node_Str" + "String_Node_Str",TextColors.DARK_PURPLE,this.entityType.getName(),TextColors.LIGHT_PURPLE,"String_Node_Str");
  vm.size();
}
Program: 97785
Project: 97785
Buggy source:
private void radialRemoval(SnipeData v){
  int cx=this.targetBlock.getChunkPosition().getX();
  int cz=this.targetBlock.getChunkPosition().getZ();
  int entityCount=0;
  int chunkCount=0;
  int radius=(int)Math.round(v.getBrushSize() / 16);
  int radiusSquared=radius * radius;
  for (int x=-radius; x <= radius; x++) {
    for (int z=-radius; z <= radius; z++) {
      if (x * x + z * z < radiusSquared) {
        Optional<Chunk> chunk=this.world.getChunk(x + cx,0,z + cz);
        if (chunk.isPresent()) {
          entityCount+=removeEntities(chunk.get());
          chunkCount++;
        }
      }
    }
  }
  v.sendMessage(TextColors.GREEN + "String_Node_Str" + TextColors.RED+ entityCount+ TextColors.GREEN+ "String_Node_Str"+ TextColors.BLUE+ chunkCount+ TextColors.GREEN+ (chunkCount == 1 ? "String_Node_Str" : "String_Node_Str"));
}

Fixed version (ground truth):
private void radialRemoval(SnipeData v){
  int cx=this.targetBlock.getChunkPosition().getX();
  int cz=this.targetBlock.getChunkPosition().getZ();
  int entityCount=0;
  int chunkCount=0;
  if (v.getBrushSize() < 16) {
    Optional<Chunk> chunk=this.world.getChunk(cx,0,cz);
    if (chunk.isPresent()) {
      entityCount+=removeEntities(chunk.get());
      chunkCount++;
    }
  }
 else {
    int radius=(int)Math.ceil(v.getBrushSize() / 16);
    int radiusSquared=radius * radius;
    for (int x=-radius; x <= radius; x++) {
      for (int z=-radius; z <= radius; z++) {
        if (x * x + z * z <= radiusSquared) {
          Optional<Chunk> chunk=this.world.getChunk(x + cx,0,z + cz);
          if (chunk.isPresent()) {
            entityCount+=removeEntities(chunk.get());
            chunkCount++;
          }
        }
      }
    }
  }
  v.sendMessage(TextColors.GREEN,"String_Node_Str",TextColors.RED,entityCount,TextColors.GREEN,"String_Node_Str",TextColors.BLUE,chunkCount,TextColors.GREEN,(chunkCount == 1 ? "String_Node_Str" : "String_Node_Str"));
}