nus-yam/ex-repair huggingface dataset:
Program: 60293
Project: 60293
Buggy source:
public Key<T> getKey(){
  return key;
}

Fixed version (ground truth):
@Override public Key<T> getKey(){
  return key;
}
Program: 60294
Project: 60294
Buggy source:
public <V>V acceptScopingVisitor(BindingScopingVisitor<V> visitor){
  return scoping.acceptVisitor(visitor);
}

Fixed version (ground truth):
@Override public <V>V acceptScopingVisitor(BindingScopingVisitor<V> visitor){
  return scoping.acceptVisitor(visitor);
}
Program: 60295
Project: 60295
Buggy source:
public Object getSource(){
  return source;
}

Fixed version (ground truth):
@Override public Object getSource(){
  return source;
}
Program: 60296
Project: 60296
Buggy source:
public Provider<T> getProvider(){
  if (provider == null) {
    if (injector == null) {
      throw new UnsupportedOperationException("String_Node_Str");
    }
    provider=injector.getProvider(key);
  }
  return provider;
}

Fixed version (ground truth):
@Override public Provider<T> getProvider(){
  if (provider == null) {
    if (injector == null) {
      throw new UnsupportedOperationException("String_Node_Str");
    }
    provider=injector.getProvider(key);
  }
  return provider;
}
Program: 60297
Project: 60297
Buggy source:
public T get(Errors errors,InternalContext context,Dependency<?> dependency,boolean linked) throws ErrorsException {
  context.pushState(providerKey,source);
  try {
    errors=errors.withSource(providerKey);
    javax.inject.Provider<? extends T> provider=providerFactory.get(errors,context,dependency,true);
    return circularGet(provider,errors,context,dependency,provisionCallback);
  }
  finally {
    context.popState();
  }
}

Fixed version (ground truth):
@Override public T get(Errors errors,InternalContext context,Dependency<?> dependency,boolean linked) throws ErrorsException {
  context.pushState(providerKey,source);
  try {
    errors=errors.withSource(providerKey);
    javax.inject.Provider<? extends T> provider=providerFactory.get(errors,context,dependency,true);
    return circularGet(provider,errors,context,dependency,provisionCallback);
  }
  finally {
    context.popState();
  }
}
Program: 60298
Project: 60298
Buggy source:
public void notify(Errors errors){
  try {
    providerFactory=injector.getInternalFactory(providerKey,errors.withSource(source),JitLimitation.NEW_OR_EXISTING_JIT);
  }
 catch (  ErrorsException e) {
    errors.merge(e.getErrors());
  }
}

Fixed version (ground truth):
@Override public void notify(Errors errors){
  try {
    providerFactory=injector.getInternalFactory(providerKey,errors.withSource(source),JitLimitation.NEW_OR_EXISTING_JIT);
  }
 catch (  ErrorsException e) {
    errors.merge(e.getErrors());
  }
}
Program: 60299
Project: 60299
Buggy source:
public void atInject(){
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") public void atInject(){
}
Program: 60300
Project: 60300
Buggy source:
@Override public void privateGAndPublicAt(){
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") @Override public void privateGAndPublicAt(){
}
Program: 60301
Project: 60301
Buggy source:
public String getName(){
  return "String_Node_Str";
}

Fixed version (ground truth):
@Override public String getName(){
  return "String_Node_Str";
}
Program: 60302
Project: 60302
Buggy source:
@Provides @Singleton @Sole Bob provideSoleBob(final Dagny dagny){
  return new Bob(){
    public String getName(){
      return "String_Node_Str";
    }
    public Dagny getDaughter(){
      return dagny;
    }
  }
;
}

Fixed version (ground truth):
@Provides @Singleton @Sole Bob provideSoleBob(final Dagny dagny){
  return new Bob(){
    @Override public String getName(){
      return "String_Node_Str";
    }
    @Override public Dagny getDaughter(){
      return dagny;
    }
  }
;
}
Program: 60303
Project: 60303
Buggy source:
@Provides public String getT(){
  return "String_Node_Str";
}

Fixed version (ground truth):
@Override @Provides public String getT(){
  return "String_Node_Str";
}
Program: 60304
Project: 60304
Buggy source:
@Provides @Singleton Dagny provideDagny(){
  return new Dagny(){
    public int getAge(){
      return 1;
    }
  }
;
}

Fixed version (ground truth):
@Provides @Singleton Dagny provideDagny(){
  return new Dagny(){
    @Override public int getAge(){
      return 1;
    }
  }
;
}
Program: 60305
Project: 60305
Buggy source:
@Provides Integer provideInt(@Named("String_Node_Str") String dep){
  return 42;
}

Fixed version (ground truth):
@Provides @Singleton int provideInt(){
  throw new RuntimeException("String_Node_Str");
}
Program: 60306
Project: 60306
Buggy source:
public int getAge(){
  return 1;
}

Fixed version (ground truth):
@Override public int getAge(){
  return 1;
}
Program: 60307
Project: 60307
Buggy source:
@Provides Bob provideBob(final Dagny dagny){
  return new Bob(){
    public String getName(){
      return "String_Node_Str";
    }
    public Dagny getDaughter(){
      return dagny;
    }
  }
;
}

Fixed version (ground truth):
@Provides Bob provideBob(final Dagny dagny){
  return new Bob(){
    @Override public String getName(){
      return "String_Node_Str";
    }
    @Override public Dagny getDaughter(){
      return dagny;
    }
  }
;
}
Program: 60308
Project: 60308
Buggy source:
public Dagny getDaughter(){
  return dagny;
}

Fixed version (ground truth):
@Override public Dagny getDaughter(){
  return dagny;
}
Program: 60309
Project: 60309
Buggy source:
@SuppressWarnings("String_Node_Str") public ProvidesMethodBinding<T> visit(ProvidesMethodBinding<? extends T> providesMethodBinding){
  return (ProvidesMethodBinding<T>)providesMethodBinding;
}

Fixed version (ground truth):
@Override @SuppressWarnings("String_Node_Str") public ProvidesMethodBinding<T> visit(ProvidesMethodBinding<? extends T> providesMethodBinding){
  return (ProvidesMethodBinding<T>)providesMethodBinding;
}
Program: 60310
Project: 60310
Buggy source:
public void testReturnDelegateCookies(){
  Cookie[] cookies=new Cookie[]{new Cookie("String_Node_Str",TEST_VALUE_1),new Cookie("String_Node_Str","String_Node_Str")};
  HttpServletRequest delegate=createMock(HttpServletRequest.class);
  expect(delegate.getCookies()).andStubReturn(cookies);
  replay(delegate);
  ContinuingHttpServletRequest continuingRequest=new ContinuingHttpServletRequest(delegate);
  assertCookieArraysEqual(cookies,continuingRequest.getCookies());
  cookies[0].setValue("String_Node_Str");
  cookies[1].setValue("String_Node_Str");
  cookies[1].setMaxAge(123);
  try {
    assertCookieArraysEqual(cookies,continuingRequest.getCookies());
    fail();
  }
 catch (  AssertionFailedError e) {
  }
  assertEquals(TEST_VALUE_1,continuingRequest.getCookies()[0].getValue());
  assertEquals(TEST_VALUE_2,continuingRequest.getCookies()[1].getValue());
  assertEquals(DEFAULT_MAX_AGE,continuingRequest.getCookies()[1].getMaxAge());
  ContinuingHttpServletRequest furtherContinuingRequest=new ContinuingHttpServletRequest(continuingRequest);
  assertCookieArraysEqual(continuingRequest.getCookies(),furtherContinuingRequest.getCookies());
  verify(delegate);
}

Fixed version (ground truth):
public void testReturnDelegateCookies(){
  Cookie[] cookies=new Cookie[]{new Cookie("String_Node_Str",TEST_VALUE_1),new Cookie("String_Node_Str","String_Node_Str")};
  HttpServletRequest delegate=createMock(HttpServletRequest.class);
  expect(delegate.getCookies()).andStubReturn(cookies);
  replay(delegate);
  ContinuingHttpServletRequest continuingRequest=new ContinuingHttpServletRequest(delegate);
  assertCookieArraysEqual(cookies,continuingRequest.getCookies());
  cookies[0].setValue("String_Node_Str");
  cookies[1].setValue("String_Node_Str");
  cookies[1].setMaxAge(123);
  try {
    assertCookieArraysEqual(cookies,continuingRequest.getCookies());
    throw new Error();
  }
 catch (  AssertionFailedError e) {
  }
  assertEquals(TEST_VALUE_1,continuingRequest.getCookies()[0].getValue());
  assertEquals(TEST_VALUE_2,continuingRequest.getCookies()[1].getValue());
  assertEquals(DEFAULT_MAX_AGE,continuingRequest.getCookies()[1].getMaxAge());
  ContinuingHttpServletRequest furtherContinuingRequest=new ContinuingHttpServletRequest(continuingRequest);
  assertCookieArraysEqual(continuingRequest.getCookies(),furtherContinuingRequest.getCookies());
  verify(delegate);
}
Program: 60311
Project: 60311
Buggy source:
public void testBindingSuperTypeAccessSubType(){
  final Integer testValue=1024;
  Object instance=new Object(){
    @Bind(to=Number.class) private Integer anInt=testValue;
  }
;
  BoundFieldModule module=BoundFieldModule.of(instance);
  Injector injector=Guice.createInjector(module);
  try {
    injector.getInstance(Integer.class);
  }
 catch (  ConfigurationException e) {
    assertContains(e.getMessage(),"String_Node_Str");
  }
}

Fixed version (ground truth):
public void testBindingSuperTypeAccessSubType(){
  final Integer testValue=1024;
  Object instance=new Object(){
    @Bind(to=Number.class) private Integer anInt=testValue;
  }
;
  BoundFieldModule module=BoundFieldModule.of(instance);
  Injector injector=Guice.createInjector(module);
  try {
    injector.getInstance(Integer.class);
    fail();
  }
 catch (  ConfigurationException e) {
    assertContains(e.getMessage(),"String_Node_Str");
  }
}
Program: 60312
Project: 60312
Buggy source:
public void testMultipleErrorsAreAggregated(){
  Object instance=new Object(){
    @Bind private Provider aProvider;
    @Bind(to=String.class) private Integer anInt;
  }
;
  BoundFieldModule module=BoundFieldModule.of(instance);
  try {
    Guice.createInjector(module);
  }
 catch (  CreationException e) {
    assertEquals(2,e.getErrorMessages().size());
  }
}

Fixed version (ground truth):
public void testMultipleErrorsAreAggregated(){
  Object instance=new Object(){
    @Bind private Provider aProvider;
    @Bind(to=String.class) private Integer anInt;
  }
;
  BoundFieldModule module=BoundFieldModule.of(instance);
  try {
    Guice.createInjector(module);
    fail();
  }
 catch (  CreationException e) {
    assertEquals(2,e.getErrorMessages().size());
  }
}
Program: 60313
Project: 60313
Buggy source:
public void testClassIsPrintedInErrorsWhenCauseIsSuperclass(){
  Object instance=new InvalidBindableSubclass();
  BoundFieldModule module=BoundFieldModule.of(instance);
  try {
    Guice.createInjector(module);
  }
 catch (  CreationException e) {
    assertContains(e.getMessage(),"String_Node_Str" + "String_Node_Str");
  }
}

Fixed version (ground truth):
public void testClassIsPrintedInErrorsWhenCauseIsSuperclass(){
  Object instance=new InvalidBindableSubclass();
  BoundFieldModule module=BoundFieldModule.of(instance);
  try {
    Guice.createInjector(module);
    fail();
  }
 catch (  CreationException e) {
    assertContains(e.getMessage(),"String_Node_Str" + "String_Node_Str");
  }
}
Program: 60314
Project: 60314
Buggy source:
public void testFailureOnMultipleBindingAnnotations(){
  final Integer testInt=1024;
  Object instance=new Object(){
    @Bind @Named("String_Node_Str") @SomeBindingAnnotation private Integer anInt=testInt;
  }
;
  BoundFieldModule module=BoundFieldModule.of(instance);
  try {
    Guice.createInjector(module);
  }
 catch (  CreationException e) {
    assertContains(e.getMessage(),"String_Node_Str");
  }
}

Fixed version (ground truth):
public void testFailureOnMultipleBindingAnnotations(){
  final Integer testInt=1024;
  Object instance=new Object(){
    @Bind @Named("String_Node_Str") @SomeBindingAnnotation private Integer anInt=testInt;
  }
;
  BoundFieldModule module=BoundFieldModule.of(instance);
  try {
    Guice.createInjector(module);
    fail();
  }
 catch (  CreationException e) {
    assertContains(e.getMessage(),"String_Node_Str");
  }
}
Program: 60315
Project: 60315
Buggy source:
public void testBoundFieldsCannotBeInjected(){
  Object instance=new Object(){
    @Bind @Inject Integer anInt=0;
  }
;
  BoundFieldModule module=BoundFieldModule.of(instance);
  try {
    Guice.createInjector(module);
  }
 catch (  CreationException e) {
    assertContains(e.getMessage(),"String_Node_Str");
  }
}

Fixed version (ground truth):
public void testBoundFieldsCannotBeInjected(){
  Object instance=new Object(){
    @Bind @Inject Integer anInt=0;
  }
;
  BoundFieldModule module=BoundFieldModule.of(instance);
  try {
    Guice.createInjector(module);
    fail();
  }
 catch (  CreationException e) {
    assertContains(e.getMessage(),"String_Node_Str");
  }
}
Program: 60316
Project: 60316
Buggy source:
@Before public void setUp() throws Exception {
  when(provider.createEntityManagerFactory(PERSISTENCE_UNIT_NAME,PERSISTENCE_PROPERTIES)).thenReturn(factory);
  when(factory.createEntityManager()).thenReturn(entityManager);
}

Fixed version (ground truth):
@Override public void setUp() throws Exception {
  when(provider.createEntityManagerFactory(PERSISTENCE_UNIT_NAME,PERSISTENCE_PROPERTIES)).thenReturn(factory);
  when(factory.createEntityManager()).thenReturn(entityManager);
}
Program: 60317
Project: 60317
Buggy source:
public void testChildInjectorInheritsOption(){
  Injector parent=Guice.createInjector(new AbstractModule(){
    @Override protected void configure(){
      binder().requireExplicitBindings();
      bind(Bar.class);
    }
  }
);
  ensureWorks(parent,Bar.class);
  ensureFails(parent,FAIL_ALL,FooImpl.class,FooBar.class,Foo.class);
  try {
    parent.createChildInjector(new AbstractModule(){
      @Override protected void configure(){
        bind(FooBar.class);
      }
    }
);
    fail("String_Node_Str");
  }
 catch (  CreationException expected) {
    assertContains(expected.getMessage(),"String_Node_Str" + jitFailed(Foo.class));
    assertTrue(expected.getMessage(),!expected.getMessage().contains("String_Node_Str"));
  }
  Injector child=parent.createChildInjector(new AbstractModule(){
    @Override protected void configure(){
      bind(Foo.class).to(FooImpl.class);
    }
  }
);
  ensureWorks(child,Foo.class,Bar.class);
  ensureFails(child,ALLOW_BINDING,FooImpl.class);
  ensureInChild(parent,FooImpl.class,FooBar.class,Foo.class);
  Injector grandchild=child.createChildInjector(new AbstractModule(){
    @Override protected void configure(){
      bind(FooBar.class);
    }
  }
);
  ensureWorks(grandchild,FooBar.class,Foo.class,Bar.class);
  ensureFails(grandchild,ALLOW_BINDING,FooImpl.class);
  ensureFails(child,ALLOW_BINDING,FooImpl.class);
  ensureInChild(parent,FooImpl.class,FooBar.class,Foo.class);
}

Fixed version (ground truth):
public void testChildInjectorInheritsOption(){
  Injector parent=Guice.createInjector(new AbstractModule(){
    @Override protected void configure(){
      binder().requireExplicitBindings();
      bind(Bar.class);
    }
  }
);
  ensureWorks(parent,Bar.class);
  ensureFails(parent,FAIL_ALL,FooImpl.class,FooBar.class,Foo.class);
  try {
    parent.createChildInjector(new AbstractModule(){
      @Override protected void configure(){
        bind(FooBar.class);
      }
    }
);
    fail("String_Node_Str");
  }
 catch (  CreationException expected) {
    assertContains(expected.getMessage(),"String_Node_Str" + jitFailed(Foo.class));
    assertTrue(expected.getMessage(),!expected.getMessage().contains("String_Node_Str"));
  }
  Injector child=parent.createChildInjector(new AbstractModule(){
    @Override protected void configure(){
      bind(Foo.class).to(FooImpl.class);
    }
  }
);
  ensureWorks(child,Foo.class,Bar.class);
  ensureFails(child,ALLOW_BINDING,FooImpl.class);
  ensureInChild(parent,FooImpl.class,Foo.class);
  Injector grandchild=child.createChildInjector(new AbstractModule(){
    @Override protected void configure(){
      bind(FooBar.class);
    }
  }
);
  ensureWorks(grandchild,FooBar.class,Foo.class,Bar.class);
  ensureFails(grandchild,ALLOW_BINDING,FooImpl.class);
  ensureFails(child,ALLOW_BINDING,FooImpl.class);
  ensureInChild(parent,FooImpl.class,FooBar.class,Foo.class);
}
Program: 60318
Project: 60318
Buggy source:
/** 
 * Creates a binding for an injectable type with the given scope. Looks for a scope on the type if none is specified.
 */
<T>BindingImpl<T> createUninitializedBinding(Key<T> key,Scoping scoping,Object source,Errors errors,boolean jitBinding) throws ErrorsException {
  Class<?> rawType=key.getTypeLiteral().getRawType();
  if (rawType.isArray() || rawType.isEnum()) {
    throw errors.missingImplementation(key).toException();
  }
  if (rawType == TypeLiteral.class) {
    @SuppressWarnings("String_Node_Str") BindingImpl<T> binding=(BindingImpl<T>)createTypeLiteralBinding((Key<TypeLiteral<Object>>)key,errors);
    return binding;
  }
  ImplementedBy implementedBy=rawType.getAnnotation(ImplementedBy.class);
  if (implementedBy != null) {
    Annotations.checkForMisplacedScopeAnnotations(rawType,source,errors);
    return createImplementedByBinding(key,scoping,implementedBy,errors);
  }
  ProvidedBy providedBy=rawType.getAnnotation(ProvidedBy.class);
  if (providedBy != null) {
    Annotations.checkForMisplacedScopeAnnotations(rawType,source,errors);
    return createProvidedByBinding(key,scoping,providedBy,errors);
  }
  return ConstructorBindingImpl.create(this,key,null,source,scoping,errors,jitBinding && options.jitDisabled,options.atInjectRequired);
}

Fixed version (ground truth):
/** 
 * Creates a binding for an injectable type with the given scope. Looks for a scope on the type if none is specified.
 */
<T>BindingImpl<T> createUninitializedBinding(Key<T> key,Scoping scoping,Object source,Errors errors,boolean jitBinding) throws ErrorsException {
  Class<?> rawType=key.getTypeLiteral().getRawType();
  ImplementedBy implementedBy=rawType.getAnnotation(ImplementedBy.class);
  if (rawType.isArray() || (rawType.isEnum() && implementedBy != null)) {
    throw errors.missingImplementation(key).toException();
  }
  if (rawType == TypeLiteral.class) {
    @SuppressWarnings("String_Node_Str") BindingImpl<T> binding=(BindingImpl<T>)createTypeLiteralBinding((Key<TypeLiteral<Object>>)key,errors);
    return binding;
  }
  if (implementedBy != null) {
    Annotations.checkForMisplacedScopeAnnotations(rawType,source,errors);
    return createImplementedByBinding(key,scoping,implementedBy,errors);
  }
  ProvidedBy providedBy=rawType.getAnnotation(ProvidedBy.class);
  if (providedBy != null) {
    Annotations.checkForMisplacedScopeAnnotations(rawType,source,errors);
    return createProvidedByBinding(key,scoping,providedBy,errors);
  }
  return ConstructorBindingImpl.create(this,key,null,source,scoping,errors,jitBinding && options.jitDisabled,options.atInjectRequired);
}
Program: 60319
Project: 60319
Buggy source:
public String get(){
  return TEST_VALUE;
}

Fixed version (ground truth):
@Override public EmptyEnum get(){
  return null;
}
Program: 60320
Project: 60320
Buggy source:
public boolean matches(String uri){
  return null != uri && this.pattern.matcher(uri).matches();
}

Fixed version (ground truth):
public boolean matches(String uri){
  return null != uri && this.pattern.matcher(getUri(uri)).matches();
}
Program: 60321
Project: 60321
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(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(ContinuingHttpServletRequestTest.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(ContinuingHttpServletRequestTest.class);
  suite.addTestSuite(VarargsFilterDispatchIntegrationTest.class);
  suite.addTestSuite(VarargsServletDispatchIntegrationTest.class);
  suite.addTestSuite(MultiModuleDispatchIntegrationTest.class);
  suite.addTestSuite(ExtensionSpiTest.class);
  suite.addTestSuite(UriPatternTypeTest.class);
  return suite;
}
Program: 60322
Project: 60322
Buggy source:
@Override protected void configureServlets(){
  serve("String_Node_Str").with(ForwardingServlet.class);
  serve("String_Node_Str").with(ForwardedServlet.class);
}

Fixed version (ground truth):
@Override protected void configureServlets(){
  filter("String_Node_Str").through(TestFilter.class);
  serve("String_Node_Str").with(TestServlet.class);
}
Program: 60323
Project: 60323
Buggy source:
public Entry<K,Provider<V>> get(){
  return this;
}

Fixed version (ground truth):
@Override public List<String> get(){
  return Lists.newArrayList();
}
Program: 60324
Project: 60324
Buggy source:
@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;
}

Fixed version (ground truth):
@Override public String getPathInfo(){
  if (!isPathInfoComputed()) {
    String servletPath=getServletPath();
    int servletPathLength=servletPath.length();
    String requestUri=getRequestURI();
    pathInfo=requestUri.substring(getContextPath().length()).replaceAll("String_Node_Str","String_Node_Str");
    if (pathInfo.startsWith(servletPath)) {
      pathInfo=pathInfo.substring(servletPathLength);
      if (pathInfo.isEmpty() && servletPathLength > 0) {
        pathInfo=null;
      }
    }
    pathInfoComputed=true;
  }
  return pathInfo;
}
Program: 60329
Project: 60329
Buggy source:
private void internalConvertToTypes(Matcher<? super TypeLiteral<?>> typeMatcher,TypeConverter converter){
  injector.state.addConverter(new TypeConverterBinding(SourceProvider.UNKNOWN_SOURCE,typeMatcher,converter));
}

Fixed version (ground truth):
private static void internalConvertToTypes(InjectorImpl injector,Matcher<? super TypeLiteral<?>> typeMatcher,TypeConverter converter){
  injector.state.addConverter(new TypeConverterBinding(SourceProvider.UNKNOWN_SOURCE,typeMatcher,converter));
}
Program: 60330
Project: 60330
Buggy source:
private void convertToClasses(final Matcher<? super Class<?>> typeMatcher,TypeConverter converter){
  internalConvertToTypes(new AbstractMatcher<TypeLiteral<?>>(){
    public boolean matches(    TypeLiteral<?> typeLiteral){
      Type type=typeLiteral.getType();
      if (!(type instanceof Class)) {
        return false;
      }
      Class<?> clazz=(Class<?>)type;
      return typeMatcher.matches(clazz);
    }
    @Override public String toString(){
      return typeMatcher.toString();
    }
  }
,converter);
}

Fixed version (ground truth):
private static void convertToClasses(InjectorImpl injector,final Matcher<? super Class<?>> typeMatcher,TypeConverter converter){
  internalConvertToTypes(injector,new AbstractMatcher<TypeLiteral<?>>(){
    public boolean matches(    TypeLiteral<?> typeLiteral){
      Type type=typeLiteral.getType();
      if (!(type instanceof Class)) {
        return false;
      }
      Class<?> clazz=(Class<?>)type;
      return typeMatcher.matches(clazz);
    }
    @Override public String toString(){
      return typeMatcher.toString();
    }
  }
,converter);
}
Program: 60331
Project: 60331
Buggy source:
private <T>void convertToClass(Class<T> type,TypeConverter converter){
  convertToClasses(Matchers.identicalTo(type),converter);
}

Fixed version (ground truth):
private static <T>void convertToClass(InjectorImpl injector,Class<T> type,TypeConverter converter){
  convertToClasses(injector,Matchers.identicalTo(type),converter);
}
Program: 60332
Project: 60332
Buggy source:
private <T>void convertToPrimitiveType(Class<T> primitiveType,final Class<T> wrapperType){
  try {
    final Method parser=wrapperType.getMethod("String_Node_Str" + capitalize(primitiveType.getName()),String.class);
    TypeConverter typeConverter=new TypeConverter(){
      @SuppressWarnings("String_Node_Str") public Object convert(      String value,      TypeLiteral<?> toType){
        try {
          return parser.invoke(null,value);
        }
 catch (        IllegalAccessException e) {
          throw new AssertionError(e);
        }
catch (        InvocationTargetException e) {
          throw new RuntimeException(e.getTargetException().getMessage());
        }
      }
      @Override public String toString(){
        return "String_Node_Str" + wrapperType.getSimpleName() + "String_Node_Str";
      }
    }
;
    convertToClass(wrapperType,typeConverter);
  }
 catch (  NoSuchMethodException e) {
    throw new AssertionError(e);
  }
}

Fixed version (ground truth):
private static <T>void convertToPrimitiveType(InjectorImpl injector,Class<T> primitiveType,final Class<T> wrapperType){
  try {
    final Method parser=wrapperType.getMethod("String_Node_Str" + capitalize(primitiveType.getName()),String.class);
    TypeConverter typeConverter=new TypeConverter(){
      @SuppressWarnings("String_Node_Str") public Object convert(      String value,      TypeLiteral<?> toType){
        try {
          return parser.invoke(null,value);
        }
 catch (        IllegalAccessException e) {
          throw new AssertionError(e);
        }
catch (        InvocationTargetException e) {
          throw new RuntimeException(e.getTargetException().getMessage());
        }
      }
      @Override public String toString(){
        return "String_Node_Str" + wrapperType.getSimpleName() + "String_Node_Str";
      }
    }
;
    convertToClass(injector,wrapperType,typeConverter);
  }
 catch (  NoSuchMethodException e) {
    throw new AssertionError(e);
  }
}
Program: 60333
Project: 60333
Buggy source:
public Object proceed() throws Throwable {
  try {
    index++;
    return index == interceptors.length ? methodProxy.invokeSuper(proxy,arguments) : interceptors[index].invoke(this);
  }
 catch (  Throwable t) {
    pruneStacktrace(t);
    throw t;
  }
 finally {
    index--;
  }
}

Fixed version (ground truth):
public Object proceed() throws Throwable {
  try {
    return index == interceptors.length ? methodProxy.invokeSuper(proxy,arguments) : interceptors[index].invoke(new InterceptedMethodInvocation(proxy,methodProxy,arguments,index + 1));
  }
 catch (  Throwable t) {
    pruneStacktrace(t);
    throw t;
  }
}
Program: 60334
Project: 60334
Buggy source:
public Object intercept(Object proxy,Method method,Object[] arguments,MethodProxy methodProxy) throws Throwable {
  return new InterceptedMethodInvocation(proxy,methodProxy,arguments).proceed();
}

Fixed version (ground truth):
public Object intercept(Object proxy,Method method,Object[] arguments,MethodProxy methodProxy) throws Throwable {
  return new InterceptedMethodInvocation(proxy,methodProxy,arguments,0).proceed();
}
Program: 60335
Project: 60335
Buggy source:
public InterceptedMethodInvocation(Object proxy,MethodProxy methodProxy,Object[] arguments){
  this.proxy=proxy;
  this.methodProxy=methodProxy;
  this.arguments=arguments;
}

Fixed version (ground truth):
public InterceptedMethodInvocation(Object proxy,MethodProxy methodProxy,Object[] arguments,int index){
  this.proxy=proxy;
  this.methodProxy=methodProxy;
  this.arguments=arguments;
  this.index=index;
}
Program: 60336
Project: 60336
Buggy source:
public Object invoke(MethodInvocation methodInvocation) throws Throwable {
  called.add(name);
  return methodInvocation.proceed();
}

Fixed version (ground truth):
public Object invoke(final MethodInvocation methodInvocation) throws Throwable {
  queue.add(new Runnable(){
    @Override public void run(){
      try {
        methodInvocation.proceed();
      }
 catch (      Throwable t) {
        throw new RuntimeException(t);
      }
    }
  }
);
  return null;
}
Program: 60337
Project: 60337
Buggy source:
@Override protected void configure(){
  CountingInterceptor interceptor=new CountingInterceptor();
  bindInterceptor(Matchers.any(),Matchers.any(),interceptor);
  bindInterceptor(Matchers.any(),Matchers.any(),interceptor);
}

Fixed version (ground truth):
protected void configure(){
  bindInterceptor(Matchers.any(),Matchers.any(),new CallLaterInterceptor(queue));
}
Program: 60338
Project: 60338
Buggy source:
ImmutableList<InjectionListener<? super T>> getInjectionListeners(){
  return injectionListeners == null ? ImmutableList.<InjectionListener<? super T>>of() : ImmutableList.copyOf(injectionListeners);
}

Fixed version (ground truth):
ImmutableSet<InjectionListener<? super T>> getInjectionListeners(){
  return injectionListeners == null ? ImmutableSet.<InjectionListener<? super T>>of() : ImmutableSet.copyOf(injectionListeners);
}
Program: 60339
Project: 60339
Buggy source:
ImmutableList<MembersInjector<? super T>> getMembersInjectors(){
  return membersInjectors == null ? ImmutableList.<MembersInjector<? super T>>of() : ImmutableList.copyOf(membersInjectors);
}

Fixed version (ground truth):
ImmutableSet<MembersInjector<? super T>> getMembersInjectors(){
  return membersInjectors == null ? ImmutableSet.<MembersInjector<? super T>>of() : ImmutableSet.copyOf(membersInjectors);
}
Program: 60340
Project: 60340
Buggy source:
void injectMembers(T t,Errors errors,InternalContext context,boolean toolableOnly){
  for (int i=0, size=memberInjectors.size(); i < size; i++) {
    SingleMemberInjector injector=memberInjectors.get(i);
    if (!toolableOnly || injector.getInjectionPoint().isToolable()) {
      injector.inject(errors,context,t);
    }
  }
  if (!toolableOnly) {
    for (int i=0, size=userMembersInjectors.size(); i < size; i++) {
      MembersInjector<? super T> userMembersInjector=userMembersInjectors.get(i);
      try {
        userMembersInjector.injectMembers(t);
      }
 catch (      RuntimeException e) {
        errors.errorInUserInjector(userMembersInjector,typeLiteral,e);
      }
    }
  }
}

Fixed version (ground truth):
void injectMembers(T t,Errors errors,InternalContext context,boolean toolableOnly){
  for (int i=0, size=memberInjectors.size(); i < size; i++) {
    SingleMemberInjector injector=memberInjectors.get(i);
    if (!toolableOnly || injector.getInjectionPoint().isToolable()) {
      injector.inject(errors,context,t);
    }
  }
  if (!toolableOnly) {
    for (    MembersInjector<? super T> userMembersInjector : userMembersInjectors) {
      try {
        userMembersInjector.injectMembers(t);
      }
 catch (      RuntimeException e) {
        errors.errorInUserInjector(userMembersInjector,typeLiteral,e);
      }
    }
  }
}
Program: 60341
Project: 60341
Buggy source:
/** 
 * Creates a new members injector and attaches both injection listeners and method aspects.
 */
private <T>MembersInjectorImpl<T> createWithListeners(TypeLiteral<T> type,Errors errors) throws ErrorsException {
  int numErrorsBefore=errors.size();
  Set<InjectionPoint> injectionPoints;
  try {
    injectionPoints=InjectionPoint.forInstanceMethodsAndFields(type);
  }
 catch (  ConfigurationException e) {
    errors.merge(e.getErrorMessages());
    injectionPoints=e.getPartialValue();
  }
  ImmutableList<SingleMemberInjector> injectors=getInjectors(injectionPoints,errors);
  errors.throwIfNewErrors(numErrorsBefore);
  EncounterImpl<T> encounter=new EncounterImpl<T>(errors,injector.lookups);
  for (  TypeListenerBinding typeListener : typeListenerBindings) {
    if (typeListener.getTypeMatcher().matches(type)) {
      try {
        typeListener.getListener().hear(type,encounter);
      }
 catch (      RuntimeException e) {
        errors.errorNotifyingTypeListener(typeListener,type,e);
      }
    }
  }
  encounter.invalidate();
  errors.throwIfNewErrors(numErrorsBefore);
  return new MembersInjectorImpl<T>(injector,type,encounter,injectors);
}

Fixed version (ground truth):
/** 
 * Creates a new members injector and attaches both injection listeners and method aspects.
 */
private <T>MembersInjectorImpl<T> createWithListeners(TypeLiteral<T> type,Errors errors) throws ErrorsException {
  int numErrorsBefore=errors.size();
  Set<InjectionPoint> injectionPoints;
  try {
    injectionPoints=InjectionPoint.forInstanceMethodsAndFields(type);
  }
 catch (  ConfigurationException e) {
    errors.merge(e.getErrorMessages());
    injectionPoints=e.getPartialValue();
  }
  ImmutableList<SingleMemberInjector> injectors=getInjectors(injectionPoints,errors);
  errors.throwIfNewErrors(numErrorsBefore);
  EncounterImpl<T> encounter=new EncounterImpl<T>(errors,injector.lookups);
  Set<TypeListener> alreadySeenListeners=Sets.newHashSet();
  for (  TypeListenerBinding binding : typeListenerBindings) {
    TypeListener typeListener=binding.getListener();
    if (!alreadySeenListeners.contains(typeListener) && binding.getTypeMatcher().matches(type)) {
      alreadySeenListeners.add(typeListener);
      try {
        typeListener.hear(type,encounter);
      }
 catch (      RuntimeException e) {
        errors.errorNotifyingTypeListener(binding,type,e);
      }
    }
  }
  encounter.invalidate();
  errors.throwIfNewErrors(numErrorsBefore);
  return new MembersInjectorImpl<T>(injector,type,encounter,injectors);
}
Program: 60342
Project: 60342
Buggy source:
public ProvisionListenerStackCallback(Binding<T> binding,List<ProvisionListener> listeners){
  this.binding=binding;
  if (listeners.isEmpty()) {
    this.listeners=EMPTY_LISTENER;
  }
 else {
    this.listeners=listeners.toArray(new ProvisionListener[listeners.size()]);
  }
}

Fixed version (ground truth):
public ProvisionListenerStackCallback(Binding<T> binding,List<ProvisionListener> listeners){
  this.binding=binding;
  if (listeners.isEmpty()) {
    this.listeners=EMPTY_LISTENER;
  }
 else {
    Set<ProvisionListener> deDuplicated=Sets.newLinkedHashSet(listeners);
    this.listeners=deDuplicated.toArray(new ProvisionListener[deDuplicated.size()]);
  }
}
Program: 60344
Project: 60344
Buggy source:
protected void configure(){
  bindInterceptor(Matchers.any(),Matchers.any(),new NamedInterceptor("String_Node_Str",callList),new NamedInterceptor("String_Node_Str",callList),new NamedInterceptor("String_Node_Str",callList));
}

Fixed version (ground truth):
@Override protected void configure(){
  CountingInterceptor interceptor=new CountingInterceptor();
  bindInterceptor(Matchers.any(),Matchers.any(),interceptor);
  bindInterceptor(Matchers.any(),Matchers.any(),interceptor);
}
Program: 60345
Project: 60345
Buggy source:
@Override protected void configure(){
  bindListener(Matchers.any(),new ProvisionListener(){
    @Override public <T>void onProvision(    ProvisionInvocation<T> provision){
      Object provisioned=provision.provision();
      if (provisioned instanceof X) {
        ((X)provisioned).init();
      }
 else       if (provisioned instanceof Y) {
        X.createY=false;
        ((Y)provisioned).init();
      }
    }
  }
);
}

Fixed version (ground truth):
@Override protected void configure(){
  bindListener(Matchers.any(),counter);
  bindListener(Matchers.any(),counter);
}
Program: 60346
Project: 60346
Buggy source:
public void injectMembers(D instance){
  instance.userInjected++;
  assertEquals(instance.guiceInjected,instance.userInjected);
}

Fixed version (ground truth):
public void injectMembers(D instance){
  ++instance.userInjected;
}
Program: 60347
Project: 60347
Buggy source:
public void afterInjection(Object injectee){
}

Fixed version (ground truth):
public void afterInjection(D injectee){
  ++injectee.listenersNotified;
}
Program: 60348
Project: 60348
Buggy source:
public <I>void hear(TypeLiteral<I> type,TypeEncounter<I> encounter){
  encounter.addError("String_Node_Str",type);
  encounter.addError(new IllegalArgumentException("String_Node_Str"));
  encounter.addError(new Message("String_Node_Str"));
  encounter.addError(new IllegalStateException());
}

Fixed version (ground truth):
@SuppressWarnings({"String_Node_Str","String_Node_Str"}) public <I>void hear(TypeLiteral<I> type,TypeEncounter<I> encounter){
  ++count;
  MembersInjector membersInjector=new CountingMembersInjector();
  encounter.register(membersInjector);
  encounter.register(membersInjector);
  InjectionListener injectionListener=new CountingInjectionListener();
  encounter.register(injectionListener);
  encounter.register(injectionListener);
}
Program: 60349
Project: 60349
Buggy source:
@Override protected void configure(){
  requestInjection(new Object());
  bindListener(Matchers.any(),new TypeListener(){
    public <I>void hear(    TypeLiteral<I> type,    TypeEncounter<I> encounter){
      encounter.addError("String_Node_Str",type);
      encounter.addError(new IllegalArgumentException("String_Node_Str"));
      encounter.addError(new Message("String_Node_Str"));
      encounter.addError(new IllegalStateException());
    }
  }
);
}

Fixed version (ground truth):
@Override protected void configure(){
  bindListener(any(),typeListener);
  bindListener(only(new TypeLiteral<D>(){
  }
),typeListener);
}
Program: 60350
Project: 60350
Buggy source:
public boolean containsElement(com.google.inject.spi.Element element){
  if (entrySetBinder.containsElement(element)) {
    return true;
  }
 else {
    Key<?> key;
    if (element instanceof Binding) {
      key=((Binding<?>)element).getKey();
    }
 else     if (element instanceof ProviderLookup) {
      key=((ProviderLookup<?>)element).getKey();
    }
 else {
      return false;
    }
    return key.equals(mapKey) || key.equals(providerMapKey) || key.equals(multimapKey)|| key.equals(providerMultimapKey)|| key.equals(entrySetBinder.getSetKey())|| matchesValueKey(key);
  }
}

Fixed version (ground truth):
public boolean containsElement(com.google.inject.spi.Element element){
  if (entrySetBinder.containsElement(element)) {
    return true;
  }
 else {
    Key<?> key;
    if (element instanceof Binding) {
      key=((Binding<?>)element).getKey();
    }
 else     if (element instanceof ProviderLookup) {
      key=((ProviderLookup<?>)element).getKey();
    }
 else {
      return false;
    }
    return key.equals(mapKey) || key.equals(providerMapKey) || key.equals(javaxProviderMapKey)|| key.equals(multimapKey)|| key.equals(providerMultimapKey)|| key.equals(entrySetBinder.getSetKey())|| matchesValueKey(key);
  }
}
Program: 60351
Project: 60351
Buggy source:
private RealMapBinder(Binder binder,TypeLiteral<K> keyType,TypeLiteral<V> valueType,Key<Map<K,V>> mapKey,Key<Map<K,Provider<V>>> providerMapKey,Key<Map<K,Set<V>>> multimapKey,Key<Map<K,Set<Provider<V>>>> providerMultimapKey,Multibinder<Map.Entry<K,Provider<V>>> entrySetBinder){
  this.keyType=keyType;
  this.valueType=valueType;
  this.mapKey=mapKey;
  this.providerMapKey=providerMapKey;
  this.multimapKey=multimapKey;
  this.providerMultimapKey=providerMultimapKey;
  this.entrySetBinder=(RealMultibinder<Entry<K,Provider<V>>>)entrySetBinder;
  this.binder=binder;
}

Fixed version (ground truth):
private RealMapBinder(Binder binder,TypeLiteral<K> keyType,TypeLiteral<V> valueType,Key<Map<K,V>> mapKey,Key<Map<K,Provider<V>>> providerMapKey,Key<Map<K,Set<V>>> multimapKey,Key<Map<K,Set<Provider<V>>>> providerMultimapKey,Multibinder<Map.Entry<K,Provider<V>>> entrySetBinder){
  this.keyType=keyType;
  this.valueType=valueType;
  this.mapKey=mapKey;
  this.providerMapKey=providerMapKey;
  this.javaxProviderMapKey=providerMapKey.ofType(mapOfJavaxProviderOf(keyType,valueType));
  this.multimapKey=multimapKey;
  this.providerMultimapKey=providerMultimapKey;
  this.entrySetBinder=(RealMultibinder<Entry<K,Provider<V>>>)entrySetBinder;
  this.binder=binder;
}
Program: 60352
Project: 60352
Buggy source:
public void testMapBinderAggregationForAnnotationInstance(){
  Module module=new AbstractModule(){
    @Override protected void configure(){
      MapBinder<String,String> multibinder=MapBinder.newMapBinder(binder(),String.class,String.class,Names.named("String_Node_Str"));
      multibinder.addBinding("String_Node_Str").toInstance("String_Node_Str");
      multibinder.addBinding("String_Node_Str").toInstance("String_Node_Str");
      multibinder=MapBinder.newMapBinder(binder(),String.class,String.class,Names.named("String_Node_Str"));
      multibinder.addBinding("String_Node_Str").toInstance("String_Node_Str");
    }
  }
;
  Injector injector=Guice.createInjector(module);
  Key<Map<String,String>> key=Key.get(mapOfString,Names.named("String_Node_Str"));
  Map<String,String> abc=injector.getInstance(key);
  assertEquals(mapOf("String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str"),abc);
  assertMapVisitor(key,stringType,stringType,setOf(module),BOTH,false,0,instance("String_Node_Str","String_Node_Str"),instance("String_Node_Str","String_Node_Str"),instance("String_Node_Str","String_Node_Str"));
}

Fixed version (ground truth):
public void testMapBinderAggregationForAnnotationInstance(){
  Module module=new AbstractModule(){
    @Override protected void configure(){
      MapBinder<String,String> multibinder=MapBinder.newMapBinder(binder(),String.class,String.class,Names.named("String_Node_Str"));
      multibinder.addBinding("String_Node_Str").toInstance("String_Node_Str");
      multibinder.addBinding("String_Node_Str").toInstance("String_Node_Str");
      multibinder=MapBinder.newMapBinder(binder(),String.class,String.class,Names.named("String_Node_Str"));
      multibinder.addBinding("String_Node_Str").toInstance("String_Node_Str");
    }
  }
;
  Injector injector=Guice.createInjector(module);
  Key<Map<String,String>> key=Key.get(mapOfString,Names.named("String_Node_Str"));
  Map<String,String> abc=injector.getInstance(key);
  assertEquals(mapOf("String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str"),abc);
  assertMapVisitor(key,stringType,stringType,setOf(module),BOTH,false,0,instance("String_Node_Str","String_Node_Str"),instance("String_Node_Str","String_Node_Str"),instance("String_Node_Str","String_Node_Str"));
  injector.getInstance(Key.get(mapOfStringProvider,Names.named("String_Node_Str")));
  injector.getInstance(Key.get(mapOfStringJavaxProvider,Names.named("String_Node_Str")));
}
Program: 60355
Project: 60355
Buggy source:
public void testMapBinderAggregatesMultipleModules(){
  Module abc=new AbstractModule(){
    @Override 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.addBinding("String_Node_Str").toInstance("String_Node_Str");
    }
  }
;
  Module de=new AbstractModule(){
    @Override 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");
    }
  }
;
  Injector injector=Guice.createInjector(abc,de);
  Map<String,String> abcde=injector.getInstance(Key.get(mapOfString));
  assertEquals(mapOf("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"),abcde);
  assertMapVisitor(Key.get(mapOfString),stringType,stringType,setOf(abc,de),BOTH,false,0,instance("String_Node_Str","String_Node_Str"),instance("String_Node_Str","String_Node_Str"),instance("String_Node_Str","String_Node_Str"),instance("String_Node_Str","String_Node_Str"),instance("String_Node_Str","String_Node_Str"));
}

Fixed version (ground truth):
public void testMapBinderAggregatesMultipleModules(){
  Module abc=new AbstractModule(){
    @Override 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.addBinding("String_Node_Str").toInstance("String_Node_Str");
    }
  }
;
  Module de=new AbstractModule(){
    @Override 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");
    }
  }
;
  Injector injector=Guice.createInjector(abc,de);
  Map<String,String> abcde=injector.getInstance(Key.get(mapOfString));
  assertEquals(mapOf("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"),abcde);
  assertMapVisitor(Key.get(mapOfString),stringType,stringType,setOf(abc,de),BOTH,false,0,instance("String_Node_Str","String_Node_Str"),instance("String_Node_Str","String_Node_Str"),instance("String_Node_Str","String_Node_Str"),instance("String_Node_Str","String_Node_Str"),instance("String_Node_Str","String_Node_Str"));
  injector.getInstance(Key.get(mapOfStringProvider));
  injector.getInstance(Key.get(mapOfStringJavaxProvider));
}
Program: 60356
Project: 60356
Buggy source:
public void testMapBinderAggregationForAnnotationType(){
  Module module=new AbstractModule(){
    @Override protected void configure(){
      MapBinder<String,String> multibinder=MapBinder.newMapBinder(binder(),String.class,String.class,Abc.class);
      multibinder.addBinding("String_Node_Str").toInstance("String_Node_Str");
      multibinder.addBinding("String_Node_Str").toInstance("String_Node_Str");
      multibinder=MapBinder.newMapBinder(binder(),String.class,String.class,Abc.class);
      multibinder.addBinding("String_Node_Str").toInstance("String_Node_Str");
    }
  }
;
  Injector injector=Guice.createInjector(module);
  Key<Map<String,String>> key=Key.get(mapOfString,Abc.class);
  Map<String,String> abc=injector.getInstance(key);
  assertEquals(mapOf("String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str"),abc);
  assertMapVisitor(key,stringType,stringType,setOf(module),BOTH,false,0,instance("String_Node_Str","String_Node_Str"),instance("String_Node_Str","String_Node_Str"),instance("String_Node_Str","String_Node_Str"));
}

Fixed version (ground truth):
public void testMapBinderAggregationForAnnotationType(){
  Module module=new AbstractModule(){
    @Override protected void configure(){
      MapBinder<String,String> multibinder=MapBinder.newMapBinder(binder(),String.class,String.class,Abc.class);
      multibinder.addBinding("String_Node_Str").toInstance("String_Node_Str");
      multibinder.addBinding("String_Node_Str").toInstance("String_Node_Str");
      multibinder=MapBinder.newMapBinder(binder(),String.class,String.class,Abc.class);
      multibinder.addBinding("String_Node_Str").toInstance("String_Node_Str");
    }
  }
;
  Injector injector=Guice.createInjector(module);
  Key<Map<String,String>> key=Key.get(mapOfString,Abc.class);
  Map<String,String> abc=injector.getInstance(key);
  assertEquals(mapOf("String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str"),abc);
  assertMapVisitor(key,stringType,stringType,setOf(module),BOTH,false,0,instance("String_Node_Str","String_Node_Str"),instance("String_Node_Str","String_Node_Str"),instance("String_Node_Str","String_Node_Str"));
  injector.getInstance(Key.get(mapOfStringProvider,Abc.class));
  injector.getInstance(Key.get(mapOfStringJavaxProvider,Abc.class));
}