nus-yam/ex-repair huggingface dataset:
Program: 62711
Project: 62711
Buggy source:
@Override public List<Archive> getNestedArchives(EntryFilter filter) throws IOException {
  List<Archive> nestedArchives=new ArrayList();
  for (  Entry entry : this) {
    if (filter.matches(entry)) {
      nestedArchives.add(getNestedArchive(entry));
    }
  }
  return Collections.unmodifiableList(nestedArchives);
}

Fixed version (ground truth):
@Override public List<Archive> getNestedArchives(EntryFilter filter) throws IOException {
  List<Archive> nestedArchives=new ArrayList<>();
  for (  Entry entry : this) {
    if (filter.matches(entry)) {
      nestedArchives.add(getNestedArchive(entry));
    }
  }
  return Collections.unmodifiableList(nestedArchives);
}
Program: 62712
Project: 62712
Buggy source:
@Override public List<Archive> getNestedArchives(EntryFilter filter) throws IOException {
  List<Archive> nestedArchives=new ArrayList();
  for (  Entry entry : this) {
    if (filter.matches(entry)) {
      nestedArchives.add(getNestedArchive(entry));
    }
  }
  return Collections.unmodifiableList(nestedArchives);
}

Fixed version (ground truth):
@Override public List<Archive> getNestedArchives(EntryFilter filter) throws IOException {
  List<Archive> nestedArchives=new ArrayList<>();
  for (  Entry entry : this) {
    if (filter.matches(entry)) {
      nestedArchives.add(getNestedArchive(entry));
    }
  }
  return Collections.unmodifiableList(nestedArchives);
}
Program: 62713
Project: 62713
Buggy source:
@Override public List<Biz> getBizsInOrder(){
  List<Biz> bizList=new ArrayList<>();
  bizList.addAll(bizs.values());
  Collections.sort(bizList,new Comparator<Biz>(){
    @Override public int compare(    Biz o1,    Biz o2){
      return Integer.compare(o1.getPriority(),o2.getPriority());
    }
  }
);
  return bizList;
}

Fixed version (ground truth):
@Override public List<Biz> getBizsInOrder(){
  List<Biz> bizList=new ArrayList<>(bizs.values());
  Collections.sort(bizList,new Comparator<Biz>(){
    @Override public int compare(    Biz o1,    Biz o2){
      return Integer.compare(o1.getPriority(),o2.getPriority());
    }
  }
);
  return bizList;
}
Program: 62714
Project: 62714
Buggy source:
/** 
 * Find export resources
 * @param resourceName
 * @return
 */
protected Enumeration<URL> getExportResources(String resourceName) throws IOException {
  if (shouldFindExportedResource(resourceName)) {
    List<ClassLoader> exportResourceClassloadersInOrder=classloaderService.findExportResourceClassloadersInOrder(resourceName);
    if (exportResourceClassloadersInOrder != null) {
      List<Enumeration<URL>> enumerationList=new ArrayList<>();
      for (      ClassLoader exportResourceClassloader : exportResourceClassloadersInOrder) {
        enumerationList.add(((AbstractClasspathClassloader)exportResourceClassloader).getLocalResources(resourceName));
      }
      return new CompoundEnumeration<>(enumerationList.toArray((Enumeration<URL>[])new Enumeration<?>[0]));
    }
  }
  return Collections.emptyEnumeration();
}

Fixed version (ground truth):
/** 
 * Find export resources
 * @param resourceName
 * @return
 */
@SuppressWarnings("String_Node_Str") protected Enumeration<URL> getExportResources(String resourceName) throws IOException {
  if (shouldFindExportedResource(resourceName)) {
    List<ClassLoader> exportResourceClassloadersInOrder=classloaderService.findExportResourceClassloadersInOrder(resourceName);
    if (exportResourceClassloadersInOrder != null) {
      List<Enumeration<URL>> enumerationList=new ArrayList<>();
      for (      ClassLoader exportResourceClassloader : exportResourceClassloadersInOrder) {
        enumerationList.add(((AbstractClasspathClassloader)exportResourceClassloader).getLocalResources(resourceName));
      }
      return new CompoundEnumeration<>(enumerationList.toArray((Enumeration<URL>[])new Enumeration<?>[0]));
    }
  }
  return Collections.emptyEnumeration();
}
Program: 62715
Project: 62715
Buggy source:
@Override public <T>List<ServiceReference<T>> referenceServices(Class<T> ifClass,ServiceFilter serviceFilter){
  String serviceName=ifClass.getName();
  if (services.containsKey(serviceName)) {
    List<ServiceReference<T>> serviceReferences=new ArrayList<>();
    for (    ServiceReference<?> reference : services.get(serviceName)) {
      if (serviceFilter == null || serviceFilter.match(reference.getServiceMetadata().getServiceProvider())) {
        serviceReferences.add((ServiceReference<T>)reference);
      }
    }
    return serviceReferences;
  }
  return Collections.emptyList();
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") @Override public <T>List<ServiceReference<T>> referenceServices(Class<T> ifClass,ServiceFilter serviceFilter){
  String serviceName=ifClass.getName();
  if (services.containsKey(serviceName)) {
    List<ServiceReference<T>> serviceReferences=new ArrayList<>();
    for (    ServiceReference<?> reference : services.get(serviceName)) {
      if (serviceFilter == null || serviceFilter.match(reference.getServiceMetadata().getServiceProvider())) {
        serviceReferences.add((ServiceReference<T>)reference);
      }
    }
    return serviceReferences;
  }
  return Collections.emptyList();
}
Program: 62716
Project: 62716
Buggy source:
@Override public <T>ServiceReference<T> publishService(Class<T> ifClass,T implObject,ServiceProvider serviceProvider){
  ServiceMetadata serviceMetadata=new ServiceMetadataImpl(ifClass.getName(),ifClass,serviceProvider);
  if (!services.containsKey(serviceMetadata.getServiceName())) {
    services.putIfAbsent(serviceMetadata.getServiceName(),new CopyOnWriteArrayList<ServiceReference<?>>());
  }
  List<ServiceReference<?>> serviceReferences=services.get(serviceMetadata.getServiceName());
  for (  ServiceReference<?> serviceReference : serviceReferences) {
    if (serviceMetadata.equals(serviceReference.getServiceMetadata())) {
      LOGGER.warn(String.format("String_Node_Str",serviceMetadata.getServiceName(),serviceProvider));
      return (ServiceReference<T>)serviceReference;
    }
  }
  ServiceReference<T> serviceReference=new ServiceReferenceImpl<>(serviceMetadata,implObject);
  LOGGER.info(String.format("String_Node_Str",serviceMetadata.getServiceName(),serviceProvider));
  serviceReferences.add(serviceReference);
  return serviceReference;
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") @Override public <T>ServiceReference<T> publishService(Class<T> ifClass,T implObject,ServiceProvider serviceProvider){
  ServiceMetadata serviceMetadata=new ServiceMetadataImpl(ifClass.getName(),ifClass,serviceProvider);
  if (!services.containsKey(serviceMetadata.getServiceName())) {
    services.putIfAbsent(serviceMetadata.getServiceName(),new CopyOnWriteArrayList<ServiceReference<?>>());
  }
  List<ServiceReference<?>> serviceReferences=services.get(serviceMetadata.getServiceName());
  for (  ServiceReference<?> serviceReference : serviceReferences) {
    if (serviceMetadata.equals(serviceReference.getServiceMetadata())) {
      LOGGER.warn(String.format("String_Node_Str",serviceMetadata.getServiceName(),serviceProvider));
      return (ServiceReference<T>)serviceReference;
    }
  }
  ServiceReference<T> serviceReference=new ServiceReferenceImpl<>(serviceMetadata,implObject);
  LOGGER.info(String.format("String_Node_Str",serviceMetadata.getServiceName(),serviceProvider));
  serviceReferences.add(serviceReference);
  return serviceReference;
}
Program: 62717
Project: 62717
Buggy source:
/** 
 * <p>Validate that the argument condition is   {@code true}; otherwise throwing an exception with the specified message. This method is useful when validating according to an arbitrary boolean expression, such as validating a primitive number or using your own custom validation expression.</p>
 * @param expression  the boolean expression to check
 * @param message  the {@link String#format(String,Object)} exception message if invalid, not null
 * @param values  the optional values for the formatted exception message, null array not recommended
 * @throws IllegalArgumentException if expression is {@code false}
 */
public static void isTrue(final boolean expression,final String message,final Object... values){
  if (expression == false) {
    throw new IllegalArgumentException(String.format(message,values));
  }
}

Fixed version (ground truth):
/** 
 * <p>Validate that the argument condition is   {@code true}; otherwise throwing an exception with the specified message. This method is useful when validating according to an arbitrary boolean expression, such as validating a primitive number or using your own custom validation expression.</p>
 * @param expression  the boolean expression to check
 * @param message  the {@link String#format(String,Object)} exception message if invalid, not null
 * @param values  the optional values for the formatted exception message, null array not recommended
 * @throws IllegalArgumentException if expression is {@code false}
 */
public static void isTrue(final boolean expression,final String message,final Object... values){
  if (!expression) {
    throw new IllegalArgumentException(String.format(message,values));
  }
}
Program: 62718
Project: 62718
Buggy source:
/** 
 * <p>Validate that the argument condition is   {@code false}; otherwise throwing an exception with the specified message. This method is useful when validating according to an arbitrary boolean expression, such as validating a primitive number or using your own custom validation expression.</p>
 * @param expression  the boolean expression to check
 * @param message  the {@link String#format(String,Object)} exception message if invalid, not null
 * @param values  the optional values for the formatted exception message, null array not recommended
 * @throws IllegalArgumentException if expression is {@code false}
 */
public static void isFalse(final boolean expression,final String message,final Object... values){
  if (expression == true) {
    throw new IllegalArgumentException(String.format(message,values));
  }
}

Fixed version (ground truth):
/** 
 * <p>Validate that the argument condition is   {@code false}; otherwise throwing an exception with the specified message. This method is useful when validating according to an arbitrary boolean expression, such as validating a primitive number or using your own custom validation expression.</p>
 * @param expression  the boolean expression to check
 * @param message  the {@link String#format(String,Object)} exception message if invalid, not null
 * @param values  the optional values for the formatted exception message, null array not recommended
 * @throws IllegalArgumentException if expression is {@code false}
 */
public static void isFalse(final boolean expression,final String message,final Object... values){
  if (expression) {
    throw new IllegalArgumentException(String.format(message,values));
  }
}
Program: 62719
Project: 62719
Buggy source:
private Set<Artifact> getAdditionalArtifact() throws MojoExecutionException {
  Artifact arkArtifact=artifactFactory.createArtifact(ArkConstants.getGroupId(),ArkConstants.getArtifactId(),arkVersion,ArkConstants.getScope(),ArkConstants.getType());
  try {
    artifactResolver.resolve(arkArtifact,project.getRemoteArtifactRepositories(),mavenSession.getLocalRepository());
    Set<Artifact> artifacts=filterExcludeArtifacts(project.getArtifacts());
    artifacts.add(arkArtifact);
    return artifacts;
  }
 catch (  Exception ex) {
    throw new MojoExecutionException(ex.getMessage(),ex);
  }
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") private Set<Artifact> getAdditionalArtifact() throws MojoExecutionException {
  Artifact arkArtifact=artifactFactory.createArtifact(ArkConstants.getGroupId(),ArkConstants.getArtifactId(),arkVersion,ArkConstants.getScope(),ArkConstants.getType());
  try {
    artifactResolver.resolve(arkArtifact,project.getRemoteArtifactRepositories(),mavenSession.getLocalRepository());
    Set<Artifact> artifacts=filterExcludeArtifacts(project.getArtifacts());
    artifacts.add(arkArtifact);
    return artifacts;
  }
 catch (  Exception ex) {
    throw new MojoExecutionException(ex.getMessage(),ex);
  }
}
Program: 62720
Project: 62720
Buggy source:
@Override public void execute() throws MojoExecutionException, MojoFailureException {
  if (this.project.getPackaging().equals("String_Node_Str")) {
    getLog().debug("String_Node_Str");
    return;
  }
  if (this.project.getPackaging().equals("String_Node_Str")) {
    getLog().debug("String_Node_Str");
    return;
  }
  if (StringUtils.isSameStr(this.arkClassifier,this.bizClassifier)) {
    getLog().debug("String_Node_Str");
    return;
  }
  if (this.skip) {
    getLog().debug("String_Node_Str");
    return;
  }
  PluginDescriptor pluginDescriptor=(PluginDescriptor)getPluginContext().get("String_Node_Str");
  arkVersion=pluginDescriptor.getVersion();
  repackage();
}

Fixed version (ground truth):
@Override public void execute() throws MojoExecutionException {
  if (this.project.getPackaging().equals("String_Node_Str")) {
    getLog().debug("String_Node_Str");
    return;
  }
  if (this.project.getPackaging().equals("String_Node_Str")) {
    getLog().debug("String_Node_Str");
    return;
  }
  if (StringUtils.isSameStr(this.arkClassifier,this.bizClassifier)) {
    getLog().debug("String_Node_Str");
    return;
  }
  if (this.skip) {
    getLog().debug("String_Node_Str");
    return;
  }
  PluginDescriptor pluginDescriptor=(PluginDescriptor)getPluginContext().get("String_Node_Str");
  arkVersion=pluginDescriptor.getVersion();
  repackage();
}
Program: 62721
Project: 62721
Buggy source:
protected boolean isTestOnArkContainer(Description description){
  RunWith runWith=description.getTestClass().getAnnotation(RunWith.class);
  if (runWith == null) {
    return false;
  }
  Class<?> runnerClass=runWith.value();
  String className=runnerClass.getName();
  if (className.equals(ARK_JUNIT4_RUNNER) || className.equals(ARK_BOOT_RUNNER)) {
    return true;
  }
  return false;
}

Fixed version (ground truth):
protected boolean isTestOnArkContainer(Description description){
  RunWith runWith=description.getTestClass().getAnnotation(RunWith.class);
  if (runWith == null) {
    return false;
  }
  Class<?> runnerClass=runWith.value();
  String className=runnerClass.getName();
  return ARK_JUNIT4_RUNNER.equals(className) || ARK_BOOT_RUNNER.equals(className);
}
Program: 62722
Project: 62722
Buggy source:
private static final URL[] getURLClassPath(){
  ClassLoader classLoader=ClassLoader.getSystemClassLoader();
  return ((URLClassLoader)classLoader).getURLs();
}

Fixed version (ground truth):
private static URL[] getURLClassPath(){
  ClassLoader classLoader=ClassLoader.getSystemClassLoader();
  return ((URLClassLoader)classLoader).getURLs();
}
Program: 62723
Project: 62723
Buggy source:
private int find(int p){
  if (p < 0 && p >= parent.length)   throw new IllegalArgumentException("String_Node_Str");
  while (p != parent[p])   p=parent[p];
  return p;
}

Fixed version (ground truth):
private int find(int p){
  if (p < 0 || p >= parent.length)   throw new IllegalArgumentException("String_Node_Str");
  while (p != parent[p])   p=parent[p];
  return p;
}
Program: 62724
Project: 62724
Buggy source:
private int find(int p){
  if (p < 0 && p >= id.length)   throw new IllegalArgumentException("String_Node_Str");
  return id[p];
}

Fixed version (ground truth):
private int find(int p){
  if (p < 0 || p >= id.length)   throw new IllegalArgumentException("String_Node_Str");
  return id[p];
}
Program: 62725
Project: 62725
Buggy source:
private int find(int p){
  if (p < 0 && p >= parent.length)   throw new IllegalArgumentException("String_Node_Str");
  while (p != parent[p])   p=parent[p];
  return p;
}

Fixed version (ground truth):
private int find(int p){
  if (p < 0 || p >= parent.length)   throw new IllegalArgumentException("String_Node_Str");
  while (p != parent[p])   p=parent[p];
  return p;
}
Program: 62726
Project: 62726
Buggy source:
private int find(int p){
  if (p < 0 && p >= parent.length)   throw new IllegalArgumentException("String_Node_Str");
  while (p != parent[p])   p=parent[p];
  return p;
}

Fixed version (ground truth):
private int find(int p){
  if (p < 0 || p >= parent.length)   throw new IllegalArgumentException("String_Node_Str");
  while (p != parent[p])   p=parent[p];
  return p;
}
Program: 62727
Project: 62727
Buggy source:
private int find(int p){
  if (p < 0 && p >= parent.length)   throw new IllegalArgumentException("String_Node_Str");
  while (p != parent[p])   p=parent[p];
  return p;
}

Fixed version (ground truth):
private int find(int p){
  if (p < 0 || p >= parent.length)   throw new IllegalArgumentException("String_Node_Str");
  while (p != parent[p])   p=parent[p];
  return p;
}
Program: 62728
Project: 62728
Buggy source:
private int find(int p){
  if (p < 0 && p >= id.length)   throw new IllegalArgumentException("String_Node_Str");
  return id[p];
}

Fixed version (ground truth):
private int find(int p){
  if (p < 0 || p >= id.length)   throw new IllegalArgumentException("String_Node_Str");
  return id[p];
}
Program: 62729
Project: 62729
Buggy source:
private int find(int p){
  if (p < 0 && p >= parent.length)   throw new IllegalArgumentException("String_Node_Str");
  while (p != parent[p])   p=parent[p];
  return p;
}

Fixed version (ground truth):
private int find(int p){
  if (p < 0 || p >= parent.length)   throw new IllegalArgumentException("String_Node_Str");
  while (p != parent[p])   p=parent[p];
  return p;
}
Program: 62730
Project: 62730
Buggy source:
private int find(int p){
  if (p < 0 && p >= parent.length)   throw new IllegalArgumentException("String_Node_Str");
  while (p != parent[p])   p=parent[p];
  return p;
}

Fixed version (ground truth):
private int find(int p){
  if (p < 0 || p >= parent.length)   throw new IllegalArgumentException("String_Node_Str");
  while (p != parent[p])   p=parent[p];
  return p;
}
Program: 62731
Project: 62731
Buggy source:
private int find(int p){
  if (p < 0 && p >= parent.length)   throw new IllegalArgumentException("String_Node_Str");
  while (p != parent[p])   p=parent[p];
  return p;
}

Fixed version (ground truth):
private int find(int p){
  if (p < 0 || p >= parent.length)   throw new IllegalArgumentException("String_Node_Str");
  while (p != parent[p])   p=parent[p];
  return p;
}
Program: 62732
Project: 62732
Buggy source:
private int find(int p){
  if (p < 0 && p >= parent.length)   throw new IllegalArgumentException("String_Node_Str");
  while (p != parent[p]) {
    parent[p]=parent[parent[p]];
    p=parent[p];
  }
  return p;
}

Fixed version (ground truth):
private int find(int p){
  if (p < 0 || p >= parent.length)   throw new IllegalArgumentException("String_Node_Str");
  while (p != parent[p]) {
    parent[p]=parent[parent[p]];
    p=parent[p];
  }
  return p;
}
Program: 62733
Project: 62733
Buggy source:
private int find(int p){
  if (p < 0 && p >= id.length)   throw new IllegalArgumentException("String_Node_Str");
  return id[p];
}

Fixed version (ground truth):
private int find(int p){
  if (p < 0 || p >= id.length)   throw new IllegalArgumentException("String_Node_Str");
  return id[p];
}
Program: 62734
Project: 62734
Buggy source:
private int find(int p){
  if (p < 0 && p >= parent.length)   throw new IllegalArgumentException("String_Node_Str");
  while (p != parent[p])   p=parent[p];
  return p;
}

Fixed version (ground truth):
private int find(int p){
  if (p < 0 || p >= parent.length)   throw new IllegalArgumentException("String_Node_Str");
  while (p != parent[p])   p=parent[p];
  return p;
}
Program: 62735
Project: 62735
Buggy source:
private int find(int p){
  if (p < 0 && p >= parent.length)   throw new IllegalArgumentException("String_Node_Str");
  while (p != parent[p])   p=parent[p];
  return p;
}

Fixed version (ground truth):
private int find(int p){
  if (p < 0 || p >= parent.length)   throw new IllegalArgumentException("String_Node_Str");
  while (p != parent[p])   p=parent[p];
  return p;
}
Program: 62736
Project: 62736
Buggy source:
private int find(int p){
  if (p < 0 && p >= parent.length)   throw new IllegalArgumentException("String_Node_Str");
  while (p != parent[p])   p=parent[p];
  return p;
}

Fixed version (ground truth):
private int find(int p){
  if (p < 0 || p >= parent.length)   throw new IllegalArgumentException("String_Node_Str");
  while (p != parent[p])   p=parent[p];
  return p;
}
Program: 62737
Project: 62737
Buggy source:
private int find(int p){
  if (p < 0 && p >= parent.length)   throw new IllegalArgumentException("String_Node_Str");
  while (p != parent[p]) {
    parent[p]=parent[parent[p]];
    p=parent[p];
  }
  return p;
}

Fixed version (ground truth):
private int find(int p){
  if (p < 0 || p >= parent.length)   throw new IllegalArgumentException("String_Node_Str");
  while (p != parent[p]) {
    parent[p]=parent[parent[p]];
    p=parent[p];
  }
  return p;
}
Program: 62738
Project: 62738
Buggy source:
private int find(int p){
  if (p < 0 && p >= parent.length)   throw new IllegalArgumentException("String_Node_Str");
  if (p != parent[p])   parent[p]=find(parent[p]);
  return parent[p];
}

Fixed version (ground truth):
private int find(int p){
  if (p < 0 || p >= parent.length)   throw new IllegalArgumentException("String_Node_Str");
  if (p != parent[p])   parent[p]=find(parent[p]);
  return parent[p];
}
Program: 62739
Project: 62739
Buggy source:
private int find(int p){
  if (p < 0 && p >= id.length)   throw new IllegalArgumentException("String_Node_Str");
  return id[p];
}

Fixed version (ground truth):
private int find(int p){
  if (p < 0 || p >= id.length)   throw new IllegalArgumentException("String_Node_Str");
  return id[p];
}
Program: 62740
Project: 62740
Buggy source:
private int find(int p){
  if (p < 0 && p >= parent.length)   throw new IllegalArgumentException("String_Node_Str");
  while (p != parent[p])   p=parent[p];
  return p;
}

Fixed version (ground truth):
private int find(int p){
  if (p < 0 || p >= parent.length)   throw new IllegalArgumentException("String_Node_Str");
  while (p != parent[p])   p=parent[p];
  return p;
}
Program: 62741
Project: 62741
Buggy source:
private int find(int p){
  if (p < 0 && p >= parent.length)   throw new IllegalArgumentException("String_Node_Str");
  while (p != parent[p])   p=parent[p];
  return p;
}

Fixed version (ground truth):
private int find(int p){
  if (p < 0 || p >= parent.length)   throw new IllegalArgumentException("String_Node_Str");
  while (p != parent[p])   p=parent[p];
  return p;
}
Program: 62742
Project: 62742
Buggy source:
private int find(int p){
  if (p < 0 && p >= parent.length)   throw new IllegalArgumentException("String_Node_Str");
  while (p != parent[p])   p=parent[p];
  return p;
}

Fixed version (ground truth):
private int find(int p){
  if (p < 0 || p >= parent.length)   throw new IllegalArgumentException("String_Node_Str");
  while (p != parent[p])   p=parent[p];
  return p;
}
Program: 62743
Project: 62743
Buggy source:
private int find(int p){
  if (p < 0 && p >= parent.length)   throw new IllegalArgumentException("String_Node_Str");
  while (p != parent[p]) {
    parent[p]=parent[parent[p]];
    p=parent[p];
  }
  return p;
}

Fixed version (ground truth):
private int find(int p){
  if (p < 0 || p >= parent.length)   throw new IllegalArgumentException("String_Node_Str");
  while (p != parent[p]) {
    parent[p]=parent[parent[p]];
    p=parent[p];
  }
  return p;
}
Program: 62744
Project: 62744
Buggy source:
private int find(int p){
  if (p < 0 && p >= parent.length)   throw new IllegalArgumentException("String_Node_Str");
  if (p != parent[p])   parent[p]=find(parent[p]);
  return parent[p];
}

Fixed version (ground truth):
private int find(int p){
  if (p < 0 || p >= parent.length)   throw new IllegalArgumentException("String_Node_Str");
  if (p != parent[p])   parent[p]=find(parent[p]);
  return parent[p];
}
Program: 62745
Project: 62745
Buggy source:
public static void main(String[] args){
  System.out.println("String_Node_Str");
  ArrayList<String> words=new ArrayList<>();
  if (FileOperation.readFile("String_Node_Str",words)) {
    System.out.println("String_Node_Str" + words.size());
    long startTime=System.nanoTime();
    BST<String,Integer> bst=new BST<>();
    for (    String word : words) {
      if (bst.contains(word))       bst.set(word,bst.get(word) + 1);
 else       bst.add(word,1);
    }
    for (    String word : words)     bst.contains(word);
    long endTime=System.nanoTime();
    double time=(endTime - startTime) / 1000000000.0;
    System.out.println("String_Node_Str" + time + "String_Node_Str");
    startTime=System.nanoTime();
    AVLTree<String,Integer> avl=new AVLTree<>();
    for (    String word : words) {
      if (avl.contains(word))       avl.set(word,avl.get(word) + 1);
 else       avl.add(word,1);
    }
    for (    String word : words)     avl.contains(word);
    endTime=System.nanoTime();
    time=(endTime - startTime) / 1000000000.0;
    System.out.println("String_Node_Str" + time + "String_Node_Str");
    startTime=System.nanoTime();
    RBTree<String,Integer> rbt=new RBTree<>();
    for (    String word : words) {
      if (rbt.contains(word))       rbt.set(word,avl.get(word) + 1);
 else       rbt.add(word,1);
    }
    for (    String word : words)     rbt.contains(word);
    endTime=System.nanoTime();
    time=(endTime - startTime) / 1000000000.0;
    System.out.println("String_Node_Str" + time + "String_Node_Str");
  }
  System.out.println();
}

Fixed version (ground truth):
public static void main(String[] args){
  System.out.println("String_Node_Str");
  ArrayList<String> words=new ArrayList<>();
  if (FileOperation.readFile("String_Node_Str",words)) {
    System.out.println("String_Node_Str" + words.size());
    long startTime=System.nanoTime();
    BST<String,Integer> bst=new BST<>();
    for (    String word : words) {
      if (bst.contains(word))       bst.set(word,bst.get(word) + 1);
 else       bst.add(word,1);
    }
    for (    String word : words)     bst.contains(word);
    long endTime=System.nanoTime();
    double time=(endTime - startTime) / 1000000000.0;
    System.out.println("String_Node_Str" + time + "String_Node_Str");
    startTime=System.nanoTime();
    AVLTree<String,Integer> avl=new AVLTree<>();
    for (    String word : words) {
      if (avl.contains(word))       avl.set(word,avl.get(word) + 1);
 else       avl.add(word,1);
    }
    for (    String word : words)     avl.contains(word);
    endTime=System.nanoTime();
    time=(endTime - startTime) / 1000000000.0;
    System.out.println("String_Node_Str" + time + "String_Node_Str");
    startTime=System.nanoTime();
    RBTree<String,Integer> rbt=new RBTree<>();
    for (    String word : words) {
      if (rbt.contains(word))       rbt.set(word,rbt.get(word) + 1);
 else       rbt.add(word,1);
    }
    for (    String word : words)     rbt.contains(word);
    endTime=System.nanoTime();
    time=(endTime - startTime) / 1000000000.0;
    System.out.println("String_Node_Str" + time + "String_Node_Str");
  }
  System.out.println();
}
Program: 62746
Project: 62746
Buggy source:
private Pair<Node,E> remove(Node node,int index){
  if (index == 0)   return new Pair<>(node.next,node.e);
  Pair<Node,E> res=remove(node.next,index - 1);
  node.next=res.getKey();
  return res;
}

Fixed version (ground truth):
private Pair<Node,E> remove(Node node,int index){
  if (index == 0)   return new Pair<>(node.next,node.e);
  Pair<Node,E> res=remove(node.next,index - 1);
  node.next=res.getKey();
  return new Pair<>(node,res.getValue());
}
Program: 62747
Project: 62747
Buggy source:
public void levelOrder(){
  Queue<Node> q=new LinkedList<>();
  q.add(root);
  while (!q.isEmpty()) {
    Node cur=q.remove();
    System.out.println(cur.e);
    if (cur.left != null)     q.add(cur.left);
    if (cur.right != null)     q.add(cur.right);
  }
}

Fixed version (ground truth):
public void levelOrder(){
  if (root == null)   return;
  Queue<Node> q=new LinkedList<>();
  q.add(root);
  while (!q.isEmpty()) {
    Node cur=q.remove();
    System.out.println(cur.e);
    if (cur.left != null)     q.add(cur.left);
    if (cur.right != null)     q.add(cur.right);
  }
}
Program: 62748
Project: 62748
Buggy source:
public void preOrderNR(){
  Stack<Node> stack=new Stack<>();
  stack.push(root);
  while (!stack.isEmpty()) {
    Node cur=stack.pop();
    System.out.println(cur.e);
    if (cur.right != null)     stack.push(cur.right);
    if (cur.left != null)     stack.push(cur.left);
  }
}

Fixed version (ground truth):
public void preOrderNR(){
  if (root == null)   return;
  Stack<Node> stack=new Stack<>();
  stack.push(root);
  while (!stack.isEmpty()) {
    Node cur=stack.pop();
    System.out.println(cur.e);
    if (cur.right != null)     stack.push(cur.right);
    if (cur.left != null)     stack.push(cur.left);
  }
}
Program: 62749
Project: 62749
Buggy source:
public void removeElement(E e){
  Node prev=dummyHead;
  while (prev.next != null) {
    if (prev.next.e.equals(e))     break;
    prev=prev.next;
  }
  if (prev.next != null) {
    Node delNode=prev.next;
    prev.next=delNode.next;
    delNode.next=null;
  }
}

Fixed version (ground truth):
public void removeElement(E e){
  Node prev=dummyHead;
  while (prev.next != null) {
    if (prev.next.e.equals(e))     break;
    prev=prev.next;
  }
  if (prev.next != null) {
    Node delNode=prev.next;
    prev.next=delNode.next;
    delNode.next=null;
    size--;
  }
}
Program: 62750
Project: 62750
Buggy source:
public void removeElement(E e){
  Node prev=dummyHead;
  while (prev.next != null) {
    if (prev.next.e.equals(e))     break;
    prev=prev.next;
  }
  if (prev.next != null) {
    Node delNode=prev.next;
    prev.next=delNode.next;
    delNode.next=null;
  }
}

Fixed version (ground truth):
public void removeElement(E e){
  Node prev=dummyHead;
  while (prev.next != null) {
    if (prev.next.e.equals(e))     break;
    prev=prev.next;
  }
  if (prev.next != null) {
    Node delNode=prev.next;
    prev.next=delNode.next;
    delNode.next=null;
    size--;
  }
}
Program: 62751
Project: 62751
Buggy source:
public void removeElement(E e){
  Node prev=dummyHead;
  while (prev.next != null) {
    if (prev.next.e.equals(e))     break;
    prev=prev.next;
  }
  if (prev.next != null) {
    Node delNode=prev.next;
    prev.next=delNode.next;
    delNode.next=null;
  }
}

Fixed version (ground truth):
public void removeElement(E e){
  Node prev=dummyHead;
  while (prev.next != null) {
    if (prev.next.e.equals(e))     break;
    prev=prev.next;
  }
  if (prev.next != null) {
    Node delNode=prev.next;
    prev.next=delNode.next;
    delNode.next=null;
    size--;
  }
}
Program: 62752
Project: 62752
Buggy source:
public void removeElement(E e){
  Node prev=dummyHead;
  while (prev.next != null) {
    if (prev.next.e.equals(e))     break;
    prev=prev.next;
  }
  if (prev.next != null) {
    Node delNode=prev.next;
    prev.next=delNode.next;
    delNode.next=null;
  }
}

Fixed version (ground truth):
public void removeElement(E e){
  Node prev=dummyHead;
  while (prev.next != null) {
    if (prev.next.e.equals(e))     break;
    prev=prev.next;
  }
  if (prev.next != null) {
    Node delNode=prev.next;
    prev.next=delNode.next;
    delNode.next=null;
    size--;
  }
}
Program: 62753
Project: 62753
Buggy source:
public void removeElement(E e){
  Node prev=dummyHead;
  while (prev.next != null) {
    if (prev.next.e.equals(e))     break;
    prev=prev.next;
  }
  if (prev.next != null) {
    Node delNode=prev.next;
    prev.next=delNode.next;
    delNode.next=null;
  }
}

Fixed version (ground truth):
public void removeElement(E e){
  Node prev=dummyHead;
  while (prev.next != null) {
    if (prev.next.e.equals(e))     break;
    prev=prev.next;
  }
  if (prev.next != null) {
    Node delNode=prev.next;
    prev.next=delNode.next;
    delNode.next=null;
    size--;
  }
}
Program: 62754
Project: 62754
Buggy source:
public void removeElement(E e){
  Node prev=dummyHead;
  while (prev.next != null) {
    if (prev.next.e.equals(e))     break;
    prev=prev.next;
  }
  if (prev.next != null) {
    Node delNode=prev.next;
    prev.next=delNode.next;
    delNode.next=null;
  }
}

Fixed version (ground truth):
public void removeElement(E e){
  Node prev=dummyHead;
  while (prev.next != null) {
    if (prev.next.e.equals(e))     break;
    prev=prev.next;
  }
  if (prev.next != null) {
    Node delNode=prev.next;
    prev.next=delNode.next;
    delNode.next=null;
    size--;
  }
}
Program: 62755
Project: 62755
Buggy source:
public E remove(int index){
  if (index < 0 || index >= size)   throw new IllegalArgumentException("String_Node_Str");
  E ret=data[index];
  for (int i=index + 1; i < size; i++)   data[i - 1]=data[i];
  size--;
  data[size]=null;
  if (size == data.length / 4)   resize(data.length / 2);
  return ret;
}

Fixed version (ground truth):
public E remove(int index){
  if (index < 0 || index >= size)   throw new IllegalArgumentException("String_Node_Str");
  E ret=data[index];
  for (int i=index + 1; i < size; i++)   data[i - 1]=data[i];
  size--;
  data[size]=null;
  if (size == data.length / 4 && data.length / 2 != 0)   resize(data.length / 2);
  return ret;
}
Program: 62756
Project: 62756
Buggy source:
public E remove(int index){
  if (index < 0 || index >= size)   throw new IllegalArgumentException("String_Node_Str");
  E ret=data[index];
  for (int i=index + 1; i < size; i++)   data[i - 1]=data[i];
  size--;
  data[size]=null;
  if (size == data.length / 4)   resize(data.length / 2);
  return ret;
}

Fixed version (ground truth):
public E remove(int index){
  if (index < 0 || index >= size)   throw new IllegalArgumentException("String_Node_Str");
  E ret=data[index];
  for (int i=index + 1; i < size; i++)   data[i - 1]=data[i];
  size--;
  data[size]=null;
  if (size == data.length / 4 && data.length / 2 != 0)   resize(data.length / 2);
  return ret;
}
Program: 62757
Project: 62757
Buggy source:
public E remove(int index){
  if (index < 0 || index >= size)   throw new IllegalArgumentException("String_Node_Str");
  E ret=data[index];
  for (int i=index + 1; i < size; i++)   data[i - 1]=data[i];
  size--;
  data[size]=null;
  if (size == data.length / 4)   resize(data.length / 2);
  return ret;
}

Fixed version (ground truth):
public E remove(int index){
  if (index < 0 || index >= size)   throw new IllegalArgumentException("String_Node_Str");
  E ret=data[index];
  for (int i=index + 1; i < size; i++)   data[i - 1]=data[i];
  size--;
  data[size]=null;
  if (size == data.length / 4 && data.length / 2 != 0)   resize(data.length / 2);
  return ret;
}
Program: 62758
Project: 62758
Buggy source:
public E remove(int index){
  if (index < 0 || index >= size)   throw new IllegalArgumentException("String_Node_Str");
  E ret=data[index];
  for (int i=index + 1; i < size; i++)   data[i - 1]=data[i];
  size--;
  data[size]=null;
  if (size == data.length / 4)   resize(data.length / 2);
  return ret;
}

Fixed version (ground truth):
public E remove(int index){
  if (index < 0 || index >= size)   throw new IllegalArgumentException("String_Node_Str");
  E ret=data[index];
  for (int i=index + 1; i < size; i++)   data[i - 1]=data[i];
  size--;
  data[size]=null;
  if (size == data.length / 4 && data.length / 2 != 0)   resize(data.length / 2);
  return ret;
}
Program: 62759
Project: 62759
Buggy source:
private void init(){
  scrollerTask=() -> {
    int newPosition=getScrollX();
    if (initialPosition - newPosition == 0) {
      if (mOnScrollChangedListener != null) {
        mOnScrollChangedListener.onScrollStopped(getScrollX(),getScrollY());
      }
    }
 else {
      initialPosition=getScrollX();
      ObservableHorizontalScrollView.this.postDelayed(scrollerTask,newCheck);
    }
  }
;
}

Fixed version (ground truth):
private void init(){
  scrollerTask=new Runnable(){
    @Override public void run(){
      int newPosition=getScrollX();
      if (initialPosition - newPosition == 0) {
        if (mOnScrollChangedListener != null) {
          mOnScrollChangedListener.onScrollStopped(getScrollX(),getScrollY());
        }
      }
 else {
        initialPosition=getScrollX();
        ObservableHorizontalScrollView.this.postDelayed(scrollerTask,newCheck);
      }
    }
  }
;
}
Program: 62760
Project: 62760
Buggy source:
@Override protected void onLayout(boolean changed,int left,int top,int right,int bottom){
  super.onLayout(changed,left,top,right,bottom);
  if (changed) {
    final int width=getWidth();
    final ViewGroup.LayoutParams leftParams=mLeftSpacer.getLayoutParams();
    leftParams.width=width / 2;
    mLeftSpacer.setLayoutParams(leftParams);
    final ViewGroup.LayoutParams rulerViewParams=lineRulerView.getLayoutParams();
    rulerViewParams.width=(int)(width * viewMultipleSize);
    lineRulerView.setLayoutParams(rulerViewParams);
    lineRulerView.invalidate();
    final ViewGroup.LayoutParams rightParams=mRightSpacer.getLayoutParams();
    rightParams.width=width / 2;
    mRightSpacer.setLayoutParams(rightParams);
    calculateRulerStrokePath();
    invalidate();
  }
}

Fixed version (ground truth):
@Override protected void onLayout(boolean changed,int left,int top,int right,int bottom){
  super.onLayout(changed,left,top,right,bottom);
  if (changed) {
    final int width=getWidth();
    final ViewGroup.LayoutParams leftParams=mLeftSpacer.getLayoutParams();
    leftParams.width=width / 2;
    mLeftSpacer.setLayoutParams(leftParams);
    final ViewGroup.LayoutParams rulerViewParams=mRulerView.getLayoutParams();
    rulerViewParams.width=(int)(width * viewMultipleSize);
    mRulerView.setLayoutParams(rulerViewParams);
    mRulerView.invalidate();
    final ViewGroup.LayoutParams rightParams=mRightSpacer.getLayoutParams();
    rightParams.width=width / 2;
    mRightSpacer.setLayoutParams(rightParams);
    calculateRulerStrokePath();
    invalidate();
  }
}
Program: 62761
Project: 62761
Buggy source:
private void prepareRuler(final Context context){
  final LinearLayout container=new LinearLayout(context);
  mHorizontalScrollView.addView(container);
  mLeftSpacer=new View(context);
  mRightSpacer=new View(context);
  lineRulerView=new LineRulerView(context);
  container.addView(lineRulerView);
  container.addView(mLeftSpacer,0);
  container.addView(mRightSpacer);
}

Fixed version (ground truth):
private void prepareRuler(final Context context){
  final LinearLayout container=new LinearLayout(context);
  mHorizontalScrollView.addView(container);
  mLeftSpacer=new View(context);
  mRightSpacer=new View(context);
  mRulerView=new RulerView(context);
  container.addView(mRulerView);
  container.addView(mLeftSpacer,0);
  container.addView(mRightSpacer);
}
Program: 62762
Project: 62762
Buggy source:
public void setValueTypeMultiple(int valueTypeMultiple){
  this.valueMultiple=valueTypeMultiple;
  lineRulerView.setMultipleTypeValue(valueTypeMultiple);
}

Fixed version (ground truth):
public void setValueTypeMultiple(int valueTypeMultiple){
  this.valueMultiple=valueTypeMultiple;
  mRulerView.setMultipleTypeValue(valueTypeMultiple);
}
Program: 62763
Project: 62763
Buggy source:
@SuppressLint("String_Node_Str") private void addScrollbar(final Context context){
  mHorizontalScrollView=new ObservableHorizontalScrollView(context);
  mHorizontalScrollView.setHorizontalScrollBarEnabled(false);
  addView(mHorizontalScrollView);
  mHorizontalScrollView.setOnTouchListener((view,motionEvent) -> {
    if (motionEvent.getAction() == MotionEvent.ACTION_UP) {
      mHorizontalScrollView.startScrollerTask();
    }
    return false;
  }
);
}

Fixed version (ground truth):
@SuppressLint("String_Node_Str") private void addScrollbar(final Context context){
  mHorizontalScrollView=new ObservableHorizontalScrollView(context);
  mHorizontalScrollView.setHorizontalScrollBarEnabled(false);
  addView(mHorizontalScrollView);
  mHorizontalScrollView.setOnTouchListener(new OnTouchListener(){
    @Override public boolean onTouch(    View v,    MotionEvent event){
      if (event.getAction() == MotionEvent.ACTION_UP) {
        mHorizontalScrollView.startScrollerTask();
      }
      return false;
    }
  }
);
}
Program: 62764
Project: 62764
Buggy source:
/** 
 * Scroll the ruler to the given value.
 */
public synchronized void scrollToValue(float value){
  mHorizontalScrollView.postDelayed(() -> {
    float oneValue=mHorizontalScrollView.getWidth() * viewMultipleSize / (maxValue - minValue);
    float valueWidth=oneValue * (value - minValue);
    mHorizontalScrollView.smoothScrollBy(Math.round(valueWidth),0);
  }
,400);
}

Fixed version (ground truth):
/** 
 * Scroll the ruler to the given value.
 */
public synchronized void scrollToValue(final float value){
  mHorizontalScrollView.postDelayed(new Runnable(){
    @Override public void run(){
      float oneValue=mHorizontalScrollView.getWidth() * viewMultipleSize / (maxValue - minValue);
      float valueWidth=oneValue * (value - minValue);
      mHorizontalScrollView.smoothScrollBy(Math.round(valueWidth),0);
    }
  }
,400);
}
Program: 62765
Project: 62765
Buggy source:
public void setMinMaxValue(float minValue,float maxValue,@SuppressWarnings("String_Node_Str") int valueMultiple){
  this.minValue=minValue;
  this.maxValue=maxValue;
  this.valueMultiple=valueMultiple;
  lineRulerView.setMaxValue(this.maxValue);
  lineRulerView.setMinValue(this.minValue);
  lineRulerView.setValueMultiple(this.valueMultiple);
}

Fixed version (ground truth):
public void setMinMaxValue(float minValue,float maxValue,@SuppressWarnings("String_Node_Str") int valueMultiple){
  this.minValue=minValue;
  this.maxValue=maxValue;
  this.valueMultiple=valueMultiple;
  mRulerView.setMaxValue(this.maxValue);
  mRulerView.setMinValue(this.minValue);
  mRulerView.setValueMultiple(this.valueMultiple);
}
Program: 62766
Project: 62766
Buggy source:
@Override @SuppressWarnings("String_Node_Str") public void onFragmentStarted(FragmentManager fm,Fragment fragment){
  if (multiInstance) {
    if (isSameInstance(fragment)) {
      presenter.onViewUp((V)fragment);
    }
  }
 else   if (cls.isInstance(fragment)) {
    presenter.onViewUp((V)fragment);
  }
}

Fixed version (ground truth):
@Override @SuppressWarnings("String_Node_Str") public void onFragmentStarted(FragmentManager fm,Fragment fragment){
  if (onViewUpCalled)   return;
  if (cls.isInstance(fragment) && isSameInstance(fragment)) {
    presenter.onViewUp((V)fragment);
    onViewDownCalled=false;
    onViewUpCalled=true;
  }
}
Program: 62767
Project: 62767
Buggy source:
@Override public void onFragmentStopped(FragmentManager fm,Fragment fragment){
  if (multiInstance) {
    if (isSameInstance(fragment)) {
      presenter.onViewDown();
    }
  }
 else   if (cls.isInstance(fragment)) {
    presenter.onViewDown();
  }
}

Fixed version (ground truth):
@Override public void onFragmentStopped(FragmentManager fm,Fragment fragment){
  if (onViewDownCalled)   return;
  if (cls.isInstance(fragment) && isSameInstance(fragment)) {
    presenter.onViewDown();
    onViewDownCalled=true;
    onViewUpCalled=false;
  }
}
Program: 62768
Project: 62768
Buggy source:
private void destroy(@NonNull Fragment fragment){
  FragmentActivity activity=fragment.getActivity();
  if (activity == null || !activity.isChangingConfigurations()) {
    FragmentManager fragmentManager=fragment.getFragmentManager();
    if (fragmentManager != null) {
      fragmentManager.unregisterFragmentLifecycleCallbacks(this);
    }
    presenter.onDestroy();
    if (listener != null) {
      listener.onDestroy(id);
    }
    presenter=null;
  }
}

Fixed version (ground truth):
private void destroy(Fragment fragment){
  if (!fragment.getActivity().isChangingConfigurations()) {
    fragment.getFragmentManager().unregisterFragmentLifecycleCallbacks(this);
    presenter.onDestroy();
    if (listener != null) {
      listener.onDestroy(id);
    }
    presenter=null;
    onDestroyCalled=true;
  }
}
Program: 62769
Project: 62769
Buggy source:
@Override public void onFragmentDestroyed(FragmentManager fm,Fragment fragment){
  if (multiInstance) {
    if (isSameInstance(fragment)) {
      destroy(fragment);
    }
  }
 else   if (cls.isInstance(fragment)) {
    destroy(fragment);
  }
}

Fixed version (ground truth):
@Override public void onFragmentDestroyed(FragmentManager fm,Fragment fragment){
  if (onDestroyCalled)   return;
  if (cls.isInstance(fragment) && isSameInstance(fragment)) {
    destroy(fragment);
  }
}
Program: 62770
Project: 62770
Buggy source:
private boolean isSameInstance(@NonNull Object view){
  final int id=getId(view);
  return id != -1 && id == this.id;
}

Fixed version (ground truth):
private boolean isSameInstance(Object view){
  final int id=getId(view);
  return id == this.id;
}
Program: 62771
Project: 62771
Buggy source:
public SlickDelegateFragment(P presenter,Class cls,int id){
  if (presenter == null) {
    throw new IllegalStateException("String_Node_Str");
  }
  this.presenter=presenter;
  this.cls=cls;
  this.id=id;
  if (id != -1)   multiInstance=true;
}

Fixed version (ground truth):
public SlickDelegateFragment(P presenter,Class cls,int id){
  if (presenter == null) {
    throw new IllegalStateException("String_Node_Str");
  }
  this.presenter=presenter;
  this.cls=cls;
  this.id=id;
}
Program: 62772
Project: 62772
Buggy source:
@Override protected void onDestroy(){
  super.onDestroy();
  customView1.onDestroy();
  ViewPresenter_Slick.onDestroy(view2UniqueId,this);
}

Fixed version (ground truth):
@Override protected void onDestroy(){
  super.onDestroy();
  customView1.onBind(customView2.getUniqueId());
  ViewPresenter_Slick.onDestroy(view2UniqueId,this);
}
Program: 62773
Project: 62773
Buggy source:
@Override public String getUniqueId(){
  return id=(id != null ? id : UUID.randomUUID().toString());
}

Fixed version (ground truth):
@NonNull @Override public String getUniqueId(){
  return id=(id != null ? id : UUID.randomUUID().toString());
}
Program: 62774
Project: 62774
Buggy source:
@Override protected void onDestroy(){
  super.onDestroy();
  customView.onDestroy();
}

Fixed version (ground truth):
@Override protected void onDestroy(){
  super.onDestroy();
  customView.onBind("String_Node_Str");
}
Program: 62775
Project: 62775
Buggy source:
@Override public String getUniqueId(){
  return id=id != null ? id : UUID.randomUUID().toString();
}

Fixed version (ground truth):
@NonNull @Override public String getUniqueId(){
  return id=id != null ? id : UUID.randomUUID().toString();
}
Program: 62776
Project: 62776
Buggy source:
@Override public String getUniqueId(){
  return id=id != null ? id : UUID.randomUUID().toString();
}

Fixed version (ground truth):
@NonNull @Override public String getUniqueId(){
  return id=id != null ? id : UUID.randomUUID().toString();
}
Program: 62777
Project: 62777
Buggy source:
String getUniqueId();

Fixed version (ground truth):
@NonNull String getUniqueId();
Program: 62778
Project: 62778
Buggy source:
@Override protected void onAttachedToWindow(){
  super.onAttachedToWindow();
  ExamplePresenter_Slick.bind(this);
  ExamplePresenter_Slick.onAttach(this);
}

Fixed version (ground truth):
@Override protected void onAttachedToWindow(){
  super.onAttachedToWindow();
  ExamplePresenter_Slick.onAttach(this);
}
Program: 62779
Project: 62779
Buggy source:
public static <T extends DaggerCustomView & ExampleView & OnDestroyListener>void bind(T daggerCustomView){
}

Fixed version (ground truth):
public static <T extends DaggerCustomView & ExampleView & SlickLifecycleListener>void bind(T daggerCustomView){
}
Program: 62780
Project: 62780
Buggy source:
public static <T extends View & ExampleView & OnDestroyListener>void onAttach(T daggerCustomView){
  hostInstance.delegates.get(SlickDelegateView.getId(daggerCustomView)).onAttach(daggerCustomView);
}

Fixed version (ground truth):
public static <T extends View & ExampleView & SlickLifecycleListener>void onAttach(T daggerCustomView){
  hostInstance.delegates.get(SlickDelegateView.getId(daggerCustomView)).onAttach(daggerCustomView);
}
Program: 62781
Project: 62781
Buggy source:
public static <T extends View & ExampleView & OnDestroyListener>void onDetach(T daggerCustomView){
  if (hostInstance == null || hostInstance.delegates.get(SlickDelegateView.getId(daggerCustomView)) == null)   return;
  hostInstance.delegates.get(SlickDelegateView.getId(daggerCustomView)).onDetach(daggerCustomView);
}

Fixed version (ground truth):
public static <T extends View & ExampleView & SlickLifecycleListener>void onDetach(T daggerCustomView){
  if (hostInstance == null || hostInstance.delegates.get(SlickDelegateView.getId(daggerCustomView)) == null)   return;
  hostInstance.delegates.get(SlickDelegateView.getId(daggerCustomView)).onDetach(daggerCustomView);
}