nus-yam/ex-repair huggingface dataset:
Program: 60359
Project: 60359
Buggy source:
/** 
 * @see Binder#bindListener(com.google.inject.matcher.Matcher,com.google.inject.spi.TypeListener)
 */
protected void bindListener(Matcher<? super TypeLiteral<?>> typeMatcher,TypeListener listener){
  binder().bindListener(typeMatcher,listener);
}

Fixed version (ground truth):
/** 
 * @see Binder#bindListener(Matcher,ProvisionListener)
 */
protected void bindListener(Matcher<? super Binding<?>> bindingMatcher,ProvisionListener... listeners){
  binder().bindListener(bindingMatcher,listeners);
}
Program: 60360
Project: 60360
Buggy source:
@Override protected void newImplementationNode(ImplementationNode node){
  NodeId nodeId=node.getId();
  GraphvizNode gnode=new GraphvizNode(nodeId);
  gnode.setStyle(NodeStyle.INVISIBLE);
  gnode.setHeaderBackgroundColor("String_Node_Str");
  gnode.setHeaderTextColor("String_Node_Str");
  gnode.setTitle(nameFactory.getClassName(nodeId.getKey()));
  for (  Member member : node.getMembers()) {
    gnode.addField(portIdFactory.getPortId(member),nameFactory.getMemberName(member));
  }
  addNode(gnode);
}

Fixed version (ground truth):
@Override protected void newImplementationNode(ImplementationNode node){
  NodeId nodeId=node.getId();
  GraphvizNode gnode=new GraphvizNode(nodeId);
  gnode.setStyle(NodeStyle.SOLID);
  gnode.setHeaderBackgroundColor("String_Node_Str");
  gnode.setHeaderTextColor("String_Node_Str");
  gnode.setTitle(nameFactory.getClassName(nodeId.getKey()));
  for (  Member member : node.getMembers()) {
    gnode.addField(portIdFactory.getPortId(member),nameFactory.getMemberName(member));
  }
  addNode(gnode);
}
Program: 60361
Project: 60361
Buggy source:
@Override protected void newInstanceNode(InstanceNode node){
  NodeId nodeId=node.getId();
  GraphvizNode gnode=new GraphvizNode(nodeId);
  gnode.setStyle(NodeStyle.INVISIBLE);
  gnode.setHeaderBackgroundColor("String_Node_Str");
  gnode.setHeaderTextColor("String_Node_Str");
  gnode.setTitle(nameFactory.getClassName(nodeId.getKey()));
  gnode.addSubtitle(0,nameFactory.getSourceName(node.getSource()));
  gnode.setHeaderBackgroundColor("String_Node_Str");
  gnode.setHeaderTextColor("String_Node_Str");
  gnode.setTitle(nameFactory.getInstanceName(node.getInstance()));
  for (  Member member : node.getMembers()) {
    gnode.addField(portIdFactory.getPortId(member),nameFactory.getMemberName(member));
  }
  addNode(gnode);
}

Fixed version (ground truth):
@Override protected void newInstanceNode(InstanceNode node){
  NodeId nodeId=node.getId();
  GraphvizNode gnode=new GraphvizNode(nodeId);
  gnode.setStyle(NodeStyle.SOLID);
  gnode.setHeaderBackgroundColor("String_Node_Str");
  gnode.setHeaderTextColor("String_Node_Str");
  gnode.setTitle(nameFactory.getClassName(nodeId.getKey()));
  gnode.addSubtitle(0,nameFactory.getSourceName(node.getSource()));
  gnode.setHeaderBackgroundColor("String_Node_Str");
  gnode.setHeaderTextColor("String_Node_Str");
  gnode.setTitle(nameFactory.getInstanceName(node.getInstance()));
  for (  Member member : node.getMembers()) {
    gnode.addField(portIdFactory.getPortId(member),nameFactory.getMemberName(member));
  }
  addNode(gnode);
}
Program: 60362
Project: 60362
Buggy source:
IndicesCallbackFilter(Class<?> declaringClass,List<Method> methods){
  this.declaringClass=declaringClass;
  final Map<Method,Integer> indices=Maps.newHashMap();
  for (int i=0; i < methods.size(); i++) {
    Method method=methods.get(i);
    indices.put(method,i);
  }
  this.indices=indices;
}

Fixed version (ground truth):
IndicesCallbackFilter(List<Method> methods){
  final Map<Object,Integer> indices=Maps.newHashMap();
  for (int i=0; i < methods.size(); i++) {
    indices.put(MethodWrapper.create(methods.get(i)),i);
  }
  this.indices=indices;
  this.hashCode=indices.hashCode();
}
Program: 60363
Project: 60363
Buggy source:
public int accept(Method method){
  return indices.get(method);
}

Fixed version (ground truth):
public int accept(Method method){
  return indices.get(MethodWrapper.create(method));
}
Program: 60364
Project: 60364
Buggy source:
@Override public int hashCode(){
  return declaringClass.hashCode();
}

Fixed version (ground truth):
@Override public int hashCode(){
  return hashCode;
}
Program: 60365
Project: 60365
Buggy source:
@Override public boolean equals(Object o){
  return o instanceof IndicesCallbackFilter && ((IndicesCallbackFilter)o).declaringClass == declaringClass;
}

Fixed version (ground truth):
@Override public boolean equals(Object o){
  return o instanceof IndicesCallbackFilter && ((IndicesCallbackFilter)o).indices.equals(indices);
}
Program: 60366
Project: 60366
Buggy source:
public ConstructionProxy<T> create() throws ErrorsException {
  if (interceptors.isEmpty()) {
    return new DefaultConstructionProxyFactory<T>(injectionPoint).create();
  }
  @SuppressWarnings("String_Node_Str") Class<? extends Callback>[] callbackTypes=new Class[callbacks.length];
  for (int i=0; i < callbacks.length; i++) {
    if (callbacks[i] == net.sf.cglib.proxy.NoOp.INSTANCE) {
      callbackTypes[i]=net.sf.cglib.proxy.NoOp.class;
    }
 else {
      callbackTypes[i]=net.sf.cglib.proxy.MethodInterceptor.class;
    }
  }
  try {
    Enhancer enhancer=BytecodeGen.newEnhancer(declaringClass,visibility);
    enhancer.setCallbackFilter(new IndicesCallbackFilter(declaringClass,methods));
    enhancer.setCallbackTypes(callbackTypes);
    return new ProxyConstructor<T>(enhancer,injectionPoint,callbacks,interceptors);
  }
 catch (  Throwable e) {
    throw new Errors().errorEnhancingClass(declaringClass,e).toException();
  }
}

Fixed version (ground truth):
public ConstructionProxy<T> create() throws ErrorsException {
  if (interceptors.isEmpty()) {
    return new DefaultConstructionProxyFactory<T>(injectionPoint).create();
  }
  @SuppressWarnings("String_Node_Str") Class<? extends Callback>[] callbackTypes=new Class[callbacks.length];
  for (int i=0; i < callbacks.length; i++) {
    if (callbacks[i] == net.sf.cglib.proxy.NoOp.INSTANCE) {
      callbackTypes[i]=net.sf.cglib.proxy.NoOp.class;
    }
 else {
      callbackTypes[i]=net.sf.cglib.proxy.MethodInterceptor.class;
    }
  }
  try {
    Enhancer enhancer=BytecodeGen.newEnhancer(declaringClass,visibility);
    enhancer.setCallbackFilter(new IndicesCallbackFilter(methods));
    enhancer.setCallbackTypes(callbackTypes);
    return new ProxyConstructor<T>(enhancer,injectionPoint,callbacks,interceptors);
  }
 catch (  Throwable e) {
    throw new Errors().errorEnhancingClass(declaringClass,e).toException();
  }
}
Program: 60367
Project: 60367
Buggy source:
public void testSharedProxyClasses(){
  Injector injector=Guice.createInjector(new AbstractModule(){
    protected void configure(){
      bindInterceptor(Matchers.any(),Matchers.returns(only(Foo.class)),new ReturnNullInterceptor());
    }
  }
);
  Injector childOne=injector.createChildInjector(new AbstractModule(){
    protected void configure(){
      bind(Interceptable.class);
    }
  }
);
  Interceptable nullFoosOne=childOne.getInstance(Interceptable.class);
  assertNotNull(nullFoosOne.bar());
  assertNull(nullFoosOne.foo());
  Injector childTwo=injector.createChildInjector(new AbstractModule(){
    protected void configure(){
      bind(Interceptable.class);
    }
  }
);
  Interceptable nullFoosTwo=childTwo.getInstance(Interceptable.class);
  assertNull(nullFoosTwo.foo());
  assertSame("String_Node_Str",nullFoosOne.getClass(),nullFoosTwo.getClass());
}

Fixed version (ground truth):
public void testSharedProxyClasses(){
  Injector injector=Guice.createInjector(new AbstractModule(){
    protected void configure(){
      bindInterceptor(Matchers.any(),Matchers.returns(only(Foo.class)),new ReturnNullInterceptor());
    }
  }
);
  Injector childOne=injector.createChildInjector(new AbstractModule(){
    protected void configure(){
      bind(Interceptable.class);
    }
  }
);
  Interceptable nullFoosOne=childOne.getInstance(Interceptable.class);
  assertNotNull(nullFoosOne.bar());
  assertNull(nullFoosOne.foo());
  Injector childTwo=injector.createChildInjector(new AbstractModule(){
    protected void configure(){
      bind(Interceptable.class);
    }
  }
);
  Interceptable nullFoosTwo=childTwo.getInstance(Interceptable.class);
  assertNull(nullFoosTwo.foo());
  assertSame("String_Node_Str",nullFoosOne.getClass(),nullFoosTwo.getClass());
  Injector injector2=Guice.createInjector(new AbstractModule(){
    protected void configure(){
      bindInterceptor(Matchers.any(),Matchers.returns(only(Foo.class)),new ReturnNullInterceptor());
    }
  }
);
  Interceptable separateNullFoos=injector2.getInstance(Interceptable.class);
  assertNull(separateNullFoos.foo());
  assertSame("String_Node_Str",nullFoosOne.getClass(),separateNullFoos.getClass());
}
Program: 60368
Project: 60368
Buggy source:
IndicesCallbackFilter(Class<?> declaringClass,List<Method> methods){
  this.declaringClass=declaringClass;
  final Map<Method,Integer> indices=Maps.newHashMap();
  for (int i=0; i < methods.size(); i++) {
    Method method=methods.get(i);
    indices.put(method,i);
  }
  this.indices=indices;
}

Fixed version (ground truth):
IndicesCallbackFilter(List<Method> methods){
  final Map<Object,Integer> indices=Maps.newHashMap();
  for (int i=0; i < methods.size(); i++) {
    indices.put(MethodWrapper.create(methods.get(i)),i);
  }
  this.indices=indices;
  this.hashCode=indices.hashCode();
}
Program: 60369
Project: 60369
Buggy source:
public int accept(Method method){
  return indices.get(method);
}

Fixed version (ground truth):
public int accept(Method method){
  return indices.get(MethodWrapper.create(method));
}
Program: 60370
Project: 60370
Buggy source:
@Override public int hashCode(){
  return declaringClass.hashCode();
}

Fixed version (ground truth):
@Override public int hashCode(){
  return hashCode;
}
Program: 60371
Project: 60371
Buggy source:
@Override public boolean equals(Object o){
  return o instanceof IndicesCallbackFilter && ((IndicesCallbackFilter)o).declaringClass == declaringClass;
}

Fixed version (ground truth):
@Override public boolean equals(Object o){
  return o instanceof IndicesCallbackFilter && ((IndicesCallbackFilter)o).indices.equals(indices);
}
Program: 60372
Project: 60372
Buggy source:
public ConstructionProxy<T> create() throws ErrorsException {
  if (interceptors.isEmpty()) {
    return new DefaultConstructionProxyFactory<T>(injectionPoint).create();
  }
  @SuppressWarnings("String_Node_Str") Class<? extends Callback>[] callbackTypes=new Class[callbacks.length];
  for (int i=0; i < callbacks.length; i++) {
    if (callbacks[i] == net.sf.cglib.proxy.NoOp.INSTANCE) {
      callbackTypes[i]=net.sf.cglib.proxy.NoOp.class;
    }
 else {
      callbackTypes[i]=net.sf.cglib.proxy.MethodInterceptor.class;
    }
  }
  try {
    Enhancer enhancer=BytecodeGen.newEnhancer(declaringClass,visibility);
    enhancer.setCallbackFilter(new IndicesCallbackFilter(declaringClass,methods));
    enhancer.setCallbackTypes(callbackTypes);
    return new ProxyConstructor<T>(enhancer,injectionPoint,callbacks,interceptors);
  }
 catch (  Throwable e) {
    throw new Errors().errorEnhancingClass(declaringClass,e).toException();
  }
}

Fixed version (ground truth):
public ConstructionProxy<T> create() throws ErrorsException {
  if (interceptors.isEmpty()) {
    return new DefaultConstructionProxyFactory<T>(injectionPoint).create();
  }
  @SuppressWarnings("String_Node_Str") Class<? extends Callback>[] callbackTypes=new Class[callbacks.length];
  for (int i=0; i < callbacks.length; i++) {
    if (callbacks[i] == net.sf.cglib.proxy.NoOp.INSTANCE) {
      callbackTypes[i]=net.sf.cglib.proxy.NoOp.class;
    }
 else {
      callbackTypes[i]=net.sf.cglib.proxy.MethodInterceptor.class;
    }
  }
  try {
    Enhancer enhancer=BytecodeGen.newEnhancer(declaringClass,visibility);
    enhancer.setCallbackFilter(new IndicesCallbackFilter(methods));
    enhancer.setCallbackTypes(callbackTypes);
    return new ProxyConstructor<T>(enhancer,injectionPoint,callbacks,interceptors);
  }
 catch (  Throwable e) {
    throw new Errors().errorEnhancingClass(declaringClass,e).toException();
  }
}
Program: 60373
Project: 60373
Buggy source:
public void testSharedProxyClasses(){
  Injector injector=Guice.createInjector(new AbstractModule(){
    protected void configure(){
      bindInterceptor(Matchers.any(),Matchers.returns(only(Foo.class)),new ReturnNullInterceptor());
    }
  }
);
  Injector childOne=injector.createChildInjector(new AbstractModule(){
    protected void configure(){
      bind(Interceptable.class);
    }
  }
);
  Interceptable nullFoosOne=childOne.getInstance(Interceptable.class);
  assertNotNull(nullFoosOne.bar());
  assertNull(nullFoosOne.foo());
  Injector childTwo=injector.createChildInjector(new AbstractModule(){
    protected void configure(){
      bind(Interceptable.class);
    }
  }
);
  Interceptable nullFoosTwo=childTwo.getInstance(Interceptable.class);
  assertNull(nullFoosTwo.foo());
  assertSame("String_Node_Str",nullFoosOne.getClass(),nullFoosTwo.getClass());
}

Fixed version (ground truth):
public void testSharedProxyClasses(){
  Injector injector=Guice.createInjector(new AbstractModule(){
    protected void configure(){
      bindInterceptor(Matchers.any(),Matchers.returns(only(Foo.class)),new ReturnNullInterceptor());
    }
  }
);
  Injector childOne=injector.createChildInjector(new AbstractModule(){
    protected void configure(){
      bind(Interceptable.class);
    }
  }
);
  Interceptable nullFoosOne=childOne.getInstance(Interceptable.class);
  assertNotNull(nullFoosOne.bar());
  assertNull(nullFoosOne.foo());
  Injector childTwo=injector.createChildInjector(new AbstractModule(){
    protected void configure(){
      bind(Interceptable.class);
    }
  }
);
  Interceptable nullFoosTwo=childTwo.getInstance(Interceptable.class);
  assertNull(nullFoosTwo.foo());
  assertSame("String_Node_Str",nullFoosOne.getClass(),nullFoosTwo.getClass());
  Injector injector2=Guice.createInjector(new AbstractModule(){
    protected void configure(){
      bindInterceptor(Matchers.any(),Matchers.returns(only(Foo.class)),new ReturnNullInterceptor());
    }
  }
);
  Interceptable separateNullFoos=injector2.getInstance(Interceptable.class);
  assertNull(separateNullFoos.foo());
  assertSame("String_Node_Str",nullFoosOne.getClass(),separateNullFoos.getClass());
}
Program: 60374
Project: 60374
Buggy source:
IndicesCallbackFilter(List<Method> methods){
  final Map<Object,Integer> indices=Maps.newHashMap();
  for (int i=0; i < methods.size(); i++) {
    indices.put(MethodWrapper.create(methods.get(i)),i);
  }
  this.indices=indices;
  this.hashCode=indices.hashCode();
}

Fixed version (ground truth):
IndicesCallbackFilter(Class<?> declaringClass,List<Method> methods){
  this.declaringClass=declaringClass;
  final Map<Method,Integer> indices=Maps.newHashMap();
  for (int i=0; i < methods.size(); i++) {
    Method method=methods.get(i);
    indices.put(method,i);
  }
  this.indices=indices;
}
Program: 60375
Project: 60375
Buggy source:
public int accept(Method method){
  return indices.get(MethodWrapper.create(method));
}

Fixed version (ground truth):
public int accept(Method method){
  return indices.get(method);
}
Program: 60376
Project: 60376
Buggy source:
@Override public int hashCode(){
  return hashCode;
}

Fixed version (ground truth):
@Override public int hashCode(){
  return declaringClass.hashCode();
}
Program: 60377
Project: 60377
Buggy source:
@Override public boolean equals(Object o){
  return o instanceof IndicesCallbackFilter && ((IndicesCallbackFilter)o).indices.equals(indices);
}

Fixed version (ground truth):
@Override public boolean equals(Object o){
  return o instanceof IndicesCallbackFilter && ((IndicesCallbackFilter)o).declaringClass == declaringClass;
}
Program: 60378
Project: 60378
Buggy source:
public ConstructionProxy<T> create() throws ErrorsException {
  if (interceptors.isEmpty()) {
    return new DefaultConstructionProxyFactory<T>(injectionPoint).create();
  }
  @SuppressWarnings("String_Node_Str") Class<? extends Callback>[] callbackTypes=new Class[callbacks.length];
  for (int i=0; i < callbacks.length; i++) {
    if (callbacks[i] == net.sf.cglib.proxy.NoOp.INSTANCE) {
      callbackTypes[i]=net.sf.cglib.proxy.NoOp.class;
    }
 else {
      callbackTypes[i]=net.sf.cglib.proxy.MethodInterceptor.class;
    }
  }
  try {
    Enhancer enhancer=BytecodeGen.newEnhancer(declaringClass,visibility);
    enhancer.setCallbackFilter(new IndicesCallbackFilter(methods));
    enhancer.setCallbackTypes(callbackTypes);
    return new ProxyConstructor<T>(enhancer,injectionPoint,callbacks,interceptors);
  }
 catch (  Throwable e) {
    throw new Errors().errorEnhancingClass(declaringClass,e).toException();
  }
}

Fixed version (ground truth):
public ConstructionProxy<T> create() throws ErrorsException {
  if (interceptors.isEmpty()) {
    return new DefaultConstructionProxyFactory<T>(injectionPoint).create();
  }
  @SuppressWarnings("String_Node_Str") Class<? extends Callback>[] callbackTypes=new Class[callbacks.length];
  for (int i=0; i < callbacks.length; i++) {
    if (callbacks[i] == net.sf.cglib.proxy.NoOp.INSTANCE) {
      callbackTypes[i]=net.sf.cglib.proxy.NoOp.class;
    }
 else {
      callbackTypes[i]=net.sf.cglib.proxy.MethodInterceptor.class;
    }
  }
  try {
    Enhancer enhancer=BytecodeGen.newEnhancer(declaringClass,visibility);
    enhancer.setCallbackFilter(new IndicesCallbackFilter(declaringClass,methods));
    enhancer.setCallbackTypes(callbackTypes);
    return new ProxyConstructor<T>(enhancer,injectionPoint,callbacks,interceptors);
  }
 catch (  Throwable e) {
    throw new Errors().errorEnhancingClass(declaringClass,e).toException();
  }
}
Program: 60379
Project: 60379
Buggy source:
public void testSharedProxyClasses(){
  Injector injector=Guice.createInjector(new AbstractModule(){
    protected void configure(){
      bindInterceptor(Matchers.any(),Matchers.returns(only(Foo.class)),new ReturnNullInterceptor());
    }
  }
);
  Injector childOne=injector.createChildInjector(new AbstractModule(){
    protected void configure(){
      bind(Interceptable.class);
    }
  }
);
  Interceptable nullFoosOne=childOne.getInstance(Interceptable.class);
  assertNotNull(nullFoosOne.bar());
  assertNull(nullFoosOne.foo());
  Injector childTwo=injector.createChildInjector(new AbstractModule(){
    protected void configure(){
      bind(Interceptable.class);
    }
  }
);
  Interceptable nullFoosTwo=childTwo.getInstance(Interceptable.class);
  assertNull(nullFoosTwo.foo());
  assertSame("String_Node_Str",nullFoosOne.getClass(),nullFoosTwo.getClass());
  Injector injector2=Guice.createInjector(new AbstractModule(){
    protected void configure(){
      bindInterceptor(Matchers.any(),Matchers.returns(only(Foo.class)),new ReturnNullInterceptor());
    }
  }
);
  Interceptable separateNullFoos=injector2.getInstance(Interceptable.class);
  assertNull(separateNullFoos.foo());
  assertSame("String_Node_Str",nullFoosOne.getClass(),separateNullFoos.getClass());
}

Fixed version (ground truth):
public void testSharedProxyClasses(){
  Injector injector=Guice.createInjector(new AbstractModule(){
    protected void configure(){
      bindInterceptor(Matchers.any(),Matchers.returns(only(Foo.class)),new ReturnNullInterceptor());
    }
  }
);
  Injector childOne=injector.createChildInjector(new AbstractModule(){
    protected void configure(){
      bind(Interceptable.class);
    }
  }
);
  Interceptable nullFoosOne=childOne.getInstance(Interceptable.class);
  assertNotNull(nullFoosOne.bar());
  assertNull(nullFoosOne.foo());
  Injector childTwo=injector.createChildInjector(new AbstractModule(){
    protected void configure(){
      bind(Interceptable.class);
    }
  }
);
  Interceptable nullFoosTwo=childTwo.getInstance(Interceptable.class);
  assertNull(nullFoosTwo.foo());
  assertSame("String_Node_Str",nullFoosOne.getClass(),nullFoosTwo.getClass());
}
Program: 60380
Project: 60380
Buggy source:
void validate(){
  Errors errorsForMember=errors.withSource(source);
  Set<InjectionPoint> injectionPoints;
  try {
    injectionPoints=request.getInjectionPoints();
  }
 catch (  ConfigurationException e) {
    errors.merge(e.getErrorMessages());
    injectionPoints=e.getPartialValue();
  }
  memberInjectors=injector.membersInjectorStore.getInjectors(injectionPoints,errorsForMember);
}

Fixed version (ground truth):
void validate(){
  Errors errorsForMember=errors.withSource(source);
  Set<InjectionPoint> injectionPoints;
  try {
    injectionPoints=request.getInjectionPoints();
  }
 catch (  ConfigurationException e) {
    errorsForMember.merge(e.getErrorMessages());
    injectionPoints=e.getPartialValue();
  }
  if (injectionPoints != null) {
    memberInjectors=injector.membersInjectorStore.getInjectors(injectionPoints,errorsForMember);
  }
 else {
    memberInjectors=ImmutableList.of();
  }
  errors.merge(errorsForMember);
}
Program: 60381
Project: 60381
Buggy source:
@Override protected void configure(){
  Multibinder.newSetBinder(binder(),String.class).addBinding().toInstance("String_Node_Str");
  MapBinder.newMapBinder(binder(),String.class,String.class).addBinding("String_Node_Str").toInstance("String_Node_Str");
}

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);
}
Program: 60382
Project: 60382
Buggy source:
/** 
 * Returns the key for the source binding. That binding can e retrieved from an injector using  {@link com.google.inject.Injector#getBinding(Key) Injector.getBinding(key)}.
 */
Key<String> getSourceKey();

Fixed version (ground truth):
/** 
 * Returns the key for the source binding. That binding can be retrieved from an injector using  {@link com.google.inject.Injector#getBinding(Key) Injector.getBinding(key)}.
 */
Key<String> getSourceKey();
Program: 60383
Project: 60383
Buggy source:
@Inject static void setPipeline(FilterPipeline pipeline){
  if (GuiceFilter.pipeline instanceof ManagedFilterPipeline) {
    Logger.getLogger(GuiceFilter.class.getName()).warning(MULTIPLE_INJECTORS_WARNING);
  }
  GuiceFilter.pipeline=pipeline;
}

Fixed version (ground truth):
@Inject static void setPipeline(FilterPipeline pipeline){
  if (GuiceFilter.pipeline instanceof ManagedFilterPipeline) {
    LOGGER.warning(MULTIPLE_INJECTORS_WARNING);
  }
  GuiceFilter.pipeline=pipeline;
}
Program: 60384
Project: 60384
Buggy source:
/** 
 * This creates two bindings. One for the   {@code Map.Entry<K, Provider<V>>}and another for   {@code V}.
 */
@Override public LinkedBindingBuilder<V> addBinding(K key){
  checkNotNull(key,"String_Node_Str");
  checkConfiguration(!isInitialized(),"String_Node_Str");
  Key<V> valueKey=Key.get(valueType,new RealElement(entrySetBinder.getSetName()));
  entrySetBinder.addBinding().toInstance(new MapEntry<K,Provider<V>>(key,binder.getProvider(valueKey),valueKey));
  return binder.bind(valueKey);
}

Fixed version (ground truth):
/** 
 * This creates two bindings. One for the   {@code Map.Entry<K, Provider<V>>}and another for   {@code V}.
 */
@Override public LinkedBindingBuilder<V> addBinding(K key){
  checkNotNull(key,"String_Node_Str");
  checkConfiguration(!isInitialized(),"String_Node_Str");
  Key<V> valueKey=Key.get(valueType,new RealElement(entrySetBinder.getSetName(),MAPBINDER));
  entrySetBinder.addBinding().toInstance(new MapEntry<K,Provider<V>>(key,binder.getProvider(valueKey),valueKey));
  return binder.bind(valueKey);
}
Program: 60385
Project: 60385
Buggy source:
/** 
 * Returns true if the key indicates this is a value in the map. 
 */
private boolean matchesValueKey(Key key){
  return key.getAnnotation() instanceof Element && ((Element)key.getAnnotation()).setName().equals(entrySetBinder.getSetName()) && key.getTypeLiteral().equals(valueType);
}

Fixed version (ground truth):
/** 
 * Returns true if the key indicates this is a value in the map. 
 */
private boolean matchesValueKey(Key key){
  return key.getAnnotation() instanceof Element && ((Element)key.getAnnotation()).setName().equals(entrySetBinder.getSetName()) && ((Element)key.getAnnotation()).type() == MAPBINDER && key.getTypeLiteral().equals(valueType);
}
Program: 60386
Project: 60386
Buggy source:
private boolean keyMatches(Key<?> key){
  return key.getTypeLiteral().equals(elementType) && key.getAnnotation() instanceof Element && ((Element)key.getAnnotation()).setName().equals(setName);
}

Fixed version (ground truth):
private boolean keyMatches(Key<?> key){
  return key.getTypeLiteral().equals(elementType) && key.getAnnotation() instanceof Element && ((Element)key.getAnnotation()).setName().equals(setName)&& ((Element)key.getAnnotation()).type() == MULTIBINDER;
}
Program: 60387
Project: 60387
Buggy source:
@Override public LinkedBindingBuilder<T> addBinding(){
  checkConfiguration(!isInitialized(),"String_Node_Str");
  return binder.bind(Key.get(elementType,new RealElement(setName)));
}

Fixed version (ground truth):
@Override public LinkedBindingBuilder<T> addBinding(){
  checkConfiguration(!isInitialized(),"String_Node_Str");
  return binder.bind(Key.get(elementType,new RealElement(setName,MULTIBINDER)));
}
Program: 60388
Project: 60388
Buggy source:
@Override public int hashCode(){
  return 127 * ("String_Node_Str".hashCode() ^ setName.hashCode()) + 127 * ("String_Node_Str".hashCode() ^ uniqueId);
}

Fixed version (ground truth):
@Override public int hashCode(){
  return 127 * ("String_Node_Str".hashCode() ^ setName.hashCode()) + 127 * ("String_Node_Str".hashCode() ^ uniqueId) + 127 * ("String_Node_Str".hashCode() ^ type.hashCode());
}
Program: 60389
Project: 60389
Buggy source:
@Override public boolean equals(Object o){
  return o instanceof Element && ((Element)o).setName().equals(setName()) && ((Element)o).uniqueId() == uniqueId();
}

Fixed version (ground truth):
@Override public boolean equals(Object o){
  return o instanceof Element && ((Element)o).setName().equals(setName()) && ((Element)o).uniqueId() == uniqueId() && ((Element)o).type() == type();
}
Program: 60390
Project: 60390
Buggy source:
@Override public String toString(){
  return "String_Node_Str" + Element.class.getName() + "String_Node_Str"+ setName+ "String_Node_Str"+ uniqueId+ "String_Node_Str";
}

Fixed version (ground truth):
@Override public String toString(){
  return "String_Node_Str" + Element.class.getName() + "String_Node_Str"+ setName+ "String_Node_Str"+ uniqueId+ "String_Node_Str"+ type+ "String_Node_Str";
}
Program: 60391
Project: 60391
Buggy source:
RealElement(String setName){
  uniqueId=nextUniqueId.getAndIncrement();
  this.setName=setName;
}

Fixed version (ground truth):
RealElement(String setName,Type type){
  uniqueId=nextUniqueId.getAndIncrement();
  this.setName=setName;
  this.type=type;
}
Program: 60392
Project: 60392
Buggy source:
@Inject static void setPipeline(FilterPipeline pipeline){
  if (GuiceFilter.pipeline instanceof ManagedFilterPipeline) {
    Logger.getLogger(GuiceFilter.class.getName()).warning(MULTIPLE_INJECTORS_WARNING);
  }
  GuiceFilter.pipeline=pipeline;
}

Fixed version (ground truth):
@Inject static void setPipeline(FilterPipeline pipeline){
  if (GuiceFilter.pipeline instanceof ManagedFilterPipeline) {
    LOGGER.warning(MULTIPLE_INJECTORS_WARNING);
  }
  GuiceFilter.pipeline=pipeline;
}
Program: 60393
Project: 60393
Buggy source:
/** 
 * Reentrant. If   {@code instance} was registered for injection at injector-creation time, thismethod will ensure that all its members have been injected before returning.
 */
public T get(Errors errors) throws ErrorsException {
  if (ready.getCount() == 0) {
    return instance;
  }
  if (Thread.currentThread() != creatingThread) {
    try {
      ready.await();
      return instance;
    }
 catch (    InterruptedException e) {
      throw new RuntimeException(e);
    }
  }
  if (pendingInjection.remove(instance) != null) {
    membersInjector.injectAndNotify(instance,errors.withSource(source),key,source,injector.options.stage == Stage.TOOL);
  }
  return instance;
}

Fixed version (ground truth):
/** 
 * Reentrant. If   {@code instance} was registered for injection at injector-creation time, thismethod will ensure that all its members have been injected before returning.
 */
public T get(Errors errors) throws ErrorsException {
  if (ready.getCount() == 0) {
    return instance;
  }
  if (Thread.currentThread() != creatingThread) {
    try {
      ready.await();
      return instance;
    }
 catch (    InterruptedException e) {
      throw new RuntimeException(e);
    }
  }
  if (pendingInjection.remove(instance) != null) {
    @SuppressWarnings("String_Node_Str") MembersInjectorImpl<T> membersInjector=(MembersInjectorImpl<T>)pendingMembersInjectors.remove(instance);
    Preconditions.checkState(membersInjector != null,"String_Node_Str" + instance + "String_Node_Str"+ key);
    membersInjector.injectAndNotify(instance,errors.withSource(source),key,source,injector.options.stage == Stage.TOOL);
  }
  return instance;
}
Program: 60394
Project: 60394
Buggy source:
/** 
 * Prepares member injectors for all injected instances. This prompts Guice to do static analysis on the injected instances.
 */
void validateOustandingInjections(Errors errors){
  for (  InjectableReference<?> reference : pendingInjection.values()) {
    try {
      reference.validate(errors);
    }
 catch (    ErrorsException e) {
      errors.merge(e.getErrors());
    }
  }
}

Fixed version (ground truth):
/** 
 * Prepares member injectors for all injected instances. This prompts Guice to do static analysis on the injected instances.
 */
void validateOustandingInjections(Errors errors){
  for (  InjectableReference<?> reference : pendingInjection.values()) {
    try {
      pendingMembersInjectors.put(reference.instance,reference.validate(errors));
    }
 catch (    ErrorsException e) {
      errors.merge(e.getErrors());
    }
  }
}
Program: 60395
Project: 60395
Buggy source:
public void validate(Errors errors) throws ErrorsException {
  @SuppressWarnings("String_Node_Str") TypeLiteral<T> type=TypeLiteral.get((Class<T>)instance.getClass());
  membersInjector=injector.membersInjectorStore.get(type,errors.withSource(source));
}

Fixed version (ground truth):
public MembersInjectorImpl<T> validate(Errors errors) throws ErrorsException {
  @SuppressWarnings("String_Node_Str") TypeLiteral<T> type=TypeLiteral.get((Class<T>)instance.getClass());
  return injector.membersInjectorStore.get(type,errors.withSource(source));
}
Program: 60396
Project: 60396
Buggy source:
public void testValidationErrorOnInjectedMembers(){
  try {
    Guice.createInjector(new AbstractModule(){
      protected void configure(){
        requestInjection(new NeedsRunnable());
      }
    }
);
  }
 catch (  CreationException expected) {
    assertContains(expected.getMessage(),"String_Node_Str","String_Node_Str" + NeedsRunnable.class.getName(),"String_Node_Str");
  }
}

Fixed version (ground truth):
public void testValidationErrorOnInjectedMembers(){
  try {
    Guice.createInjector(new AbstractModule(){
      @Override protected void configure(){
        requestInjection(new NeedsRunnable());
      }
    }
);
  }
 catch (  CreationException expected) {
    assertContains(expected.getMessage(),"String_Node_Str","String_Node_Str" + NeedsRunnable.class.getName(),"String_Node_Str");
  }
}
Program: 60397
Project: 60397
Buggy source:
public void testUserExceptionWhileInjectingStatically(){
  try {
    Guice.createInjector(new AbstractModule(){
      protected void configure(){
        requestStaticInjection(BlowsUpOnInject.class);
      }
    }
);
    fail();
  }
 catch (  CreationException expected) {
    assertContains(expected.getMessage(),"String_Node_Str","String_Node_Str" + BlowsUpOnInject.class.getName() + "String_Node_Str");
  }
}

Fixed version (ground truth):
public void testUserExceptionWhileInjectingStatically(){
  try {
    Guice.createInjector(new AbstractModule(){
      @Override protected void configure(){
        requestStaticInjection(BlowsUpOnInject.class);
      }
    }
);
    fail();
  }
 catch (  CreationException expected) {
    assertContains(expected.getMessage(),"String_Node_Str","String_Node_Str" + BlowsUpOnInject.class.getName() + "String_Node_Str");
  }
}
Program: 60398
Project: 60398
Buggy source:
public void testUserExceptionWhileInjectingInstance(){
  try {
    Guice.createInjector(new AbstractModule(){
      protected void configure(){
        requestInjection(new BlowsUpOnInject());
      }
    }
);
    fail();
  }
 catch (  CreationException expected) {
    assertContains(expected.getMessage(),"String_Node_Str","String_Node_Str" + BlowsUpOnInject.class.getName() + "String_Node_Str");
  }
}

Fixed version (ground truth):
public void testUserExceptionWhileInjectingInstance(){
  try {
    Guice.createInjector(new AbstractModule(){
      @Override protected void configure(){
        requestInjection(new BlowsUpOnInject());
      }
    }
);
    fail();
  }
 catch (  CreationException expected) {
    assertContains(expected.getMessage(),"String_Node_Str","String_Node_Str" + BlowsUpOnInject.class.getName() + "String_Node_Str");
  }
}
Program: 60399
Project: 60399
Buggy source:
protected void configure(){
  requestStaticInjection(BlowsUpOnInject.class);
}

Fixed version (ground truth):
@Override protected void configure(){
  bindListener(Matchers.any(),new TypeListener(){
    @Override public <I>void hear(    TypeLiteral<I> type,    TypeEncounter<I> encounter){
    }
  }
);
  String fail=new String("String_Node_Str");
  bind(Object.class).toInstance(fail);
  bind(String.class).toInstance(fail);
  requestInjection(new Object(){
    @SuppressWarnings("String_Node_Str") @Inject Object obj;
    @SuppressWarnings("String_Node_Str") @Inject String str;
  }
);
}
Program: 60400
Project: 60400
Buggy source:
public void testInjectMembers(){
  final HasInjections hi=new HasInjections();
  Guice.createInjector(new AbstractModule(){
    protected void configure(){
      bindConstant().annotatedWith(ForMethod.class).to("String_Node_Str");
      bindConstant().annotatedWith(ForField.class).to(5);
      requestInjection(hi);
    }
  }
);
  assertEquals("String_Node_Str",hi.instanceMethod);
  assertEquals(5,hi.instanceField);
  assertNull(HasInjections.staticMethod);
  assertEquals(0,HasInjections.staticField);
}

Fixed version (ground truth):
public void testInjectMembers(){
  final HasInjections hi=new HasInjections();
  Guice.createInjector(new AbstractModule(){
    @Override protected void configure(){
      bindConstant().annotatedWith(ForMethod.class).to("String_Node_Str");
      bindConstant().annotatedWith(ForField.class).to(5);
      requestInjection(hi);
    }
  }
);
  assertEquals("String_Node_Str",hi.instanceMethod);
  assertEquals(5,hi.instanceField);
  assertNull(HasInjections.staticMethod);
  assertEquals(0,HasInjections.staticField);
}
Program: 60401
Project: 60401
Buggy source:
public void testInjectStatics() throws CreationException {
  Guice.createInjector(new AbstractModule(){
    protected void configure(){
      bindConstant().annotatedWith(ForMethod.class).to("String_Node_Str");
      bindConstant().annotatedWith(ForField.class).to(5);
      requestStaticInjection(HasInjections.class);
    }
  }
);
  assertEquals("String_Node_Str",HasInjections.staticMethod);
  assertEquals(5,HasInjections.staticField);
}

Fixed version (ground truth):
public void testInjectStatics() throws CreationException {
  Guice.createInjector(new AbstractModule(){
    @Override protected void configure(){
      bindConstant().annotatedWith(ForMethod.class).to("String_Node_Str");
      bindConstant().annotatedWith(ForField.class).to(5);
      requestStaticInjection(HasInjections.class);
    }
  }
);
  assertEquals("String_Node_Str",HasInjections.staticMethod);
  assertEquals(5,HasInjections.staticField);
}
Program: 60402
Project: 60402
Buggy source:
public void testInjectMembersAndStatics(){
  final HasInjections hi=new HasInjections();
  Guice.createInjector(new AbstractModule(){
    protected void configure(){
      bindConstant().annotatedWith(ForMethod.class).to("String_Node_Str");
      bindConstant().annotatedWith(ForField.class).to(5);
      requestStaticInjection(HasInjections.class);
      requestInjection(hi);
    }
  }
);
  assertEquals("String_Node_Str",hi.instanceMethod);
  assertEquals(5,hi.instanceField);
  assertEquals("String_Node_Str",HasInjections.staticMethod);
  assertEquals(5,HasInjections.staticField);
}

Fixed version (ground truth):
public void testInjectMembersAndStatics(){
  final HasInjections hi=new HasInjections();
  Guice.createInjector(new AbstractModule(){
    @Override protected void configure(){
      bindConstant().annotatedWith(ForMethod.class).to("String_Node_Str");
      bindConstant().annotatedWith(ForField.class).to(5);
      requestStaticInjection(HasInjections.class);
      requestInjection(hi);
    }
  }
);
  assertEquals("String_Node_Str",hi.instanceMethod);
  assertEquals(5,hi.instanceField);
  assertEquals("String_Node_Str",HasInjections.staticMethod);
  assertEquals(5,HasInjections.staticField);
}
Program: 60403
Project: 60403
Buggy source:
protected void setUp() throws Exception {
  super.setUp();
  HasInjections.staticField=0;
  HasInjections.staticMethod=null;
}

Fixed version (ground truth):
@Override protected void setUp() throws Exception {
  super.setUp();
  HasInjections.staticField=0;
  HasInjections.staticMethod=null;
}
Program: 60404
Project: 60404
Buggy source:
public void testInjectionErrorOnInjectedMembers(){
  try {
    Guice.createInjector(new AbstractModule(){
      protected void configure(){
        bind(Runnable.class).toProvider(new Provider<Runnable>(){
          public Runnable get(){
            throw new UnsupportedOperationException();
          }
        }
);
        requestInjection(new NeedsRunnable());
      }
    }
);
  }
 catch (  CreationException expected) {
    assertContains(expected.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 testInjectionErrorOnInjectedMembers(){
  try {
    Guice.createInjector(new AbstractModule(){
      @Override protected void configure(){
        bind(Runnable.class).toProvider(new Provider<Runnable>(){
          public Runnable get(){
            throw new UnsupportedOperationException();
          }
        }
);
        requestInjection(new NeedsRunnable());
      }
    }
);
  }
 catch (  CreationException expected) {
    assertContains(expected.getMessage(),"String_Node_Str","String_Node_Str" + NeedsRunnable.class.getName() + "String_Node_Str","String_Node_Str" + getClass().getName(),"String_Node_Str");
  }
}
Program: 60405
Project: 60405
Buggy source:
/** 
 * Returns the key for the source binding. That binding can e retrieved from an injector using  {@link com.google.inject.Injector#getBinding(Key) Injector.getBinding(key)}.
 */
Key<String> getSourceKey();

Fixed version (ground truth):
/** 
 * Returns the key for the source binding. That binding can be retrieved from an injector using  {@link com.google.inject.Injector#getBinding(Key) Injector.getBinding(key)}.
 */
Key<String> getSourceKey();
Program: 60406
Project: 60406
Buggy source:
protected ConstructorInjector<?> create(InjectionPoint constructorInjector,Errors errors) throws ErrorsException {
  return createConstructor(constructorInjector,errors);
}

Fixed version (ground truth):
@Override protected ConstructorInjector<?> create(InjectionPoint constructorInjector,Errors errors) throws ErrorsException {
  return createConstructor(constructorInjector,errors);
}
Program: 60407
Project: 60407
Buggy source:
InjectorImpl(InjectorImpl parent,State state,InjectorOptions injectorOptions){
  this.parent=parent;
  this.state=state;
  this.options=injectorOptions;
  if (parent != null) {
    localContext=parent.localContext;
  }
 else {
    localContext=new ThreadLocal<Object[]>(){
      protected Object[] initialValue(){
        return new Object[1];
      }
    }
;
  }
}

Fixed version (ground truth):
InjectorImpl(InjectorImpl parent,State state,InjectorOptions injectorOptions){
  this.parent=parent;
  this.state=state;
  this.options=injectorOptions;
  if (parent != null) {
    localContext=parent.localContext;
  }
 else {
    localContext=new ThreadLocal<Object[]>(){
      @Override protected Object[] initialValue(){
        return new Object[1];
      }
    }
;
  }
}
Program: 60408
Project: 60408
Buggy source:
protected Object[] initialValue(){
  return new Object[1];
}

Fixed version (ground truth):
@Override protected Object[] initialValue(){
  return new Object[1];
}
Program: 60409
Project: 60409
Buggy source:
/** 
 * Returns a just-in-time binding for   {@code key}, creating it if necessary.
 * @throws ErrorsException if the binding could not be created.
 */
private <T>BindingImpl<T> getJustInTimeBinding(Key<T> key,Errors errors,JitLimitation jitType) throws ErrorsException {
  boolean jitOverride=isProvider(key) || isTypeLiteral(key) || isMembersInjector(key);
synchronized (state.lock()) {
    for (InjectorImpl injector=this; injector != null; injector=injector.parent) {
      @SuppressWarnings("String_Node_Str") BindingImpl<T> binding=(BindingImpl<T>)injector.jitBindings.get(key);
      if (binding != null) {
        if (options.jitDisabled && jitType == JitLimitation.NO_JIT && !jitOverride && !(binding instanceof ConvertedConstantBindingImpl)) {
          throw errors.jitDisabled(key).toException();
        }
 else {
          return binding;
        }
      }
    }
    return createJustInTimeBindingRecursive(key,errors,options.jitDisabled,jitType);
  }
}

Fixed version (ground truth):
/** 
 * Returns a just-in-time binding for   {@code key}, creating it if necessary.
 * @throws ErrorsException if the binding could not be created.
 */
private <T>BindingImpl<T> getJustInTimeBinding(Key<T> key,Errors errors,JitLimitation jitType) throws ErrorsException {
  boolean jitOverride=isProvider(key) || isTypeLiteral(key) || isMembersInjector(key);
synchronized (state.lock()) {
    for (InjectorImpl injector=this; injector != null; injector=injector.parent) {
      @SuppressWarnings("String_Node_Str") BindingImpl<T> binding=(BindingImpl<T>)injector.jitBindings.get(key);
      if (binding != null) {
        if (options.jitDisabled && jitType == JitLimitation.NO_JIT && !jitOverride && !(binding instanceof ConvertedConstantBindingImpl)) {
          throw errors.jitDisabled(key).toException();
        }
 else {
          return binding;
        }
      }
    }
    if (failedJitBindings.contains(key) && errors.hasErrors()) {
      throw errors.toException();
    }
    return createJustInTimeBindingRecursive(key,errors,options.jitDisabled,jitType);
  }
}
Program: 60410
Project: 60410
Buggy source:
/** 
 * Cleans up any state that may have been cached when constructing the JIT binding. 
 */
private void removeFailedJitBinding(Key<?> key,InjectionPoint ip){
  jitBindings.remove(key);
  membersInjectorStore.remove(key.getTypeLiteral());
  provisionListenerStore.remove(key);
  if (ip != null) {
    constructors.remove(ip);
  }
}

Fixed version (ground truth):
/** 
 * Cleans up any state that may have been cached when constructing the JIT binding. 
 */
private void removeFailedJitBinding(Key<?> key,InjectionPoint ip){
  failedJitBindings.add(key);
  jitBindings.remove(key);
  membersInjectorStore.remove(key.getTypeLiteral());
  provisionListenerStore.remove(key);
  if (ip != null) {
    constructors.remove(ip);
  }
}
Program: 60411
Project: 60411
Buggy source:
public String toString(){
  return Objects.toStringHelper(Injector.class).add("String_Node_Str",state.getExplicitBindingsThisLevel().values()).toString();
}

Fixed version (ground truth):
@Override public String toString(){
  return Objects.toStringHelper(Injector.class).add("String_Node_Str",state.getExplicitBindingsThisLevel().values()).toString();
}
Program: 60413
Project: 60413
Buggy source:
public void testBindingToProvider(){
  try {
    Guice.createInjector(new AbstractModule(){
      protected void configure(){
        bind(new TypeLiteral<Provider<String>>(){
        }
).toInstance(Providers.of("String_Node_Str"));
      }
    }
);
    fail();
  }
 catch (  CreationException expected) {
    assertContains(expected.getMessage(),"String_Node_Str","String_Node_Str" + BinderTest.class.getName(),"String_Node_Str");
  }
}

Fixed version (ground truth):
public void testBindingToProvider(){
  try {
    Guice.createInjector(new AbstractModule(){
      @Override protected void configure(){
        bind(new TypeLiteral<Provider<String>>(){
        }
).toInstance(Providers.of("String_Node_Str"));
      }
    }
);
    fail();
  }
 catch (  CreationException expected) {
    assertContains(expected.getMessage(),"String_Node_Str","String_Node_Str" + BinderTest.class.getName(),"String_Node_Str");
  }
}
Program: 60414
Project: 60414
Buggy source:
public void testCannotBindToGuiceTypes(){
  final Named red=Names.named("String_Node_Str");
  try {
    Guice.createInjector(new AbstractModule(){
      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));
      }
    }
);
    fail();
  }
 catch (  CreationException expected) {
    assertContains(expected.getMessage(),"String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str");
  }
}

Fixed version (ground truth):
public void testCannotBindToGuiceTypes(){
  final Named red=Names.named("String_Node_Str");
  try {
    Guice.createInjector(new AbstractModule(){
      @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));
      }
    }
);
    fail();
  }
 catch (  CreationException expected) {
    assertContains(expected.getMessage(),"String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str");
  }
}
Program: 60415
Project: 60415
Buggy source:
public void testUserReportedErrorsAreAlsoLogged(){
  try {
    Guice.createInjector(new AbstractModule(){
      protected void configure(){
        addError(new Message(ImmutableList.of(),"String_Node_Str",new IllegalArgumentException()));
      }
    }
);
    fail();
  }
 catch (  CreationException expected) {
  }
  LogRecord logRecord=Iterables.getOnlyElement(this.logRecords);
  assertContains(logRecord.getMessage(),"String_Node_Str");
}

Fixed version (ground truth):
public void testUserReportedErrorsAreAlsoLogged(){
  try {
    Guice.createInjector(new AbstractModule(){
      @Override protected void configure(){
        addError(new Message(ImmutableList.of(),"String_Node_Str",new IllegalArgumentException()));
      }
    }
);
    fail();
  }
 catch (  CreationException expected) {
  }
  LogRecord logRecord=Iterables.getOnlyElement(this.logRecords);
  assertContains(logRecord.getMessage(),"String_Node_Str");
}