nus-yam/ex-repair huggingface dataset:
Program: 88464
Project: 88464
Buggy source:
/** 
 * Main method. accepts a single parameter, which is the config directory.
 * @param args The parameters to the entry point.
 */
public static void main(String[] args){
  try {
    String configDir=null;
    if (args.length >= 2 && args[0].equals("String_Node_Str")) {
      configDir=args[1];
    }
    if (configDir == null) {
      System.err.println("String_Node_Str");
      System.exit(1);
      return;
    }
    GlobalConfiguration.loadConfiguration(configDir);
    Configuration config=GlobalConfiguration.getConfiguration();
    int port=config.getInteger(PactConfigConstants.WEB_FRONTEND_PORT_KEY,PactConfigConstants.DEFAULT_WEB_FRONTEND_PORT);
    WebInterfaceServer server=new WebInterfaceServer(config,port);
    LOG.info("String_Node_Str" + port + '.');
    server.start();
    server.join();
  }
 catch (  Throwable t) {
    LOG.error("String_Node_Str" + t.getMessage(),t);
  }
}

Fixed version (ground truth):
/** 
 * Main method. accepts a single parameter, which is the config directory.
 * @param args The parameters to the entry point.
 */
public static void main(String[] args){
  try {
    String configDir=null;
    if (args.length >= 2 && args[0].equals("String_Node_Str")) {
      configDir=args[1];
    }
    if (configDir == null) {
      System.err.println("String_Node_Str");
      System.exit(1);
      return;
    }
    GlobalConfiguration.loadConfiguration(configDir);
    Configuration config=GlobalConfiguration.getConfiguration();
    config.setString(PactConfigConstants.STRATOSPHERE_BASE_DIR_PATH_KEY,configDir + "String_Node_Str");
    int port=config.getInteger(PactConfigConstants.WEB_FRONTEND_PORT_KEY,PactConfigConstants.DEFAULT_WEB_FRONTEND_PORT);
    WebInterfaceServer server=new WebInterfaceServer(config,port);
    LOG.info("String_Node_Str" + port + '.');
    server.start();
    server.join();
  }
 catch (  Throwable t) {
    LOG.error("String_Node_Str" + t.getMessage(),t);
  }
}
Program: 88467
Project: 88467
Buggy source:
/** 
 * {@inheritDoc}
 */
@Override public InstanceType getDefaultInstanceType(){
  return this.availableInstanceTypes[this.defaultInstanceTypeIndex - 1];
}

Fixed version (ground truth):
/** 
 * {@inheritDoc}
 */
@Override public InstanceType getDefaultInstanceType(){
  return this.availableInstanceTypes[this.defaultInstanceTypeIndex];
}
Program: 88468
Project: 88468
Buggy source:
/** 
 * Constructor.
 */
public ClusterManager(){
  this.availableInstanceTypes=populateInstanceTypeArray();
  long tmpCleanUpInterval=(long)GlobalConfiguration.getInteger(CLEANUP_INTERVAL_KEY,DEFAULT_CLEANUP_INTERVAL) * 1000;
  if ((tmpCleanUpInterval % BASE_INTERVAL) != 0) {
    LOG.warn("String_Node_Str" + DEFAULT_CLEANUP_INTERVAL);
    tmpCleanUpInterval=DEFAULT_CLEANUP_INTERVAL;
  }
  this.cleanUpInterval=tmpCleanUpInterval;
  int tmpDefaultInstanceTypeIndex=GlobalConfiguration.getInteger(DEFAULT_INSTANCE_TYPE_INDEX_KEY,DEFAULT_DEFAULT_INSTANCE_TYPE_INDEX);
  if (tmpDefaultInstanceTypeIndex >= this.availableInstanceTypes.length) {
    LOG.warn("String_Node_Str" + DEFAULT_DEFAULT_INSTANCE_TYPE_INDEX);
    tmpDefaultInstanceTypeIndex=DEFAULT_DEFAULT_INSTANCE_TYPE_INDEX;
  }
  this.defaultInstanceTypeIndex=tmpDefaultInstanceTypeIndex;
  this.networkTopology=loadNetworkTopology();
  loadIPToInstanceTypeMapping();
  final boolean runTimerAsDaemon=true;
  new Timer(runTimerAsDaemon).schedule(cleanupStaleMachines,BASE_INTERVAL,BASE_INTERVAL);
}

Fixed version (ground truth):
/** 
 * Constructor.
 */
public ClusterManager(){
  this.availableInstanceTypes=populateInstanceTypeArray(LOG);
  long tmpCleanUpInterval=(long)GlobalConfiguration.getInteger(ConfigConstants.INSTANCE_MANAGER_CLEANUP_INTERVAL_KEY,DEFAULT_CLEANUP_INTERVAL) * 1000;
  if ((tmpCleanUpInterval % BASE_INTERVAL) != 0) {
    LOG.warn("String_Node_Str" + DEFAULT_CLEANUP_INTERVAL + "String_Node_Str");
    tmpCleanUpInterval=DEFAULT_CLEANUP_INTERVAL;
  }
  this.cleanUpInterval=tmpCleanUpInterval;
  int tmpDefaultInstanceTypeIndex=GlobalConfiguration.getInteger(ConfigConstants.INSTANCE_MANAGER_DEFAULT_INSTANCE_TYPE_INDEX_KEY,ConfigConstants.DEFAULT_DEFAULT_INSTANCE_TYPE_INDEX);
  if (tmpDefaultInstanceTypeIndex > this.availableInstanceTypes.length) {
    LOG.warn("String_Node_Str" + tmpDefaultInstanceTypeIndex + "String_Node_Str"+ ConfigConstants.DEFAULT_DEFAULT_INSTANCE_TYPE_INDEX);
    tmpDefaultInstanceTypeIndex=ConfigConstants.DEFAULT_DEFAULT_INSTANCE_TYPE_INDEX;
  }
  this.defaultInstanceTypeIndex=tmpDefaultInstanceTypeIndex - 1;
  this.networkTopology=loadNetworkTopology();
  loadIPToInstanceTypeMapping();
  final boolean runTimerAsDaemon=true;
  new Timer(runTimerAsDaemon).schedule(cleanupStaleMachines,BASE_INTERVAL,BASE_INTERVAL);
}
Program: 88469
Project: 88469
Buggy source:
private void preConfigure(Object obj,String alias){
  checkNotNull(obj,"String_Node_Str");
  serializee.setRootClass(initializer.getActualClass(obj));
  if (initializer.isProxy(obj.getClass())) {
    initializer.initialize(obj);
  }
  if (alias == null) {
    if (Collection.class.isInstance(obj) && (List.class.isInstance(obj))) {
      alias="String_Node_Str";
    }
 else {
      alias=extractor.nameFor(serializee.getRootClass());
    }
  }
  builder.setAlias(alias);
  setRoot(obj);
}

Fixed version (ground truth):
private void preConfigure(Object obj,String alias){
  checkNotNull(obj,"String_Node_Str");
  serializee.setRootClass(initializer.getActualClass(obj));
  if (alias == null) {
    if (Collection.class.isInstance(obj) && (List.class.isInstance(obj))) {
      alias="String_Node_Str";
    }
 else {
      alias=extractor.nameFor(serializee.getRootClass());
    }
  }
  builder.setAlias(alias);
  setRoot(obj);
}
Program: 88470
Project: 88470
Buggy source:
public Gson create(){
  return builder.create();
}

Fixed version (ground truth):
public Gson create(){
  builder.registerTypeHierarchyAdapter(HibernateProxy.class,new HibernateProxySerializer());
  return builder.create();
}
Program: 88471
Project: 88471
Buggy source:
@Test public void shouldRunHibernateLazyInitialization() throws Exception {
  LazyInitializer initializer=mock(LazyInitializer.class);
  SomeProxy proxy=new SomeProxy(initializer);
  proxy.name="String_Node_Str";
  proxy.aField="String_Node_Str";
  when(initializer.getPersistentClass()).thenReturn(Client.class);
  serialization.from(proxy).serialize();
  assertThat(result(),is("String_Node_Str"));
  verify(initializer).initialize();
}

Fixed version (ground truth):
@Test public void shouldRunHibernateLazyInitialization() throws Exception {
  LazyInitializer initializer=mock(LazyInitializer.class);
  SomeProxy proxy=new SomeProxy(initializer);
  proxy.name="String_Node_Str";
  proxy.aField="String_Node_Str";
  when(initializer.getPersistentClass()).thenReturn(Client.class);
  when(proxy.getHibernateLazyInitializer().getImplementation()).thenReturn((Client)proxy);
  serialization.from(proxy).serialize();
  assertThat(result(),is("String_Node_Str"));
}
Program: 88472
Project: 88472
Buggy source:
public BluePrintsPersister(Kind node){
  nodeKind=node;
}

Fixed version (ground truth):
public BluePrintsPersister(Kind node){
}
Program: 88474
Project: 88474
Buggy source:
@Test public void makeSureListOrderIsPreserved(){
  for (int i=posts.size() - 1; i >= 0; i--) {
    author.posts.add(posts.get(i));
  }
  getUserService().update(author);
  User user=getACopyOfTheAuthor();
  assertThat("String_Node_Str",user.posts.size(),is(6));
  assertThat("String_Node_Str",user.posts.get(0),is(posts.get(5)));
  assertThat("String_Node_Str",user.posts.get(1),is(posts.get(4)));
  assertThat("String_Node_Str",user.posts.get(2),is(posts.get(3)));
  assertThat("String_Node_Str",user.posts.get(3),is(posts.get(2)));
  assertThat("String_Node_Str",user.posts.get(4),is(posts.get(1)));
  assertThat("String_Node_Str",user.posts.get(5),is(posts.get(0)));
}

Fixed version (ground truth):
@Test public void makeSureListOrderIsPreserved(){
  for (int i=posts.size() - 1; i >= 0; i--) {
    author.posts.add(posts.get(i));
  }
  getUserService().update(author);
  User user=getACopyOfTheAuthor();
  final int NUM_POSTS=6;
  assertThat("String_Node_Str",user.posts.size(),is(NUM_POSTS));
  for (int i=0; i < NUM_POSTS; i++) {
    assertThat("String_Node_Str" + i + "String_Node_Str",user.posts.get(i),is(posts.get(NUM_POSTS - i - 1)));
  }
}
Program: 88475
Project: 88475
Buggy source:
private User getACopyOfTheAuthor(){
  User user=getUserService().find().matching(new QueryBuilder<UserInformer>(){
    @Override public QueryExpression createMatchingExpression(    UserInformer informer){
      return informer.getId().equalsTo(author.id);
    }
  }
).getFirst();
  return user;
}

Fixed version (ground truth):
/** 
 * Load this.author fresh from the database, by building a query to fetch it.
 * @return
 */
private User getACopyOfTheAuthor(){
  User user=getUserService().find().matching(new QueryBuilder<UserInformer>(){
    @Override public QueryExpression createMatchingExpression(    UserInformer informer){
      return informer.getId().equalsTo(author.id);
    }
  }
).getFirst();
  return user;
}
Program: 88476
Project: 88476
Buggy source:
@Override public int compare(Edge o1,Edge o2){
  Integer o1Idx=(Integer)o1.getProperty(Properties.collection_index.name());
  Integer o2Idx=(Integer)o2.getProperty(Properties.collection_index.name());
  if (null == o1Idx || null == o2Idx)   throw new UnableToSortException("String_Node_Str");
  return o1Idx.compareTo(o2Idx);
}

Fixed version (ground truth):
@Override public int compare(Edge o1,Edge o2){
  Integer o1Idx=(Integer)o1.getProperty(Properties.collection_index.name());
  Integer o2Idx=(Integer)o2.getProperty(Properties.collection_index.name());
  if (null == o1Idx && null == o2Idx)   return 0;
  if (null == o1Idx)   return -1;
  if (null == o2Idx)   return 1;
  return o1Idx.compareTo(o2Idx);
}
Program: 88477
Project: 88477
Buggy source:
private void deleteAllAuthorsPosts(){
  User u=getACopyOfTheAuthor();
  u.posts.clear();
  getUserService().update(u);
}

Fixed version (ground truth):
@After public void deleteAllAuthorsPosts(){
  User u=getACopyOfTheAuthor();
  u.posts.clear();
  getUserService().update(u);
}
Program: 88478
Project: 88478
Buggy source:
@Test public void checkListOrderWithModifications(){
  for (int i=posts.size() - 1; i >= 0; i--) {
    author.posts.add(posts.get(i));
  }
  getUserService().update(author);
  author.posts.remove(3);
  author.posts.remove(1);
  getUserService().update(author);
  User user=getACopyOfTheAuthor();
  assertThat("String_Node_Str",user.posts.size(),is(posts.size() - 2));
  assertThat("String_Node_Str",user.posts.get(0),is(posts.get(5)));
  assertThat("String_Node_Str",user.posts.get(1),is(posts.get(3)));
  assertThat("String_Node_Str",user.posts.get(2),is(posts.get(1)));
  assertThat("String_Node_Str",user.posts.get(3),is(posts.get(0)));
  deleteAllAuthorsPosts();
}

Fixed version (ground truth):
@Test public void checkListOrderWithModifications(){
  for (int i=posts.size() - 1; i >= 0; i--) {
    author.posts.add(posts.get(i));
  }
  getUserService().update(author);
  author.posts.remove(3);
  author.posts.remove(1);
  getUserService().update(author);
  User user=getACopyOfTheAuthor();
  assertThat("String_Node_Str",user.posts.size(),is(posts.size() - 2));
  assertThat("String_Node_Str",user.posts.get(0),is(posts.get(5)));
  assertThat("String_Node_Str",user.posts.get(1),is(posts.get(3)));
  assertThat("String_Node_Str",user.posts.get(2),is(posts.get(1)));
  assertThat("String_Node_Str",user.posts.get(3),is(posts.get(0)));
}
Program: 88479
Project: 88479
Buggy source:
@Test public void makeSureListOrderIsPreserved(){
  for (int i=posts.size() - 1; i >= 0; i--) {
    author.posts.add(posts.get(i));
  }
  getUserService().update(author);
  User user=getACopyOfTheAuthor();
  assertThat("String_Node_Str",user.posts.size(),is(6));
  assertThat("String_Node_Str",user.posts.get(0),is(posts.get(5)));
  assertThat("String_Node_Str",user.posts.get(1),is(posts.get(4)));
  assertThat("String_Node_Str",user.posts.get(2),is(posts.get(3)));
  assertThat("String_Node_Str",user.posts.get(3),is(posts.get(2)));
  assertThat("String_Node_Str",user.posts.get(4),is(posts.get(1)));
  assertThat("String_Node_Str",user.posts.get(5),is(posts.get(0)));
  deleteAllAuthorsPosts();
}

Fixed version (ground truth):
@Test public void makeSureListOrderIsPreserved(){
  for (int i=posts.size() - 1; i >= 0; i--) {
    author.posts.add(posts.get(i));
  }
  getUserService().update(author);
  User user=getACopyOfTheAuthor();
  assertThat("String_Node_Str",user.posts.size(),is(6));
  assertThat("String_Node_Str",user.posts.get(0),is(posts.get(5)));
  assertThat("String_Node_Str",user.posts.get(1),is(posts.get(4)));
  assertThat("String_Node_Str",user.posts.get(2),is(posts.get(3)));
  assertThat("String_Node_Str",user.posts.get(3),is(posts.get(2)));
  assertThat("String_Node_Str",user.posts.get(4),is(posts.get(1)));
  assertThat("String_Node_Str",user.posts.get(5),is(posts.get(0)));
}
Program: 88480
Project: 88480
Buggy source:
/** 
 * Transform an object type into associated primitive type
 * @param toCompareClass
 * @return
 */
public static Class primitize(Class<? extends Number> toCompareClass){
  if (Integer.class.equals(toCompareClass)) {
    return Integer.TYPE;
  }
 else   if (Long.class.equals(toCompareClass)) {
    return Long.TYPE;
  }
 else   if (Short.class.equals(toCompareClass)) {
    return Short.TYPE;
  }
 else   if (Float.class.equals(toCompareClass)) {
    return Float.TYPE;
  }
 else   if (Double.class.equals(toCompareClass)) {
    return Double.TYPE;
  }
 else   if (Byte.class.equals(toCompareClass)) {
    return Byte.TYPE;
  }
 else   if (Character.class.equals(toCompareClass)) {
    return Character.TYPE;
  }
 else   if (Boolean.class.equals(toCompareClass)) {
    return Boolean.TYPE;
  }
  return null;
}

Fixed version (ground truth):
/** 
 * Transform an object type into associated primitive type
 * @param toCompareClass
 * @return
 */
public static Class<?> primitize(Class<? extends Number> toCompareClass){
  if (Integer.class.equals(toCompareClass)) {
    return Integer.TYPE;
  }
 else   if (Long.class.equals(toCompareClass)) {
    return Long.TYPE;
  }
 else   if (Short.class.equals(toCompareClass)) {
    return Short.TYPE;
  }
 else   if (Float.class.equals(toCompareClass)) {
    return Float.TYPE;
  }
 else   if (Double.class.equals(toCompareClass)) {
    return Double.TYPE;
  }
 else   if (Byte.class.equals(toCompareClass)) {
    return Byte.TYPE;
  }
 else   if (Character.class.equals(toCompareClass)) {
    return Character.TYPE;
  }
 else   if (Boolean.class.equals(toCompareClass)) {
    return Boolean.TYPE;
  }
  return null;
}
Program: 88481
Project: 88481
Buggy source:
/** 
 * Put all classes extended or implemented by this one (including itself) in a collection
 * @param declaring
 * @return
 */
public static Collection<Class> allClassesOf(Class<?> declaring){
  Collection<Class> returned=new LinkedList<Class>();
  if (declaring != null) {
    if (!declaring.equals(Object.class)) {
      returned.add(declaring);
      returned.addAll(allClassesOf(declaring.getSuperclass()));
      for (      Class i : declaring.getInterfaces()) {
        returned.addAll(allClassesOf(i));
      }
    }
  }
  return returned;
}

Fixed version (ground truth):
/** 
 * Put all classes extended or implemented by this one (including itself) in a collection
 * @param declaring
 * @return
 */
public static Collection<Class<?>> allClassesOf(Class<?> declaring){
  Collection<Class<?>> returned=new LinkedList<Class<?>>();
  if (declaring != null) {
    if (!declaring.equals(Object.class)) {
      returned.add(declaring);
      returned.addAll(allClassesOf(declaring.getSuperclass()));
      for (      Class<?> i : declaring.getInterfaces()) {
        returned.addAll(allClassesOf(i));
      }
    }
  }
  return returned;
}
Program: 88482
Project: 88482
Buggy source:
/** 
 * Convert a string into an object of the class it is supposed to come from. This method is expected to work only for String (quite logical, isn't ?) and classes providing either a constructor using String as an argument, or a valueOf method having String as an argument. Any other case will miserably fail (ie a NoFromStringConversionExists will be thrown)
 * @param value input string value
 * @param type expected output type
 * @return an object of that type
 */
public static <Type>Type fromString(String value,Class<Type> type){
  if (String.class.equals(type)) {
    return (Type)value.toString();
  }
 else   if (type.isPrimitive()) {
    return (Type)fromString(value,objectify(type));
  }
 else   if (URI.class.equals(type)) {
    try {
      return (Type)new URI(value);
    }
 catch (    URISyntaxException e) {
      throw new UnableToBuilddURIException("String_Node_Str" + value + "String_Node_Str",e);
    }
  }
 else   if (Class.class.equals(type)) {
    return classFromString(value);
  }
 else {
    try {
      Constructor<Type> withString=type.getDeclaredConstructor(String.class);
      return withString.newInstance(value);
    }
 catch (    Exception e) {
      try {
        Method valueOf=type.getDeclaredMethod("String_Node_Str",String.class);
        return (Type)valueOf.invoke(null,value);
      }
 catch (      Exception e1) {
        throw new NoFromStringConversionExistsException(type,e,e1);
      }
    }
  }
}

Fixed version (ground truth):
/** 
 * Convert a string into an object of the class it is supposed to come from. This method is expected to work only for String (quite logical, isn't ?) and classes providing either a constructor using String as an argument, or a valueOf method having String as an argument. Any other case will miserably fail (ie a NoFromStringConversionExists will be thrown)
 * @param value input string value
 * @param type expected output type
 * @return an object of that type
 */
@SuppressWarnings("String_Node_Str") public static <Type>Type fromString(String value,Class<Type> type){
  if (String.class.equals(type)) {
    return (Type)value.toString();
  }
 else   if (type.isPrimitive()) {
    return (Type)fromString(value,objectify(type));
  }
 else   if (URI.class.equals(type)) {
    try {
      return (Type)new URI(value);
    }
 catch (    URISyntaxException e) {
      throw new UnableToBuilddURIException("String_Node_Str" + value + "String_Node_Str",e);
    }
  }
 else   if (Class.class.equals(type)) {
    return (Type)classFromString(value);
  }
 else {
    try {
      Constructor<Type> withString=type.getDeclaredConstructor(String.class);
      return withString.newInstance(value);
    }
 catch (    Exception e) {
      try {
        Method valueOf=type.getDeclaredMethod("String_Node_Str",String.class);
        return (Type)valueOf.invoke(null,value);
      }
 catch (      Exception e1) {
        throw new NoFromStringConversionExistsException(type,e,e1);
      }
    }
  }
}
Program: 88483
Project: 88483
Buggy source:
/** 
 * Try to load given type class
 * @param value
 * @return
 */
private static <Type>Type classFromString(String value){
  value=maybeObjectify(value);
  ClassLoader[] used=new ClassLoader[]{value.getClass().getClassLoader(),Utils.class.getClassLoader(),Thread.currentThread().getContextClassLoader()};
  for (  ClassLoader c : used) {
    if (c != null) {
      try {
        return (Type)c.loadClass(value);
      }
 catch (      ClassNotFoundException e) {
      }
    }
  }
  throw new UnableToLoadClassException(value,used);
}

Fixed version (ground truth):
/** 
 * Try to load given type class
 * @param value
 * @return
 */
@SuppressWarnings("String_Node_Str") private static <Type>Type classFromString(String value){
  value=maybeObjectify(value);
  ClassLoader[] used=new ClassLoader[]{value.getClass().getClassLoader(),Utils.class.getClassLoader(),Thread.currentThread().getContextClassLoader()};
  for (  ClassLoader c : used) {
    if (c != null) {
      try {
        return (Type)c.loadClass(value);
      }
 catch (      ClassNotFoundException e) {
      }
    }
  }
  throw new UnableToLoadClassException(value,used);
}
Program: 88484
Project: 88484
Buggy source:
protected abstract <Type,InformerType extends Informer<Type>>FinderCrudService<Type,InformerType> createServiceFor(Class<Type> beanClass,Class<InformerType> informerClass);

Fixed version (ground truth):
public abstract <Type,InformerType extends Informer<Type>>FinderCrudService<Type,InformerType> createServiceFor(Class<Type> beanClass,Class<InformerType> informerClass);
Program: 88485
Project: 88485
Buggy source:
@After public void unload() throws Exception {
  if (graph != null) {
    graph.shutdown();
  }
  File f=new File(GraphProvider.GRAPH_DIR);
  f.delete();
}

Fixed version (ground truth):
@After public void unload() throws Exception {
  if (graph != null) {
    graph.shutdown();
    graph=null;
  }
  File f=new File(graphPath());
  FileUtils.deleteRecursively(f);
}
Program: 88486
Project: 88486
Buggy source:
public void loadService() throws Exception {
  repository=new SimpleServiceRepository();
  provider=new FieldBackedPropertyProvider();
  locator=new CumulativeFieldInformerLocator();
  locator.add(new BasicFieldInformerLocator());
  locator.add(new ServiceBackedFieldLocator(repository));
  locator.add(new LazyInterfaceInformerLocator());
  reflectiveFactory=new ReflectionBackedInformerFactory(locator,provider);
  proxyInformerFactory=new ProxyBackedInformerFactory(reflectiveFactory);
  graph=createGraph(graphProvider);
  repository.add(createServiceFor(Tag.class,TagInformer.class));
  repository.add(createServiceFor(Post.class,PostInformer.class));
  repository.add(createServiceFor(PostSubClass.class,PostSubClassInformer.class));
  repository.add(createServiceFor(User.class,UserInformer.class));
  repository.add(createServiceFor(Theme.class,ThemeInformer.class));
  tagService=repository.get(Tag.class);
  postService=repository.get(Post.class);
  postSubService=repository.get(PostSubClass.class);
  userService=repository.get(User.class);
  themeService=repository.get(Theme.class);
}

Fixed version (ground truth):
public void loadService() throws Exception {
  serviceRrepository=new SimpleServiceRepository();
  provider=new FieldBackedPropertyProvider();
  locator=new CumulativeFieldInformerLocator();
  locator.add(new BasicFieldInformerLocator());
  locator.add(new ServiceBackedFieldLocator(serviceRrepository));
  locator.add(new LazyInterfaceInformerLocator());
  reflectiveFactory=new ReflectionBackedInformerFactory(locator,provider);
  proxyInformerFactory=new ProxyBackedInformerFactory(reflectiveFactory);
  graph=createGraph(graphProvider);
  serviceRrepository.add(createServiceFor(Tag.class,TagInformer.class));
  serviceRrepository.add(createServiceFor(Post.class,PostInformer.class));
  serviceRrepository.add(createServiceFor(PostSubClass.class,PostSubClassInformer.class));
  serviceRrepository.add(createServiceFor(User.class,UserInformer.class));
  serviceRrepository.add(createServiceFor(Theme.class,ThemeInformer.class));
  tagService=serviceRrepository.get(Tag.class);
  postService=serviceRrepository.get(Post.class);
  postSubService=serviceRrepository.get(PostSubClass.class);
  userService=serviceRrepository.get(User.class);
  themeService=serviceRrepository.get(Theme.class);
}
Program: 88487
Project: 88487
Buggy source:
protected SailRepository getRepository(){
  return environment.getRepository();
}

Fixed version (ground truth):
protected SailRepository getRepository(){
  return environment.getSailRepository();
}
Program: 88488
Project: 88488
Buggy source:
@Test @Ignore public void ensureMapCanBeEmptiedForIssue13() throws Exception {
  final String text="String_Node_Str";
  Post newxONe=new Post().withText(text).withAuthor(author);
  newxONe=getPostService().create(newxONe);
  try {
    newxONe.annotations.put(A,null);
    getPostService().update(newxONe);
    newxONe=getPostService().find().matching(new FindPostByText(text)).getFirst();
    assertThat(newxONe.annotations.size(),Is.is(1));
    assertThat(newxONe.annotations.containsKey(A),Is.is(true));
    newxONe.annotations.clear();
    getPostService().update(newxONe);
    newxONe=getPostService().find().matching(new FindPostByText(text)).getFirst();
    assertThat(newxONe.annotations.size(),Is.is(0));
  }
 catch (  Exception e) {
    if (logger.isLoggable(Level.SEVERE)) {
      logger.log(Level.SEVERE,"String_Node_Str",e);
    }
    throw e;
  }
 finally {
    getPostService().delete(newxONe);
  }
}

Fixed version (ground truth):
@Test public void ensureMapCanBeEmptiedForIssue13() throws Exception {
  final String text="String_Node_Str";
  Post newxONe=new Post().withText(text).withAuthor(author);
  newxONe=getPostService().create(newxONe);
  try {
    newxONe.annotations.put(A,null);
    getPostService().update(newxONe);
    newxONe=getPostService().find().matching(new FindPostByText(text)).getFirst();
    assertThat(newxONe.annotations.size(),Is.is(1));
    assertThat(newxONe.annotations.containsKey(A),Is.is(true));
    newxONe.annotations.clear();
    getPostService().update(newxONe);
    newxONe=getPostService().find().matching(new FindPostByText(text)).getFirst();
    assertThat(newxONe.annotations.size(),Is.is(0));
  }
 catch (  Exception e) {
    if (logger.isLoggable(Level.SEVERE)) {
      logger.log(Level.SEVERE,"String_Node_Str",e);
    }
    throw e;
  }
 finally {
    getPostService().delete(newxONe);
  }
}
Program: 88489
Project: 88489
Buggy source:
@Test @Ignore public void ensureMapWorksInAllCases() throws Exception {
  Post newxONe=new Post().withText(SOME_NEW_TEXT).withAuthor(author);
  final long id=newxONe.id;
  newxONe=getPostService().create(newxONe);
  try {
    newxONe.annotations.put(A,null);
    getPostService().update(newxONe);
    newxONe=getPostService().find().matching(new FindPostByText(SOME_NEW_TEXT)).getFirst();
    assertThat(newxONe.annotations.size(),Is.is(1));
    assertThat(newxONe.annotations.containsKey(A),Is.is(true));
  }
 catch (  Exception e) {
    if (logger.isLoggable(Level.SEVERE)) {
      logger.log(Level.SEVERE,"String_Node_Str",e);
    }
    throw e;
  }
 finally {
    getPostService().delete(newxONe);
  }
}

Fixed version (ground truth):
@Test public void ensureMapWorksInAllCases() throws Exception {
  Post newxONe=new Post().withText(SOME_NEW_TEXT).withAuthor(author);
  final long id=newxONe.id;
  newxONe=getPostService().create(newxONe);
  try {
    newxONe.annotations.put(A,null);
    getPostService().update(newxONe);
    newxONe=getPostService().find().matching(new FindPostByText(SOME_NEW_TEXT)).getFirst();
    assertThat(newxONe.annotations.size(),Is.is(1));
    assertThat(newxONe.annotations.containsKey(A),Is.is(true));
  }
 catch (  Exception e) {
    if (logger.isLoggable(Level.SEVERE)) {
      logger.log(Level.SEVERE,"String_Node_Str",e);
    }
    throw e;
  }
 finally {
    getPostService().delete(newxONe);
  }
}
Program: 88490
Project: 88490
Buggy source:
@Test @Ignore public void ensureUpdateOnCreateWorks() throws IOException, ClassNotFoundException {
  Post newxONe=new Post().withText(SOME_NEW_TEXT).withAuthor(author);
  author.setLogin(LOGIN_FOR_UPDATE_ON_CREATE);
  tag1.setText(TEST_TAG_FOR_CREATE_ON_UPDATE);
  newxONe.tags.add(tag1);
  newxONe=getPostService().create(newxONe);
  try {
    author=getUserService().find().matching(new QueryBuilder<UserInformer>(){
      @Override public QueryExpression createMatchingExpression(      UserInformer informer){
        return informer.getPassword().equalsTo(author.password);
      }
    }
).getFirst();
    assertThat(author.getLogin(),Is.is(LOGIN_FOR_UPDATE_ON_CREATE));
    Tag official=getTagService().find().matching(new QueryBuilder<TagInformer>(){
      @Override public QueryExpression createMatchingExpression(      TagInformer informer){
        return informer.getId().equalsTo(tag1.getId());
      }
    }
).getFirst();
    assertThat(official.getText(),Is.is(TEST_TAG_FOR_CREATE_ON_UPDATE));
  }
  finally {
    getPostService().delete(newxONe);
    tag1.setText(TAG_TEXT);
    getTagService().update(tag1);
  }
}

Fixed version (ground truth):
@Test public void ensureUpdateOnCreateWorks() throws IOException, ClassNotFoundException {
  Post newxONe=new Post().withText(SOME_NEW_TEXT).withAuthor(author);
  author.setLogin(LOGIN_FOR_UPDATE_ON_CREATE);
  tag1.setText(TEST_TAG_FOR_CREATE_ON_UPDATE);
  newxONe.tags.add(tag1);
  newxONe=getPostService().create(newxONe);
  try {
    author=getUserService().find().matching(new QueryBuilder<UserInformer>(){
      @Override public QueryExpression createMatchingExpression(      UserInformer informer){
        return informer.getPassword().equalsTo(author.password);
      }
    }
).getFirst();
    assertThat(author.getLogin(),Is.is(LOGIN_FOR_UPDATE_ON_CREATE));
    Tag official=getTagService().find().matching(new QueryBuilder<TagInformer>(){
      @Override public QueryExpression createMatchingExpression(      TagInformer informer){
        return informer.getId().equalsTo(tag1.getId());
      }
    }
).getFirst();
    assertThat(official.getText(),Is.is(TEST_TAG_FOR_CREATE_ON_UPDATE));
  }
  finally {
    getPostService().delete(newxONe);
    tag1.setText(TAG_TEXT);
    getTagService().update(tag1);
  }
}
Program: 88491
Project: 88491
Buggy source:
@Test @Ignore public void ensurePostIdCanBeGenerated() throws IOException, ClassNotFoundException {
  Post newOne=new Post().withText("String_Node_Str");
  assertThat(newOne.id,Is.is(0l));
  newOne=getPostService().create(newOne);
  assertThat(newOne.id,IsNot.not(0l));
}

Fixed version (ground truth):
@Test public void ensurePostIdCanBeGenerated() throws IOException, ClassNotFoundException {
  Post newOne=new Post().withText("String_Node_Str");
  assertThat(newOne.id,Is.is(0l));
  newOne=getPostService().create(newOne);
  assertThat(newOne.id,IsNot.not(0l));
}
Program: 88492
Project: 88492
Buggy source:
/** 
 * Create all required environments by replacing   {@link GraphProvider} instance with pairs
 * @param loadTestProviders
 * @return
 */
private static Collection<Object[]> environmentsFor(Collection<Object[]> providers){
  Collection<Object[]> returned=new LinkedList<Object[]>();
  for (  Object[] p : providers) {
    returned.add(covnertProviderToEnvironment(p,new EnvironmentCreator(){
      @Override public Object environmentFor(      GraphProvider o){
        return new SailGraphEnvironment(o);
      }
    }
).toArray());
  }
  return returned;
}

Fixed version (ground truth):
/** 
 * Create all required environments by replacing   {@link GraphProvider} instance with pairs
 * @param loadTestProviders
 * @return
 */
private static Collection<Object[]> environmentsFor(Collection<Object[]> providers){
  Collection<Object[]> returned=new LinkedList<Object[]>();
  for (  Object[] p : providers) {
    returned.add(covnertProviderToEnvironment(p,new EnvironmentCreator(){
      @Override public Object environmentFor(      GraphProvider o){
        return new IndexableGraphEnvironment(o);
      }
    }
).toArray());
  }
  return returned;
}
Program: 88493
Project: 88493
Buggy source:
@Override protected <Type,InformerType extends Informer<Type>>FinderCrudService<Type,InformerType> createServiceFor(Class<Type> beanClass,Class<InformerType> informerClass){
  return new IndexableGraphBackedFinderService(beanClass,informerClass,proxyInformerFactory,repository,provider,graph);
}

Fixed version (ground truth):
@Override public <Type,InformerType extends Informer<Type>>FinderCrudService<Type,InformerType> createServiceFor(Class<Type> beanClass,Class<InformerType> informerClass){
  return new IndexableGraphBackedFinderService(beanClass,informerClass,getInformerFactory(),getServiceRrepository(),getProvider(),graph);
}
Program: 88494
Project: 88494
Buggy source:
@Override public IndexableGraph get(String path){
  return new TinkerGraph(path(path));
}

Fixed version (ground truth):
@Override public IndexableGraph get(String path){
  String fullPath=path(path);
  File f=new File(fullPath);
  return new TinkerGraph(f.getAbsolutePath());
}
Program: 88495
Project: 88495
Buggy source:
protected <Type,InformerType extends Informer<Type>>FinderCrudService<Type,InformerType> createServiceFor(Class<Type> beanClass,Class<InformerType> informerClass){
  return new SailGraphBackedFinderService(beanClass,informerClass,proxyInformerFactory,repository,provider,graph);
}

Fixed version (ground truth):
public <Type,InformerType extends Informer<Type>>FinderCrudService<Type,InformerType> createServiceFor(Class<Type> beanClass,Class<InformerType> informerClass){
  return new SailGraphBackedFinderService(beanClass,informerClass,getInformerFactory(),getServiceRrepository(),getProvider(),graph);
}
Program: 88497
Project: 88497
Buggy source:
/** 
 * Gets the id vertex for the given object (if that object exists)
 * @param object
 * @return first matching node if found, and null if not
 */
private Vertex getIdVertexFor(DataType object){
  return GraphUtils.locateVertex(database,Properties.vertexId.name(),getIdVertexId(object,idProperty,false));
}

Fixed version (ground truth):
/** 
 * Gets the id vertex for the given object (if that object exists)
 * @param object object to get id vertex for
 * @param allowIdGeneration when set to true, an id may be created for that object
 * @return first matching node if found, and null if not
 */
private Vertex getIdVertexFor(DataType object,boolean allowIdGeneration){
  return GraphUtils.locateVertex(database,Properties.vertexId.name(),getIdVertexId(object,idProperty,allowIdGeneration));
}
Program: 88498
Project: 88498
Buggy source:
/** 
 * Set id of object, and try to assign that object a vertex.
 * @param value
 * @param id
 * @return
 * @see com.dooapp.gaedo.finders.id.IdBasedService#assignId(java.lang.Object,java.lang.Object[])
 */
@Override public boolean assignId(final DataType value,Object... id){
  if (containedClass.isInstance(value)) {
    idProperty.set(value,id[0]);
    if (getIdVertexFor(value) == null) {
      try {
        TransactionalOperation<Boolean> operation=new TransactionalOperation<Boolean>(){
          @Override protected Boolean doPerform(){
            persister.createIdVertex(database,value.getClass(),getIdVertexId(value,idProperty,requiresIdGeneration));
            return true;
          }
        }
;
        return operation.perform();
      }
 catch (      Exception e) {
        return false;
      }
    }
 else {
      return false;
    }
  }
 else {
    return false;
  }
}

Fixed version (ground truth):
/** 
 * Set id of object, and try to assign that object a vertex.
 * @param value
 * @param id
 * @return
 * @see com.dooapp.gaedo.finders.id.IdBasedService#assignId(java.lang.Object,java.lang.Object[])
 */
@Override public boolean assignId(final DataType value,Object... id){
  if (containedClass.isInstance(value)) {
    idProperty.set(value,id[0]);
    if (getIdVertexFor(value,false) == null) {
      try {
        TransactionalOperation<Boolean> operation=new TransactionalOperation<Boolean>(){
          @Override protected Boolean doPerform(){
            persister.createIdVertex(database,value.getClass(),getIdVertexId(value,idProperty,requiresIdGeneration));
            return true;
          }
        }
;
        return operation.perform();
      }
 catch (      Exception e) {
        return false;
      }
    }
 else {
      return false;
    }
  }
 else {
    return false;
  }
}
Program: 88499
Project: 88499
Buggy source:
@Test public void ensureCreateOnUpdateWorks() throws IOException, ClassNotFoundException {
  Post first=postService.find().matching(new FindFirstPostByNote()).getFirst();
  assertThat(first.tags.size(),Is.is(0));
  Tag t=new Tag();
  t.setText(TEST_TAG_FOR_CREATE_ON_UPDATE);
  first.tags.add(t);
  first=postService.update(first);
  Tag inDB=tagService.find().matching(new QueryBuilder<TagInformer>(){
    @Override public QueryExpression createMatchingExpression(    TagInformer informer){
      return informer.getText().equalsTo(TEST_TAG_FOR_CREATE_ON_UPDATE);
    }
  }
).getFirst();
  assertThat(inDB.getText(),Is.is(t.getText()));
  assertThat(inDB.getId(),IsNot.not(0l));
}

Fixed version (ground truth):
@Test public void ensureCreateOnUpdateWorks() throws IOException, ClassNotFoundException {
  Post first=postService.find().matching(new FindFirstPostByNote()).getFirst();
  if (first.tags.size() > 0) {
    first.tags.clear();
    first=postService.update(first);
  }
  assertThat(first.tags.size(),Is.is(0));
  Tag t=new Tag();
  t.setText(TEST_TAG_FOR_CREATE_ON_UPDATE);
  first.tags.add(t);
  first=postService.update(first);
  Tag inDB=tagService.find().matching(new QueryBuilder<TagInformer>(){
    @Override public QueryExpression createMatchingExpression(    TagInformer informer){
      return informer.getText().equalsTo(TEST_TAG_FOR_CREATE_ON_UPDATE);
    }
  }
).getFirst();
  assertThat(inDB.getText(),Is.is(t.getText()));
  assertThat(inDB.getId(),IsNot.not(0l));
}
Program: 88501
Project: 88501
Buggy source:
@Override public QueryExpression createMatchingExpression(TagInformer informer){
  return informer.getText().equalsTo(TEST_TAG_FOR_CREATE_ON_UPDATE);
}

Fixed version (ground truth):
@Override public QueryExpression createMatchingExpression(TagInformer informer){
  return informer.getId().equalsTo(tag1.getId());
}
Program: 88502
Project: 88502
Buggy source:
/** 
 * Set id of object, and try to assign that object a vertex.
 * @param value
 * @param id
 * @return
 * @see com.dooapp.gaedo.finders.id.IdBasedService#assignId(java.lang.Object,java.lang.Object[])
 */
@Override public boolean assignId(DataType value,Object... id){
  idProperty.set(value,id[0]);
  if (getIdVertexFor(value) == null) {
    try {
      persister.createIdVertex(database,containedClass,getIdVertexId(value,idProperty,requiresIdGeneration));
      return true;
    }
 catch (    Exception e) {
      return false;
    }
  }
 else {
    return false;
  }
}

Fixed version (ground truth):
/** 
 * Set id of object, and try to assign that object a vertex.
 * @param value
 * @param id
 * @return
 * @see com.dooapp.gaedo.finders.id.IdBasedService#assignId(java.lang.Object,java.lang.Object[])
 */
@Override public boolean assignId(DataType value,Object... id){
  if (containedClass.isInstance(value)) {
    idProperty.set(value,id[0]);
    if (getIdVertexFor(value) == null) {
      try {
        persister.createIdVertex(database,value.getClass(),getIdVertexId(value,idProperty,requiresIdGeneration));
        return true;
      }
 catch (      Exception e) {
        return false;
      }
    }
 else {
      return false;
    }
  }
 else {
    return false;
  }
}
Program: 88504
Project: 88504
Buggy source:
/** 
 * By default in this provider there is no particular entity
 * @param id
 * @return
 */
public boolean entityExists(String id){
  log.info(userInfo() + "String_Node_Str" + id);
  if (id.equals("String_Node_Str")) {
    return true;
  }
  return false;
}

Fixed version (ground truth):
public boolean entityExists(String id){
  log.info(userInfo() + "String_Node_Str" + id);
  if (id.equals("String_Node_Str")) {
    return true;
  }
  return false;
}
Program: 88505
Project: 88505
Buggy source:
public Object getSampleEntity(){
  return new CollectionEntity();
}

Fixed version (ground truth):
public Object getSampleEntity(){
  return new StatsEntity();
}
Program: 88506
Project: 88506
Buggy source:
/** 
 * Here are statistical data extracted and returned as the list StatsEntity is used here to format and present data It could be done using HashMap for now it is not functioning, updates of related software needed
 * @param ref
 * @param search
 * @return
 * @see StatsEntity
 */
public List<?> getEntities(EntityReference ref,Search search){
  log.info(userInfo() + "String_Node_Str");
  Context context;
  try {
    context=new Context();
  }
 catch (  SQLException ex) {
    throw new EntityException("String_Node_Str","String_Node_Str",500);
  }
  refreshParams(context);
  List<Object> stat=new ArrayList<Object>();
  File reportDir=new File(ConfigurationManager.getProperty("String_Node_Str"));
  ReportGenerator rg=new ReportGenerator();
  File[] reports=reportDir.listFiles();
  try {
    for (    File report : reports) {
      Matcher genMatcher=analysisGeneralPattern.matcher(report.getName());
      Matcher monMatcher=analysisMonthlyPattern.matcher(report.getName());
      StatReport statReport=new StatReport();
      if (genMatcher.matches()) {
        statReport.setType("String_Node_Str");
        rg.processReport(context,statReport,report.getAbsolutePath());
        stat.add(statReport);
      }
 else       if (monMatcher.matches()) {
        statReport.setType("String_Node_Str");
        rg.processReport(context,statReport,report.getAbsolutePath());
        stat.add(statReport);
      }
    }
    removeConn(context);
    return stat;
  }
 catch (  SQLException ex) {
    throw new EntityException("String_Node_Str","String_Node_Str",500);
  }
catch (  Exception ex) {
    throw new EntityException("String_Node_Str","String_Node_Str",500);
  }
}

Fixed version (ground truth):
public List<?> getEntities(EntityReference ref,Search search){
  log.info(userInfo() + "String_Node_Str");
  Context context;
  try {
    context=new Context();
  }
 catch (  SQLException ex) {
    throw new EntityException("String_Node_Str","String_Node_Str",500);
  }
  refreshParams(context);
  List<Object> stat=new ArrayList<Object>();
  File reportDir=new File(ConfigurationManager.getProperty("String_Node_Str"));
  ReportGenerator rg=new ReportGenerator();
  File[] reports=reportDir.listFiles();
  try {
    for (    File report : reports) {
      Matcher genMatcher=analysisGeneralPattern.matcher(report.getName());
      Matcher monMatcher=analysisMonthlyPattern.matcher(report.getName());
      StatReport statReport=new StatReport();
      if (genMatcher.matches()) {
        statReport.setType("String_Node_Str");
        rg.processReport(context,statReport,report.getAbsolutePath());
        stat.add(statReport);
      }
 else       if (monMatcher.matches()) {
        statReport.setType("String_Node_Str");
        rg.processReport(context,statReport,report.getAbsolutePath());
        stat.add(statReport);
      }
    }
    removeConn(context);
    return stat;
  }
 catch (  SQLException ex) {
    throw new EntityException("String_Node_Str","String_Node_Str",500);
  }
catch (  Exception ex) {
    throw new EntityException("String_Node_Str","String_Node_Str",500);
  }
}
Program: 88508
Project: 88508
Buggy source:
public Object getAdministrators(EntityReference ref,UserRequestParams uparams,Context context){
  try {
    Community res=Community.find(context,Integer.parseInt(ref.getId()));
    AuthorizeManager.authorizeAction(context,res,Constants.READ);
    Group administrators=res.getAdministrators();
    if (administrators != null) {
      return new GroupEntityTrim(administrators);
    }
  }
 catch (  SQLException ex) {
    throw new EntityException("String_Node_Str","String_Node_Str",500);
  }
catch (  AuthorizeException ex) {
    throw new EntityException("String_Node_Str","String_Node_Str",403);
  }
  return new GroupEntity();
}

Fixed version (ground truth):
public Object getAdministrators(EntityReference ref,UserRequestParams uparams,Context context){
  try {
    Community res=Community.find(context,Integer.parseInt(ref.getId()));
    AuthorizeManager.authorizeAction(context,res,Constants.READ);
    Group administrators=res.getAdministrators();
    if (administrators != null) {
      return new GroupEntity(administrators);
    }
  }
 catch (  SQLException ex) {
    throw new EntityException("String_Node_Str","String_Node_Str",500);
  }
catch (  AuthorizeException ex) {
    throw new EntityException("String_Node_Str","String_Node_Str",403);
  }
  return new GroupEntityTrim();
}
Program: 88509
Project: 88509
Buggy source:
public GroupEntity(Group egroup){
  super(egroup);
  for (  EPerson member : egroup.getMembers()) {
    users.add(new UserEntity(member));
  }
  for (  Group group : egroup.getMemberGroups()) {
    groups.add(new GroupEntity(group));
  }
}

Fixed version (ground truth):
public GroupEntity(Group egroup){
  super(egroup);
  for (  EPerson member : egroup.getMembers()) {
    users.add(new UserEntityTrim(member));
  }
  for (  Group group : egroup.getMemberGroups()) {
    if (group.getMemberGroups().length > 0) {
      groups.add(new GroupEntity(group));
    }
 else {
      groups.add(new GroupEntityTrim(group));
    }
  }
}
Program: 88510
Project: 88510
Buggy source:
public UserEntity(int id,String firstName,String lastName,String fullName,String email){
  this.id=id;
  this.firstName=firstName;
  this.lastName=lastName;
  this.fullName=fullName;
  this.email=email;
}

Fixed version (ground truth):
public UserEntity(int id,String firstName,String lastName,String fullName,String email){
  super(id,firstName,lastName,fullName,email);
}
Program: 88513
Project: 88513
Buggy source:
public UserProvider(EntityProviderManager entityProviderManager) throws SQLException, NoSuchMethodException {
  super(entityProviderManager);
  entityProviderManager.registerEntityProvider(this);
  processedEntity=UserEntity.class;
  func2actionMapGET.put("String_Node_Str","String_Node_Str");
  func2actionMapGET.put("String_Node_Str","String_Node_Str");
  func2actionMapGET.put("String_Node_Str","String_Node_Str");
  func2actionMapGET.put("String_Node_Str","String_Node_Str");
  func2actionMapGET.put("String_Node_Str","String_Node_Str");
  func2actionMapGET.put("String_Node_Str","String_Node_Str");
  func2actionMapGET.put("String_Node_Str","String_Node_Str");
  func2actionMapGET.put("String_Node_Str","String_Node_Str");
  func2actionMapGET.put("String_Node_Str","String_Node_Str");
  func2actionMapGET.put("String_Node_Str","String_Node_Str");
  func2actionMapGET.put("String_Node_Str","String_Node_Str");
  func2actionMapGET.put("String_Node_Str","String_Node_Str");
  func2actionMapPOST.put("String_Node_Str","String_Node_Str");
  inputParamsPOST.put("String_Node_Str",new String[]{"String_Node_Str","String_Node_Str"});
  entityConstructor=processedEntity.getDeclaredConstructor(new Class<?>[]{String.class,Context.class,Integer.TYPE,UserRequestParams.class});
  entityConstructor2=processedEntity.getDeclaredConstructor(new Class<?>[]{Context.class,Integer.TYPE,UserRequestParams.class});
  initMappings(processedEntity);
}

Fixed version (ground truth):
public UserProvider(EntityProviderManager entityProviderManager) throws SQLException, NoSuchMethodException {
  super(entityProviderManager);
  entityProviderManager.registerEntityProvider(this);
  processedEntity=UserEntity.class;
  func2actionMapGET.put("String_Node_Str","String_Node_Str");
  func2actionMapGET.put("String_Node_Str","String_Node_Str");
  func2actionMapGET.put("String_Node_Str","String_Node_Str");
  func2actionMapGET.put("String_Node_Str","String_Node_Str");
  func2actionMapGET.put("String_Node_Str","String_Node_Str");
  func2actionMapGET.put("String_Node_Str","String_Node_Str");
  func2actionMapGET.put("String_Node_Str","String_Node_Str");
  func2actionMapGET.put("String_Node_Str","String_Node_Str");
  func2actionMapGET.put("String_Node_Str","String_Node_Str");
  func2actionMapGET.put("String_Node_Str","String_Node_Str");
  func2actionMapGET.put("String_Node_Str","String_Node_Str");
  func2actionMapGET.put("String_Node_Str","String_Node_Str");
  func2actionMapPOST.put("String_Node_Str","String_Node_Str");
  inputParamsPOST.put("String_Node_Str",new String[]{"String_Node_Str","String_Node_Str"});
  entityConstructor=processedEntity.getDeclaredConstructor(new Class<?>[]{String.class,Context.class,Integer.TYPE,UserRequestParams.class});
  initMappings(processedEntity);
}
Program: 88515
Project: 88515
Buggy source:
@Override public String transform(String s){
  return transform(s).toLowerCase();
}

Fixed version (ground truth):
@Override public String transform(String s){
  return st.transform(s).toLowerCase();
}
Program: 88516
Project: 88516
Buggy source:
private void setLanguagePreference(String preference){
  Utility.storeUserProfileEntry(Utility.getQualifiedUsername(),"String_Node_Str",null,Utility.getQualifiedUsername(),preference,null);
  String newURL=Window.Location.createUrlBuilder().setParameter(LocaleInfo.getLocaleQueryParam(),preference).buildString();
  Window.Location.replace(newURL);
}

Fixed version (ground truth):
private void setLanguagePreference(String preference){
  Utility.storeUserProfileEntry(Utility.getQualifiedUsername(),"String_Node_Str",null,Utility.getQualifiedUsername(),preference,"String_Node_Str");
  String newURL=Window.Location.createUrlBuilder().setParameter(LocaleInfo.getLocaleQueryParam(),preference).buildString();
  Window.Location.replace(newURL);
}