nus-yam/ex-repair huggingface dataset:
Program: 60416
Project: 60416
Buggy source:
public void testMissingDependency(){
  try {
    Guice.createInjector(new AbstractModule(){
      public void configure(){
        bind(NeedsRunnable.class);
      }
    }
);
  }
 catch (  CreationException e) {
    assertEquals(1,e.getErrorMessages().size());
    assertContains(e.getMessage(),"String_Node_Str","String_Node_Str" + NeedsRunnable.class.getName(),"String_Node_Str","String_Node_Str" + getClass().getName(),"String_Node_Str");
  }
}

Fixed version (ground truth):
public void testMissingDependency(){
  try {
    Guice.createInjector(new AbstractModule(){
      @Override public void configure(){
        bind(NeedsRunnable.class);
      }
    }
);
  }
 catch (  CreationException e) {
    assertEquals(1,e.getErrorMessages().size());
    assertContains(e.getMessage(),"String_Node_Str","String_Node_Str" + NeedsRunnable.class.getName(),"String_Node_Str","String_Node_Str" + getClass().getName(),"String_Node_Str");
  }
}
Program: 60417
Project: 60417
Buggy source:
protected void configure(){
  bind(AbstractModule.class).annotatedWith(red).toProvider(Providers.<AbstractModule>of(null));
  bind(Binder.class).annotatedWith(red).toProvider(Providers.<Binder>of(null));
  bind(Binding.class).annotatedWith(red).toProvider(Providers.<Binding>of(null));
  bind(Injector.class).annotatedWith(red).toProvider(Providers.<Injector>of(null));
  bind(Key.class).annotatedWith(red).toProvider(Providers.<Key>of(null));
  bind(Module.class).annotatedWith(red).toProvider(Providers.<Module>of(null));
  bind(Provider.class).annotatedWith(red).toProvider(Providers.<Provider>of(null));
  bind(Scope.class).annotatedWith(red).toProvider(Providers.<Scope>of(null));
  bind(TypeLiteral.class).annotatedWith(red).toProvider(Providers.<TypeLiteral>of(null));
  bind(new TypeLiteral<Key<String>>(){
  }
).toProvider(Providers.<Key<String>>of(null));
}

Fixed version (ground truth):
@Override protected void configure(){
  bind(AbstractModule.class).annotatedWith(red).toProvider(Providers.<AbstractModule>of(null));
  bind(Binder.class).annotatedWith(red).toProvider(Providers.<Binder>of(null));
  bind(Binding.class).annotatedWith(red).toProvider(Providers.<Binding>of(null));
  bind(Injector.class).annotatedWith(red).toProvider(Providers.<Injector>of(null));
  bind(Key.class).annotatedWith(red).toProvider(Providers.<Key>of(null));
  bind(Module.class).annotatedWith(red).toProvider(Providers.<Module>of(null));
  bind(Provider.class).annotatedWith(red).toProvider(Providers.<Provider>of(null));
  bind(Scope.class).annotatedWith(red).toProvider(Providers.<Scope>of(null));
  bind(TypeLiteral.class).annotatedWith(red).toProvider(Providers.<TypeLiteral>of(null));
  bind(new TypeLiteral<Key<String>>(){
  }
).toProvider(Providers.<Key<String>>of(null));
}
Program: 60418
Project: 60418
Buggy source:
public void testMissingBindings(){
  try {
    Guice.createInjector(new AbstractModule(){
      public void configure(){
        getProvider(Runnable.class);
        bind(Comparator.class);
        requireBinding(Key.get(new TypeLiteral<Callable<String>>(){
        }
));
        bind(Date.class).annotatedWith(Names.named("String_Node_Str"));
      }
    }
);
  }
 catch (  CreationException e) {
    assertEquals(4,e.getErrorMessages().size());
    assertContains(e.getMessage(),"String_Node_Str","String_Node_Str" + getClass().getName(),"String_Node_Str" + Comparator.class.getName() + "String_Node_Str","String_Node_Str" + getClass().getName(),"String_Node_Str","String_Node_Str" + getClass().getName(),"String_Node_Str" + Named.class.getName() + "String_Node_Str","String_Node_Str" + getClass().getName());
  }
}

Fixed version (ground truth):
public void testMissingBindings(){
  try {
    Guice.createInjector(new AbstractModule(){
      @Override public void configure(){
        getProvider(Runnable.class);
        bind(Comparator.class);
        requireBinding(Key.get(new TypeLiteral<Callable<String>>(){
        }
));
        bind(Date.class).annotatedWith(Names.named("String_Node_Str"));
      }
    }
);
  }
 catch (  CreationException e) {
    assertEquals(4,e.getErrorMessages().size());
    assertContains(e.getMessage(),"String_Node_Str","String_Node_Str" + getClass().getName(),"String_Node_Str" + Comparator.class.getName() + "String_Node_Str","String_Node_Str" + getClass().getName(),"String_Node_Str","String_Node_Str" + getClass().getName(),"String_Node_Str" + Named.class.getName() + "String_Node_Str","String_Node_Str" + getClass().getName());
  }
}
Program: 60419
Project: 60419
Buggy source:
/** 
 * Untargetted bindings should follow @ImplementedBy and @ProvidedBy annotations if they exist. Otherwise the class should be constructed directly.
 */
public void testUntargettedBinding(){
  Injector injector=Guice.createInjector(new AbstractModule(){
    protected void configure(){
      bind(HasProvidedBy1.class);
      bind(HasImplementedBy1.class);
      bind(HasProvidedBy2.class);
      bind(HasImplementedBy2.class);
      bind(JustAClass.class);
    }
  }
);
  assertNotNull(injector.getInstance(HasProvidedBy1.class));
  assertNotNull(injector.getInstance(HasImplementedBy1.class));
  assertNotSame(HasProvidedBy2.class,injector.getInstance(HasProvidedBy2.class).getClass());
  assertSame(ExtendsHasImplementedBy2.class,injector.getInstance(HasImplementedBy2.class).getClass());
  assertSame(JustAClass.class,injector.getInstance(JustAClass.class).getClass());
}

Fixed version (ground truth):
/** 
 * Untargetted bindings should follow @ImplementedBy and @ProvidedBy annotations if they exist. Otherwise the class should be constructed directly.
 */
public void testUntargettedBinding(){
  Injector injector=Guice.createInjector(new AbstractModule(){
    @Override protected void configure(){
      bind(HasProvidedBy1.class);
      bind(HasImplementedBy1.class);
      bind(HasProvidedBy2.class);
      bind(HasImplementedBy2.class);
      bind(JustAClass.class);
    }
  }
);
  assertNotNull(injector.getInstance(HasProvidedBy1.class));
  assertNotNull(injector.getInstance(HasImplementedBy1.class));
  assertNotSame(HasProvidedBy2.class,injector.getInstance(HasProvidedBy2.class).getClass());
  assertSame(ExtendsHasImplementedBy2.class,injector.getInstance(HasImplementedBy2.class).getClass());
  assertSame(JustAClass.class,injector.getInstance(JustAClass.class).getClass());
}
Program: 60420
Project: 60420
Buggy source:
public void testUserReportedError(){
  final Message message=new Message(getClass(),"String_Node_Str");
  try {
    Guice.createInjector(new AbstractModule(){
      protected void configure(){
        addError(message);
      }
    }
);
    fail();
  }
 catch (  CreationException expected) {
    assertSame(message,Iterables.getOnlyElement(expected.getErrorMessages()));
  }
}

Fixed version (ground truth):
public void testUserReportedError(){
  final Message message=new Message(getClass(),"String_Node_Str");
  try {
    Guice.createInjector(new AbstractModule(){
      @Override protected void configure(){
        addError(message);
      }
    }
);
    fail();
  }
 catch (  CreationException expected) {
    assertSame(message,Iterables.getOnlyElement(expected.getErrorMessages()));
  }
}
Program: 60421
Project: 60421
Buggy source:
public void testBindingOverridesImplementedBy(){
  Injector injector=Guice.createInjector(new AbstractModule(){
    protected void configure(){
      bind(I.class).to(AlternateImpl.class);
    }
  }
);
  assertEquals(AlternateImpl.class,injector.getInstance(I.class).getClass());
}

Fixed version (ground truth):
public void testBindingOverridesImplementedBy(){
  Injector injector=Guice.createInjector(new AbstractModule(){
    @Override protected void configure(){
      bind(I.class).to(AlternateImpl.class);
    }
  }
);
  assertEquals(AlternateImpl.class,injector.getInstance(I.class).getClass());
}
Program: 60422
Project: 60422
Buggy source:
@SuppressWarnings("String_Node_Str") private void assertFailure(Injector injector,Class clazz){
  try {
    injector.getBinding(clazz);
    fail("String_Node_Str" + clazz);
  }
 catch (  ConfigurationException expected) {
    List<Object> sources=Iterables.getOnlyElement(expected.getErrorMessages()).getSources();
    assertEquals(Key.get(clazz).toString(),sources.get(0).toString());
    Asserts.assertContains(sources.get(sources.size() - 1).toString(),Key.get(InvalidInterface.class).toString());
  }
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") private void assertFailure(Injector injector,Class clazz){
  try {
    injector.getBinding(clazz);
    fail("String_Node_Str" + clazz);
  }
 catch (  ConfigurationException expected) {
    Message msg=Iterables.getOnlyElement(expected.getErrorMessages());
    assertEquals("String_Node_Str" + InvalidInterface.class.getName() + "String_Node_Str",msg.getMessage());
    List<Object> sources=msg.getSources();
    assertEquals(Key.get(clazz).toString(),sources.get(0).toString());
    Asserts.assertContains(sources.get(sources.size() - 1).toString(),Key.get(InvalidInterface.class).toString());
  }
}
Program: 60423
Project: 60423
Buggy source:
BoundProviderFactory(InjectorImpl injector,Key<? extends javax.inject.Provider<? extends T>> providerKey,Object source){
  this.injector=injector;
  this.providerKey=providerKey;
  this.source=source;
}

Fixed version (ground truth):
BoundProviderFactory(InjectorImpl injector,Key<? extends javax.inject.Provider<? extends T>> providerKey,Object source,boolean allowProxy){
  super(source,allowProxy);
  this.injector=injector;
  this.providerKey=providerKey;
}
Program: 60424
Project: 60424
Buggy source:
public T get(Errors errors,InternalContext context,Dependency<?> dependency,boolean linked) throws ErrorsException {
  errors=errors.withSource(providerKey);
  javax.inject.Provider<? extends T> provider=providerFactory.get(errors,context,dependency,true);
  try {
    return errors.checkForNull(provider.get(),source,dependency);
  }
 catch (  RuntimeException userException) {
    throw errors.errorInProvider(userException).toException();
  }
}

Fixed version (ground truth):
public T get(Errors errors,InternalContext context,Dependency<?> dependency,boolean linked) throws ErrorsException {
  errors=errors.withSource(providerKey);
  javax.inject.Provider<? extends T> provider=providerFactory.get(errors,context,dependency,true);
  try {
    return circularGet(provider,errors,context,dependency,linked);
  }
 catch (  RuntimeException userException) {
    throw errors.errorInProvider(userException).toException();
  }
}
Program: 60426
Project: 60426
Buggy source:
public T get(Errors errors,InternalContext context,Dependency<?> dependency,boolean linked) throws ErrorsException {
  try {
    return errors.checkForNull(initializable.get(errors).get(),source,dependency);
  }
 catch (  RuntimeException userException) {
    throw errors.withSource(source).errorInProvider(userException).toException();
  }
}

Fixed version (ground truth):
public T get(Errors errors,InternalContext context,Dependency<?> dependency,boolean linked) throws ErrorsException {
  try {
    return errors.checkForNull(provider.get(),source,dependency);
  }
 catch (  RuntimeException userException) {
    throw errors.withSource(source).errorInProvider(userException).toException();
  }
}
Program: 60427
Project: 60427
Buggy source:
@Override public String toString(){
  return initializable.toString();
}

Fixed version (ground truth):
@Override public String toString(){
  return provider.toString();
}
Program: 60428
Project: 60428
Buggy source:
public InternalFactoryToProviderAdapter(Initializable<Provider<? extends T>> initializable,Object source){
  this.initializable=checkNotNull(initializable,"String_Node_Str");
  this.source=checkNotNull(source,"String_Node_Str");
}

Fixed version (ground truth):
public InternalFactoryToProviderAdapter(Provider<? extends T> provider,Object source){
  this.provider=checkNotNull(provider,"String_Node_Str");
  this.source=checkNotNull(source,"String_Node_Str");
}
Program: 60429
Project: 60429
Buggy source:
/** 
 * Scopes an internal factory. 
 */
static <T>InternalFactory<? extends T> scope(Key<T> key,InjectorImpl injector,InternalFactory<? extends T> creator,Object source,Scoping scoping){
  if (scoping.isNoScope()) {
    return creator;
  }
  Scope scope=scoping.getScopeInstance();
  Provider<T> scoped=scope.scope(key,new ProviderToInternalFactoryAdapter<T>(injector,creator));
  return new InternalFactoryToProviderAdapter<T>(Initializables.<Provider<? extends T>>of(scoped),source);
}

Fixed version (ground truth):
/** 
 * Scopes an internal factory. 
 */
static <T>InternalFactory<? extends T> scope(Key<T> key,InjectorImpl injector,InternalFactory<? extends T> creator,Object source,Scoping scoping){
  if (scoping.isNoScope()) {
    return creator;
  }
  Scope scope=scoping.getScopeInstance();
  Provider<T> scoped=scope.scope(key,new ProviderToInternalFactoryAdapter<T>(injector,creator));
  return new InternalFactoryToProviderAdapter<T>(scoped,source);
}
Program: 60430
Project: 60430
Buggy source:
/** 
 * Creates a child injector that binds the args, and returns the binding for the method's result.
 */
public Binding<?> getBindingFromNewInjector(final Method method,final Object[] args,final AssistData data){
  checkState(injector != null,"String_Node_Str");
  final Key<?> returnType=data.returnType;
  final Key<?> assistedReturnType=Key.get(returnType.getTypeLiteral(),Assisted.class);
  Module assistedModule=new AbstractModule(){
    @Override @SuppressWarnings("String_Node_Str") protected void configure(){
      Binder binder=binder().withSource(method);
      int p=0;
      if (!data.optimized) {
        for (        Key<?> paramKey : data.paramTypes) {
          binder.bind((Key)paramKey).toProvider(Providers.of(args[p++]));
        }
      }
 else {
        for (        Key<?> paramKey : data.paramTypes) {
          binder.bind((Key)paramKey).toProvider(data.providers.get(p++));
        }
      }
      Constructor constructor=data.constructor;
      if (constructor != null) {
        binder.bind(assistedReturnType).toConstructor(constructor,(TypeLiteral)data.implementationType);
      }
    }
  }
;
  Injector forCreate=injector.createChildInjector(assistedModule);
  Binding binding=forCreate.getBinding(assistedReturnType);
  if (data.optimized) {
    data.cachedBinding=binding;
  }
  return binding;
}

Fixed version (ground truth):
/** 
 * Creates a child injector that binds the args, and returns the binding for the method's result.
 */
public Binding<?> getBindingFromNewInjector(final Method method,final Object[] args,final AssistData data){
  checkState(injector != null,"String_Node_Str");
  final Key<?> returnType=data.returnType;
  final Key<?> assistedReturnType=Key.get(returnType.getTypeLiteral(),Assisted.class);
  Module assistedModule=new AbstractModule(){
    @Override @SuppressWarnings("String_Node_Str") protected void configure(){
      Binder binder=binder().withSource(method);
      int p=0;
      if (!data.optimized) {
        for (        Key<?> paramKey : data.paramTypes) {
          binder.bind((Key)paramKey).toProvider(Providers.of(args[p++]));
        }
      }
 else {
        for (        Key<?> paramKey : data.paramTypes) {
          binder.bind((Key)paramKey).toProvider(data.providers.get(p++));
        }
      }
      Constructor constructor=data.constructor;
      if (constructor != null) {
        binder.bind(assistedReturnType).toConstructor(constructor,(TypeLiteral)data.implementationType).in(Scopes.NO_SCOPE);
      }
    }
  }
;
  Injector forCreate=injector.createChildInjector(assistedModule);
  Binding binding=forCreate.getBinding(assistedReturnType);
  if (data.optimized) {
    data.cachedBinding=binding;
  }
  return binding;
}
Program: 60431
Project: 60431
Buggy source:
@Override @SuppressWarnings("String_Node_Str") protected void configure(){
  Binder binder=binder().withSource(method);
  int p=0;
  if (!data.optimized) {
    for (    Key<?> paramKey : data.paramTypes) {
      binder.bind((Key)paramKey).toProvider(Providers.of(args[p++]));
    }
  }
 else {
    for (    Key<?> paramKey : data.paramTypes) {
      binder.bind((Key)paramKey).toProvider(data.providers.get(p++));
    }
  }
  Constructor constructor=data.constructor;
  if (constructor != null) {
    binder.bind(assistedReturnType).toConstructor(constructor,(TypeLiteral)data.implementationType);
  }
}

Fixed version (ground truth):
@Override @SuppressWarnings("String_Node_Str") protected void configure(){
  Binder binder=binder().withSource(method);
  int p=0;
  if (!data.optimized) {
    for (    Key<?> paramKey : data.paramTypes) {
      binder.bind((Key)paramKey).toProvider(Providers.of(args[p++]));
    }
  }
 else {
    for (    Key<?> paramKey : data.paramTypes) {
      binder.bind((Key)paramKey).toProvider(data.providers.get(p++));
    }
  }
  Constructor constructor=data.constructor;
  if (constructor != null) {
    binder.bind(assistedReturnType).toConstructor(constructor,(TypeLiteral)data.implementationType).in(Scopes.NO_SCOPE);
  }
}
Program: 60432
Project: 60432
Buggy source:
Hidden create();

Fixed version (ground truth):
AssistedSingleton create(String string);
Program: 60433
Project: 60433
Buggy source:
@Override protected void configure(){
  install(new FactoryModuleBuilder().implement(Hidden.class,HiddenImpl.class).build(NotHidden.class));
}

Fixed version (ground truth):
@Override protected void configure(){
  install(new FactoryModuleBuilder().build(SingletonFactory.class));
}
Program: 60434
Project: 60434
Buggy source:
@Override public Boolean visit(PrivateElements privateElements){
  for (  Key<?> key : privateElements.getExposedKeys()) {
    bindExposed(privateElements,key);
  }
  return false;
}

Fixed version (ground truth):
@Override public Boolean visit(PrivateElements privateElements){
  if (phase == Phase.PASS_TWO) {
    return false;
  }
  for (  Key<?> key : privateElements.getExposedKeys()) {
    bindExposed(privateElements,key);
  }
  return false;
}
Program: 60436
Project: 60436
Buggy source:
/** 
 * Returns a module that installs   {@literal @}{@link CheckedProvides} methods.
 * @since 3.0
 */
public static Module forModule(Module module){
  return ThrowingProviderMethodsModule.forModule(module);
}

Fixed version (ground truth):
/** 
 * Returns a module that installs   {@literal @}{@link CheckedProvides} methods.
 * @since 3.0
 */
public static Module forModule(Module module){
  return CheckedProviderMethodsModule.forModule(module);
}
Program: 60438
Project: 60438
Buggy source:
ScopedBindingBuilder toProviderMethod(ThrowingProviderMethod<?> target){
  Key<ThrowingProviderMethod> targetKey=Key.get(ThrowingProviderMethod.class,UniqueAnnotations.create());
  binder.bind(targetKey).toInstance(target);
  return toInternal(targetKey);
}

Fixed version (ground truth):
ScopedBindingBuilder toProviderMethod(CheckedProviderMethod<?> target){
  Key<CheckedProviderMethod> targetKey=Key.get(CheckedProviderMethod.class,UniqueAnnotations.create());
  binder.bind(targetKey).toInstance(target);
  return toInternal(targetKey);
}
Program: 60439
Project: 60439
Buggy source:
/** 
 * Returns the exception type declared to be thrown by the get method of  {@code interfaceType}.
 */
@SuppressWarnings({"String_Node_Str"}) private List<Class<? extends Throwable>> getExceptionType(Class<P> interfaceType){
  try {
    Method getMethod=interfaceType.getMethod("String_Node_Str");
    List<TypeLiteral<?>> exceptionLiterals=TypeLiteral.get(interfaceType).getExceptionTypes(getMethod);
    List<Class<? extends Throwable>> results=Lists.newArrayList();
    for (    TypeLiteral<?> exLiteral : exceptionLiterals) {
      results.add(exLiteral.getRawType().asSubclass(Throwable.class));
    }
    return results;
  }
 catch (  SecurityException e) {
    throw new IllegalStateException("String_Node_Str",e);
  }
catch (  NoSuchMethodException e) {
    throw new IllegalStateException("String_Node_Str",e);
  }
}

Fixed version (ground truth):
/** 
 * Returns the exception type declared to be thrown by the get method of  {@code interfaceType}.
 */
private List<Class<? extends Throwable>> getExceptionType(Class<P> interfaceType){
  try {
    Method getMethod=interfaceType.getMethod("String_Node_Str");
    List<TypeLiteral<?>> exceptionLiterals=TypeLiteral.get(interfaceType).getExceptionTypes(getMethod);
    List<Class<? extends Throwable>> results=Lists.newArrayList();
    for (    TypeLiteral<?> exLiteral : exceptionLiterals) {
      results.add(exLiteral.getRawType().asSubclass(Throwable.class));
    }
    return results;
  }
 catch (  SecurityException e) {
    throw new IllegalStateException("String_Node_Str",e);
  }
catch (  NoSuchMethodException e) {
    throw new IllegalStateException("String_Node_Str",e);
  }
}
Program: 60440
Project: 60440
Buggy source:
private void bindQueryNamedParameters(Query jpaQuery,JpaFinderProxy.FinderDescriptor descriptor,Object[] arguments){
  for (int i=0; i < arguments.length; i++) {
    Object argument=arguments[i];
    Object annotation=descriptor.parameterAnnotations[i];
    if (null == annotation) {
      continue;
    }
 else     if (annotation instanceof Named) {
      Named named=(Named)annotation;
      jpaQuery.setParameter(named.value(),argument);
    }
 else     if (annotation instanceof FirstResult) {
      jpaQuery.setFirstResult((Integer)argument);
    }
 else     if (annotation instanceof MaxResults) {
      jpaQuery.setMaxResults((Integer)argument);
    }
  }
}

Fixed version (ground truth):
private void bindQueryNamedParameters(Query jpaQuery,JpaFinderProxy.FinderDescriptor descriptor,Object[] arguments){
  for (int i=0; i < arguments.length; i++) {
    Object argument=arguments[i];
    Object annotation=descriptor.parameterAnnotations[i];
    if (null == annotation) {
      continue;
    }
 else     if (annotation instanceof Named) {
      Named named=(Named)annotation;
      jpaQuery.setParameter(named.value(),argument);
    }
 else     if (annotation instanceof javax.inject.Named) {
      javax.inject.Named named=(javax.inject.Named)annotation;
      jpaQuery.setParameter(named.value(),argument);
    }
 else     if (annotation instanceof FirstResult) {
      jpaQuery.setFirstResult((Integer)argument);
    }
 else     if (annotation instanceof MaxResults) {
      jpaQuery.setMaxResults((Integer)argument);
    }
  }
}
Program: 60442
Project: 60442
Buggy source:
/** 
 * Returns a Guice-friendly   {@code com.google.inject.Provider} for the givenJSR-330  {@code javax.inject.Provider}. The converse method is unnecessary, since Guice providers directly implement the JSR-330 interface.
 * @since 3.0
 */
public static <T>Provider<T> guicify(javax.inject.Provider<T> provider){
  if (provider instanceof Provider) {
    return (Provider<T>)provider;
  }
  final javax.inject.Provider<T> delegate=checkNotNull(provider,"String_Node_Str");
  return new Provider<T>(){
    public T get(){
      return delegate.get();
    }
    @Override public String toString(){
      return "String_Node_Str" + delegate + "String_Node_Str";
    }
  }
;
}

Fixed version (ground truth):
/** 
 * Returns a Guice-friendly   {@code com.google.inject.Provider} for the givenJSR-330  {@code javax.inject.Provider}. The converse method is unnecessary, since Guice providers directly implement the JSR-330 interface.
 * @since 3.0
 */
public static <T>Provider<T> guicify(javax.inject.Provider<T> provider){
  if (provider instanceof Provider) {
    return (Provider<T>)provider;
  }
  final javax.inject.Provider<T> delegate=checkNotNull(provider,"String_Node_Str");
  Set<InjectionPoint> injectionPoints=InjectionPoint.forInstanceMethodsAndFields(provider.getClass());
  if (injectionPoints.isEmpty()) {
    return new Provider<T>(){
      public T get(){
        return delegate.get();
      }
      @Override public String toString(){
        return "String_Node_Str" + delegate + "String_Node_Str";
      }
    }
;
  }
 else {
    Set<Dependency<?>> mutableDeps=Sets.newHashSet();
    for (    InjectionPoint ip : injectionPoints) {
      mutableDeps.addAll(ip.getDependencies());
    }
    final Set<Dependency<?>> dependencies=ImmutableSet.copyOf(mutableDeps);
    return new ProviderWithDependencies<T>(){
      @SuppressWarnings("String_Node_Str") @Inject void initialize(      Injector injector){
        injector.injectMembers(delegate);
      }
      public Set<Dependency<?>> getDependencies(){
        return dependencies;
      }
      public T get(){
        return delegate.get();
      }
      @Override public String toString(){
        return "String_Node_Str" + delegate + "String_Node_Str";
      }
    }
;
  }
}
Program: 60443
Project: 60443
Buggy source:
public void testGuicify330Provider(){
  Provider<String> jsr330Provider=new Provider<String>(){
    public String get(){
      return "String_Node_Str";
    }
    @Override public String toString(){
      return "String_Node_Str";
    }
  }
;
  com.google.inject.Provider<String> guicified=Providers.guicify(jsr330Provider);
  assertEquals("String_Node_Str",guicified.toString());
  assertEquals("String_Node_Str",guicified.get());
  assertSame(guicified,Providers.guicify(guicified));
}

Fixed version (ground truth):
public void testGuicify330Provider(){
  Provider<String> jsr330Provider=new Provider<String>(){
    public String get(){
      return "String_Node_Str";
    }
    @Override public String toString(){
      return "String_Node_Str";
    }
  }
;
  com.google.inject.Provider<String> guicified=Providers.guicify(jsr330Provider);
  assertEquals("String_Node_Str",guicified.toString());
  assertEquals("String_Node_Str",guicified.get());
  assertSame(guicified,Providers.guicify(guicified));
  assertFalse(guicified instanceof HasDependencies);
}
Program: 60444
Project: 60444
Buggy source:
protected void configure(){
  bind(B.class).toProvider(BProvider.class);
  bind(B.class).annotatedWith(Names.named("String_Node_Str")).toProvider(BProvider.class);
  bind(B.class).annotatedWith(Names.named("String_Node_Str")).toProvider(Key.get(BProvider.class));
  bind(B.class).annotatedWith(Names.named("String_Node_Str")).toProvider(TypeLiteral.get(BProvider.class));
}

Fixed version (ground truth):
@Override protected void configure(){
  bind(String.class).toProvider(guicified);
  bind(int.class).toInstance(1);
  bind(double.class).toInstance(2.0d);
}
Program: 60445
Project: 60445
Buggy source:
public static Visibility forMember(Member member){
  if ((member.getModifiers() & (Modifier.PROTECTED | Modifier.PUBLIC)) == 0) {
    return SAME_PACKAGE;
  }
  Class[] parameterTypes=member instanceof Constructor ? ((Constructor)member).getParameterTypes() : ((Method)member).getParameterTypes();
  for (  Class<?> type : parameterTypes) {
    if (forType(type) == SAME_PACKAGE) {
      return SAME_PACKAGE;
    }
  }
  return PUBLIC;
}

Fixed version (ground truth):
public static Visibility forMember(Member member){
  if ((member.getModifiers() & (Modifier.PROTECTED | Modifier.PUBLIC)) == 0) {
    return SAME_PACKAGE;
  }
  Class[] parameterTypes;
  if (member instanceof Constructor) {
    parameterTypes=((Constructor)member).getParameterTypes();
  }
 else {
    Method method=(Method)member;
    if (forType(method.getReturnType()) == SAME_PACKAGE) {
      return SAME_PACKAGE;
    }
    parameterTypes=method.getParameterTypes();
  }
  for (  Class<?> type : parameterTypes) {
    if (forType(type) == SAME_PACKAGE) {
      return SAME_PACKAGE;
    }
  }
  return PUBLIC;
}
Program: 60446
Project: 60446
Buggy source:
public TestVisibilityClassLoader(){
  super(new URL[0]);
  final String[] classpath=System.getProperty("String_Node_Str").split(File.pathSeparator);
  for (  final String element : classpath) {
    try {
      addURL(new URL(element));
    }
 catch (    final MalformedURLException e1) {
      try {
        addURL(new File(element).toURI().toURL());
      }
 catch (      final MalformedURLException e2) {
        throw new RuntimeException(e1);
      }
    }
  }
}

Fixed version (ground truth):
public TestVisibilityClassLoader(boolean hideInternals){
  super(new URL[0]);
  this.hideInternals=hideInternals;
  final String[] classpath=System.getProperty("String_Node_Str").split(File.pathSeparator);
  for (  final String element : classpath) {
    try {
      addURL(new URL(element));
    }
 catch (    final MalformedURLException e1) {
      try {
        addURL(new File(element).toURI().toURL());
      }
 catch (      final MalformedURLException e2) {
        throw new RuntimeException(e1);
      }
    }
  }
}
Program: 60447
Project: 60447
Buggy source:
public Object invoke(MethodInvocation chain) throws Throwable {
  return chain.proceed() + "String_Node_Str";
}

Fixed version (ground truth):
public Object invoke(MethodInvocation chain) throws Throwable {
  return chain.proceed();
}
Program: 60448
Project: 60448
Buggy source:
/** 
 * Classic parent-delegating classloaders are meant to override findClass. However, non-delegating classloaders (as used in OSGi) instead override loadClass to provide support for "class-space" separation.
 */
@Override protected Class<?> loadClass(final String name,final boolean resolve) throws ClassNotFoundException {
synchronized (this) {
    final Class<?> clazz=findLoadedClass(name);
    if (clazz != null) {
      return clazz;
    }
  }
  if (name.startsWith("String_Node_Str")) {
    return super.loadClass(name,resolve);
  }
 else   if (!name.contains("String_Node_Str") && !name.contains("String_Node_Str")) {
    final Class<?> clazz=findClass(name);
    if (resolve) {
      resolveClass(clazz);
    }
    return clazz;
  }
  throw new ClassNotFoundException();
}

Fixed version (ground truth):
/** 
 * Classic parent-delegating classloaders are meant to override findClass. However, non-delegating classloaders (as used in OSGi) instead override loadClass to provide support for "class-space" separation.
 */
@Override protected Class<?> loadClass(final String name,final boolean resolve) throws ClassNotFoundException {
synchronized (this) {
    final Class<?> clazz=findLoadedClass(name);
    if (clazz != null) {
      return clazz;
    }
  }
  if (name.startsWith("String_Node_Str")) {
    return super.loadClass(name,resolve);
  }
 else   if (!name.contains("String_Node_Str") && !name.contains("String_Node_Str")) {
    final Class<?> clazz=findClass(name);
    if (resolve) {
      resolveClass(clazz);
    }
    return clazz;
  }
  if (hideInternals) {
    throw new ClassNotFoundException();
  }
  return super.loadClass(name,resolve);
}
Program: 60449
Project: 60449
Buggy source:
@SuppressWarnings("String_Node_Str") protected void setUp() throws Exception {
  super.setUp();
  ClassLoader testClassLoader=new TestVisibilityClassLoader();
  proxyTestClass=(Class<ProxyTest>)testClassLoader.loadClass(ProxyTest.class.getName());
  realClass=(Class<ProxyTestImpl>)testClassLoader.loadClass(ProxyTestImpl.class.getName());
  testModule=new AbstractModule(){
    public void configure(){
      bind(proxyTestClass).to(realClass);
    }
  }
;
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") protected void setUp() throws Exception {
  super.setUp();
  ClassLoader testClassLoader=new TestVisibilityClassLoader(true);
  proxyTestClass=(Class<ProxyTest>)testClassLoader.loadClass(ProxyTest.class.getName());
  realClass=(Class<ProxyTestImpl>)testClassLoader.loadClass(ProxyTestImpl.class.getName());
  testModule=new AbstractModule(){
    public void configure(){
      bind(proxyTestClass).to(realClass);
    }
  }
;
}
Program: 60450
Project: 60450
Buggy source:
/** 
 * Returns true if   {@code binding} is singleton-scoped. If the binding is a {@link com.google.inject.spi.LinkedKeyBinding linked key binding} and belongs to an injector (ie. itwas retrieved via  {@link Injector#getBinding Injector.getBinding()}), then this method will also true if the target binding is singleton-scoped.
 * @since 3.0
 */
public static boolean isSingleton(Binding<?> binding){
  do {
    boolean singleton=binding.acceptScopingVisitor(new BindingScopingVisitor<Boolean>(){
      public Boolean visitNoScoping(){
        return false;
      }
      public Boolean visitScopeAnnotation(      Class<? extends Annotation> scopeAnnotation){
        return scopeAnnotation == Singleton.class || scopeAnnotation == javax.inject.Singleton.class;
      }
      public Boolean visitScope(      Scope scope){
        return scope == Scopes.SINGLETON;
      }
      public Boolean visitEagerSingleton(){
        return true;
      }
    }
);
    if (singleton) {
      return true;
    }
    if (binding instanceof LinkedBindingImpl) {
      LinkedBindingImpl<?> linkedBinding=(LinkedBindingImpl)binding;
      Injector injector=(Injector)linkedBinding.getInjector();
      if (injector != null) {
        binding=injector.getBinding(linkedBinding.getLinkedKey());
        continue;
      }
    }
    return false;
  }
 while (true);
}

Fixed version (ground truth):
/** 
 * Returns true if   {@code binding} is singleton-scoped. If the binding is a {@link com.google.inject.spi.LinkedKeyBinding linked key binding} and belongs to an injector (ie. itwas retrieved via  {@link Injector#getBinding Injector.getBinding()}), then this method will also true if the target binding is singleton-scoped.
 * @since 3.0
 */
public static boolean isSingleton(Binding<?> binding){
  do {
    boolean singleton=binding.acceptScopingVisitor(new BindingScopingVisitor<Boolean>(){
      public Boolean visitNoScoping(){
        return false;
      }
      public Boolean visitScopeAnnotation(      Class<? extends Annotation> scopeAnnotation){
        return scopeAnnotation == Singleton.class || scopeAnnotation == javax.inject.Singleton.class;
      }
      public Boolean visitScope(      Scope scope){
        return scope == Scopes.SINGLETON;
      }
      public Boolean visitEagerSingleton(){
        return true;
      }
    }
);
    if (singleton) {
      return true;
    }
    if (binding instanceof LinkedBindingImpl) {
      LinkedBindingImpl<?> linkedBinding=(LinkedBindingImpl)binding;
      Injector injector=(Injector)linkedBinding.getInjector();
      if (injector != null) {
        binding=injector.getBinding(linkedBinding.getLinkedKey());
        continue;
      }
    }
 else     if (binding instanceof ExposedBinding) {
      ExposedBinding<?> exposedBinding=(ExposedBinding)binding;
      Injector injector=exposedBinding.getPrivateElements().getInjector();
      if (injector != null) {
        binding=injector.getBinding(exposedBinding.getKey());
        continue;
      }
    }
    return false;
  }
 while (true);
}
Program: 60452
Project: 60452
Buggy source:
ImmutableMap<Key<?>,Binding<?>> indexBindings(Iterable<Element> elements){
  ImmutableMap.Builder<Key<?>,Binding<?>> builder=ImmutableMap.builder();
  for (  Element element : elements) {
    if (element instanceof Binding) {
      Binding<?> binding=(Binding<?>)element;
      builder.put(binding.getKey(),binding);
    }
  }
  return builder.build();
}

Fixed version (ground truth):
ImmutableMap<Key<?>,Binding<?>> indexBindings(Iterable<Element> elements){
  ImmutableMap.Builder<Key<?>,Binding<?>> builder=ImmutableMap.builder();
  for (  Element element : elements) {
    if (element instanceof Binding) {
      Binding<?> binding=(Binding<?>)element;
      builder.put(binding.getKey(),binding);
    }
 else     if (element instanceof PrivateElements) {
      PrivateElements privateElements=(PrivateElements)element;
      Map<Key<?>,Binding<?>> privateBindings=indexBindings(privateElements.getElements());
      for (      Key<?> exposed : privateElements.getExposedKeys()) {
        builder.put(exposed,privateBindings.get(exposed));
      }
    }
  }
  return builder.build();
}
Program: 60453
Project: 60453
Buggy source:
protected void configure(){
  bind(a).to(b);
  bind(b).to(c);
  bind(c).toProvider(Providers.of("String_Node_Str")).in(Scopes.NO_SCOPE);
  bind(d).toProvider(Providers.of("String_Node_Str")).in(CustomScoped.class);
  bindScope(CustomScoped.class,Scopes.NO_SCOPE);
}

Fixed version (ground truth):
@Override protected void configure(){
  bind(f).toProvider(Providers.of("String_Node_Str")).in(CustomScoped.class);
  expose(f);
}
Program: 60455
Project: 60455
Buggy source:
@Override public String getPathInfo(){
  if (!isPathInfoComputed()) {
    final int servletPathLength=getServletPath().length();
    pathInfo=getRequestURI().substring(getContextPath().length()).replaceAll("String_Node_Str","String_Node_Str").substring(servletPathLength);
    if ("String_Node_Str".equals(pathInfo) && servletPathLength != 0) {
      pathInfo=null;
    }
    pathInfoComputed=true;
  }
  return pathInfo;
}

Fixed version (ground truth):
@Override public String getPathInfo(){
  if (!isPathInfoComputed()) {
    int servletPathLength=getServletPath().length();
    pathInfo=getRequestURI().substring(getContextPath().length()).replaceAll("String_Node_Str","String_Node_Str");
    pathInfo=pathInfo.length() > servletPathLength ? pathInfo.substring(servletPathLength) : null;
    if ("String_Node_Str".equals(pathInfo) && servletPathLength != 0) {
      pathInfo=null;
    }
    pathInfoComputed=true;
  }
  return pathInfo;
}
Program: 60457
Project: 60457
Buggy source:
@Override protected final void configure(){
  install(new InternalServletModule());
  configureServlets();
  install(filtersModuleBuilder);
  install(servletsModuleBuilder);
}

Fixed version (ground truth):
@Override protected final void configure(){
  checkState(filtersModuleBuilder == null,"String_Node_Str");
  checkState(servletsModuleBuilder == null,"String_Node_Str");
  filtersModuleBuilder=new FiltersModuleBuilder();
  servletsModuleBuilder=new ServletsModuleBuilder();
  try {
    install(new InternalServletModule());
    configureServlets();
    install(filtersModuleBuilder);
    install(servletsModuleBuilder);
  }
  finally {
    filtersModuleBuilder=null;
    servletsModuleBuilder=null;
  }
}
Program: 60458
Project: 60458
Buggy source:
public static Test suite(){
  TestSuite suite=new TestSuite();
  suite.addTestSuite(EdslTest.class);
  suite.addTestSuite(FilterDefinitionTest.class);
  suite.addTestSuite(FilterDispatchIntegrationTest.class);
  suite.addTestSuite(FilterPipelineTest.class);
  suite.addTestSuite(ServletTest.class);
  suite.addTestSuite(ServletDefinitionTest.class);
  suite.addTestSuite(ServletDefinitionPathsTest.class);
  suite.addTestSuite(ServletPipelineRequestDispatcherTest.class);
  suite.addTestSuite(ServletDispatchIntegrationTest.class);
  suite.addTestSuite(InvalidScopeBindingTest.class);
  suite.addTestSuite(VarargsFilterDispatchIntegrationTest.class);
  suite.addTestSuite(VarargsServletDispatchIntegrationTest.class);
  suite.addTestSuite(MultiModuleDispatchIntegrationTest.class);
  suite.addTestSuite(ExtensionSpiTest.class);
  return suite;
}

Fixed version (ground truth):
public static Test suite(){
  TestSuite suite=new TestSuite();
  suite.addTestSuite(EdslTest.class);
  suite.addTestSuite(FilterDefinitionTest.class);
  suite.addTestSuite(FilterDispatchIntegrationTest.class);
  suite.addTestSuite(FilterPipelineTest.class);
  suite.addTestSuite(ServletModuleTest.class);
  suite.addTestSuite(ServletTest.class);
  suite.addTestSuite(ServletDefinitionTest.class);
  suite.addTestSuite(ServletDefinitionPathsTest.class);
  suite.addTestSuite(ServletPipelineRequestDispatcherTest.class);
  suite.addTestSuite(ServletDispatchIntegrationTest.class);
  suite.addTestSuite(InvalidScopeBindingTest.class);
  suite.addTestSuite(VarargsFilterDispatchIntegrationTest.class);
  suite.addTestSuite(VarargsServletDispatchIntegrationTest.class);
  suite.addTestSuite(MultiModuleDispatchIntegrationTest.class);
  suite.addTestSuite(ExtensionSpiTest.class);
  return suite;
}
Program: 60459
Project: 60459
Buggy source:
/** 
 * Returns the interceptors applied to each method, in order of invocation.
 */
ImmutableMap<Method,List<MethodInterceptor>> getMethodInterceptors();

Fixed version (ground truth):
/** 
 * Returns the interceptors applied to each method, in order of invocation.
 */
ImmutableMap<Method,List<org.aopalliance.intercept.MethodInterceptor>> getMethodInterceptors();
Program: 60461
Project: 60461
Buggy source:
public ImmutableMap<Method,List<MethodInterceptor>> getMethodInterceptors(){
  return ImmutableMap.of();
}

Fixed version (ground truth):
public ImmutableMap<Method,List<org.aopalliance.intercept.MethodInterceptor>> getMethodInterceptors(){
  return ImmutableMap.of();
}
Program: 60463
Project: 60463
Buggy source:
@Override protected void setUp() throws Exception {
  assertTrue(failMsg(),new File(BUILD_DIR).isDirectory());
  assertTrue(failMsg(),new File(GUICE_JAR).isFile());
  assertTrue(failMsg(),new File(AOPALLIANCE_JAR).isFile());
  assertTrue(failMsg(),new File(JAVAX_INJECT_JAR).isFile());
  Properties instructions=new Properties();
  instructions.setProperty("String_Node_Str","String_Node_Str");
  buildBundle("String_Node_Str",instructions,AOPALLIANCE_JAR);
  instructions.clear();
  instructions.setProperty("String_Node_Str","String_Node_Str");
  buildBundle("String_Node_Str",instructions,JAVAX_INJECT_JAR);
  instructions.clear();
  instructions.setProperty("String_Node_Str","String_Node_Str" + "String_Node_Str");
  instructions.setProperty("String_Node_Str",OSGiTestActivator.class.getName());
  instructions.setProperty("String_Node_Str",OSGiTestActivator.class.getPackage().getName());
  buildBundle("String_Node_Str",instructions,BUILD_TEST_DIR);
  instructions.clear();
}

Fixed version (ground truth):
@Override protected void setUp() throws Exception {
  assertTrue(failMsg(),new File(BUILD_DIR).isDirectory());
  assertTrue(failMsg(),new File(GUICE_JAR).isFile());
  assertTrue(failMsg(),new File(AOPALLIANCE_JAR).isFile());
  assertTrue(failMsg(),new File(JAVAX_INJECT_JAR).isFile());
  Properties instructions=new Properties();
  instructions.setProperty("String_Node_Str","String_Node_Str");
  buildBundle("String_Node_Str",instructions,AOPALLIANCE_JAR);
  instructions.clear();
  instructions.setProperty("String_Node_Str","String_Node_Str");
  buildBundle("String_Node_Str",instructions,JAVAX_INJECT_JAR);
  instructions.clear();
  instructions.setProperty("String_Node_Str","String_Node_Str" + "String_Node_Str" + "String_Node_Str");
  instructions.setProperty("String_Node_Str",OSGiTestActivator.class.getName());
  instructions.setProperty("String_Node_Str",OSGiTestActivator.class.getPackage().getName());
  buildBundle("String_Node_Str",instructions,BUILD_TEST_DIR);
  instructions.clear();
}
Program: 60464
Project: 60464
Buggy source:
public Object invoke(MethodInvocation mi) throws Throwable {
  return mi.proceed();
}

Fixed version (ground truth):
public Object invoke(org.aopalliance.intercept.MethodInvocation mi) throws Throwable {
  return mi.proceed();
}
Program: 60465
Project: 60465
Buggy source:
@Override protected void configure(){
  bindInterceptor(new AbstractMatcher<Class<?>>(){
    public boolean matches(    Class<?> clazz){
      try {
        int clazzModifiers=clazz.getModifiers();
        int ctorModifiers=clazz.getConstructor().getModifiers();
        return (clazzModifiers & (Modifier.PUBLIC | Modifier.PROTECTED)) != 0 && (ctorModifiers & (Modifier.PUBLIC | Modifier.PROTECTED)) != 0;
      }
 catch (      NoSuchMethodException e) {
        return false;
      }
    }
  }
,new AbstractMatcher<Method>(){
    public boolean matches(    Method method){
      int methodModifiers=method.getModifiers();
      return (methodModifiers & (Modifier.PUBLIC | Modifier.PROTECTED)) != 0;
    }
  }
,new MethodInterceptor(){
    public Object invoke(    MethodInvocation mi) throws Throwable {
      return mi.proceed();
    }
  }
);
}

Fixed version (ground truth):
@Override protected void configure(){
  bindInterceptor(new AbstractMatcher<Class<?>>(){
    public boolean matches(    Class<?> clazz){
      try {
        int clazzModifiers=clazz.getModifiers();
        int ctorModifiers=clazz.getConstructor().getModifiers();
        return (clazzModifiers & (Modifier.PUBLIC | Modifier.PROTECTED)) != 0 && (ctorModifiers & (Modifier.PUBLIC | Modifier.PROTECTED)) != 0;
      }
 catch (      NoSuchMethodException e) {
        return false;
      }
    }
  }
,new AbstractMatcher<Method>(){
    public boolean matches(    Method method){
      int methodModifiers=method.getModifiers();
      return (methodModifiers & (Modifier.PUBLIC | Modifier.PROTECTED)) != 0;
    }
  }
,new org.aopalliance.intercept.MethodInterceptor(){
    public Object invoke(    org.aopalliance.intercept.MethodInvocation mi) throws Throwable {
      return mi.proceed();
    }
  }
);
}
Program: 60466
Project: 60466
Buggy source:
public final void testAsyncServiceLifecycle() throws InterruptedException {
  ExecutorService executor=Executors.newSingleThreadExecutor();
  final CountDownLatch latch=new CountDownLatch(2);
  AsyncService service=new AsyncService(executor){
    @Override protected void onStart(){
      assertEquals(2,latch.getCount());
      latch.countDown();
    }
    @Override protected void onStop(){
      assertEquals(1,latch.getCount());
      latch.countDown();
    }
  }
;
  service.start();
  latch.await(2,TimeUnit.SECONDS);
  service.stop();
  latch.await(2,TimeUnit.SECONDS);
  executor.shutdown();
  assertEquals(0,latch.getCount());
}

Fixed version (ground truth):
public final void testAsyncServiceLifecycle() throws InterruptedException {
  ExecutorService executor=Executors.newSingleThreadExecutor();
  final CountDownLatch startLatch=new CountDownLatch(1);
  final CountDownLatch stopLatch=new CountDownLatch(1);
  AsyncService service=new AsyncService(executor){
    @Override protected void onStart(){
      assertEquals(1,startLatch.getCount());
      assertEquals(1,stopLatch.getCount());
      startLatch.countDown();
    }
    @Override protected void onStop(){
      assertEquals(0,startLatch.getCount());
      assertEquals(1,stopLatch.getCount());
      stopLatch.countDown();
    }
  }
;
  service.start();
  assertTrue(startLatch.await(2,TimeUnit.SECONDS));
  service.stop();
  assertTrue(stopLatch.await(2,TimeUnit.SECONDS));
  executor.shutdown();
  assertEquals(0,startLatch.getCount());
  assertEquals(0,stopLatch.getCount());
}
Program: 60467
Project: 60467
Buggy source:
private RealMultibinder(Binder binder,TypeLiteral<T> elementType,String setName,Key<Set<T>> setKey){
  this.binder=checkNotNull(binder,"String_Node_Str");
  this.elementType=checkNotNull(elementType,"String_Node_Str");
  this.setName=checkNotNull(setName,"String_Node_Str");
  this.setKey=checkNotNull(setKey,"String_Node_Str");
  this.permitDuplicatesKey=Key.get(Boolean.class,named(toString() + "String_Node_Str"));
}

Fixed version (ground truth):
private RealMultibinder(Binder binder,TypeLiteral<T> elementType,Key<Set<T>> setKey){
  this.binder=checkNotNull(binder,"String_Node_Str");
  this.elementType=checkNotNull(elementType,"String_Node_Str");
  this.setKey=checkNotNull(setKey,"String_Node_Str");
  this.setName=nameOf(setKey);
  this.permitDuplicatesKey=Key.get(Boolean.class,named(toString() + "String_Node_Str"));
}
Program: 60468
Project: 60468
Buggy source:
protected void configure(){
  MapBinder<String,String> multibinder=MapBinder.newMapBinder(binder(),String.class,String.class);
  multibinder.addBinding("String_Node_Str").toInstance("String_Node_Str");
  multibinder.addBinding("String_Node_Str").toInstance("String_Node_Str");
  multibinder.permitDuplicates();
}

Fixed version (ground truth):
@Override public void configure(){
  MapBinder<Integer,Integer> mb1=MapBinder.newMapBinder(binder(),Integer.class,Integer.class,Marker.class);
  MapBinder<Integer,Integer> mb2=MapBinder.newMapBinder(binder(),Integer.class,Integer.class,marker);
  mb1.addBinding(1).toInstance(1);
  mb2.addBinding(2).toInstance(2);
  assertEquals(mb1,mb2);
}
Program: 60469
Project: 60469
Buggy source:
protected void configure(){
  Multibinder<String> multibinder=Multibinder.newSetBinder(binder(),String.class);
  multibinder.addBinding().toInstance("String_Node_Str");
  multibinder.addBinding().toInstance("String_Node_Str");
  multibinder.permitDuplicates();
}

Fixed version (ground truth):
@Override public void configure(){
  Multibinder<Integer> mb1=Multibinder.newSetBinder(binder(),Integer.class,Marker.class);
  Multibinder<Integer> mb2=Multibinder.newSetBinder(binder(),Integer.class,marker);
  mb1.addBinding().toInstance(1);
  mb2.addBinding().toInstance(2);
  assertEquals(mb1,mb2);
}