nus-yam/ex-repair huggingface dataset:
Program: 91549
Project: 91549
Buggy source:
private static List<Class<?>> findPropertyParameterizedType(Object entity,String prop){
  Class<?> c=entity.getClass();
  while (null != c && !Object.class.equals(c)) {
    try {
      String p=S.capFirst(prop);
      String getter="String_Node_Str" + p;
      Method m=c.getDeclaredMethod(getter);
      m.setAccessible(true);
      Type type=m.getGenericReturnType();
      if (type instanceof ParameterizedType) {
        ParameterizedType ptype=cast(type);
        return findArgumentTypes(ptype);
      }
 else {
        return null;
      }
    }
 catch (    NoSuchMethodException e) {
      try {
        Method m=c.getDeclaredMethod(prop);
        m.setAccessible(true);
        Type type=m.getGenericReturnType();
        if (type instanceof ParameterizedType) {
          ParameterizedType ptype=cast(type);
          return findArgumentTypes(ptype);
        }
      }
 catch (      NoSuchMethodException e1) {
        try {
          Field f=c.getDeclaredField(prop);
          f.setAccessible(true);
          Type type=f.getGenericType();
          if (type instanceof ParameterizedType) {
            ParameterizedType ptype=cast(type);
            return findArgumentTypes(ptype);
          }
        }
 catch (        NoSuchFieldException e2) {
          c=c.getSuperclass();
        }
      }
    }
  }
  throw E.unexpected("String_Node_Str",prop,entity.getClass());
}

Fixed version (ground truth):
private static List<Class<?>> findPropertyParameterizedType(Object entity,String prop){
  Class<?> c=entity.getClass();
  while (null != c && !Object.class.equals(c)) {
    try {
      String p=S.capFirst(prop);
      String getter="String_Node_Str" + p;
      Method m=findPropertyMethod(c,getter);
      m.setAccessible(true);
      Type type=m.getGenericReturnType();
      if (type instanceof ParameterizedType) {
        ParameterizedType ptype=cast(type);
        return findArgumentTypes(ptype);
      }
 else {
        return null;
      }
    }
 catch (    NoSuchMethodException e) {
      try {
        Method m=findPropertyMethod(c,prop);
        m.setAccessible(true);
        Type type=m.getGenericReturnType();
        if (type instanceof ParameterizedType) {
          ParameterizedType ptype=cast(type);
          return findArgumentTypes(ptype);
        }
      }
 catch (      NoSuchMethodException e1) {
        try {
          Field f=findPropertyField(c,prop);
          f.setAccessible(true);
          Type type=f.getGenericType();
          if (type instanceof ParameterizedType) {
            ParameterizedType ptype=cast(type);
            return findArgumentTypes(ptype);
          }
        }
 catch (        NoSuchFieldException e2) {
          c=c.getSuperclass();
        }
      }
    }
  }
  return null;
}
Program: 91550
Project: 91550
Buggy source:
private static <T>T getProperty(CacheService cache,Object entity,String... propertyPath){
  if (null == entity) {
    return null;
  }
  int len=propertyPath.length;
  E.illegalArgumentIf(len < 1);
  Object lastEntity=null;
  for (int i=0; i < len; ++i) {
    String prop=propertyPath[i];
    String lastProp=i == 0 ? prop : propertyPath[i - 1];
    if (entity instanceof List) {
      List<Class<?>> classList=findPropertyParameterizedType(lastEntity,lastProp);
      ListPropertyGetter getter=propertyHandlerFactory.createListPropertyGetter(classList.get(0));
      lastEntity=entity;
      entity=getter.get(lastEntity,prop);
    }
 else     if (entity instanceof Map) {
      List<Class<?>> classList=findPropertyParameterizedType(lastEntity,lastProp);
      if (null == classList) {
        PropertyGetter getter=propertyGetter(cache,entity,prop,false);
        lastEntity=entity;
        entity=getter.get(entity,null);
      }
 else {
        MapPropertyGetter getter=propertyHandlerFactory.createMapPropertyGetter(classList.get(0),classList.get(1));
        lastEntity=entity;
        entity=getter.get(lastEntity,prop);
      }
    }
 else {
      PropertyGetter getter=propertyGetter(cache,entity,prop,false);
      lastEntity=entity;
      entity=getter.get(entity,null);
    }
    if (null == entity) {
      return null;
    }
  }
  return (T)entity;
}

Fixed version (ground truth):
private static <T>T getProperty(CacheService cache,Object entity,String... propertyPath){
  if (null == entity) {
    return null;
  }
  int len=propertyPath.length;
  E.illegalArgumentIf(len < 1);
  Object lastEntity=null;
  for (int i=0; i < len; ++i) {
    String prop=propertyPath[i];
    String lastProp=i == 0 ? prop : propertyPath[i - 1];
    if (entity instanceof ValueObject) {
      ValueObject vo=(ValueObject)entity;
      if (vo.isUDF()) {
        entity=vo.value();
      }
    }
    if (entity instanceof List) {
      List<Class<?>> classList=findPropertyParameterizedType(lastEntity,lastProp);
      ListPropertyGetter getter=propertyHandlerFactory.createListPropertyGetter(classList.get(0));
      lastEntity=entity;
      entity=getter.get(lastEntity,prop);
    }
 else     if (entity instanceof Map) {
      List<Class<?>> classList=findPropertyParameterizedType(lastEntity,lastProp);
      if (null == classList) {
        PropertyGetter getter=propertyGetter(cache,entity,prop,false);
        lastEntity=entity;
        entity=getter.get(entity,prop);
      }
 else {
        MapPropertyGetter getter=propertyHandlerFactory.createMapPropertyGetter(classList.get(0),classList.get(1));
        lastEntity=entity;
        entity=getter.get(lastEntity,prop);
      }
    }
 else {
      PropertyGetter getter=propertyGetter(cache,entity,prop,false);
      lastEntity=entity;
      entity=getter.get(entity,null);
    }
    if (null == entity) {
      return null;
    }
  }
  return (T)entity;
}
Program: 91551
Project: 91551
Buggy source:
@Override public T resolve(String value){
  return func.apply(value);
}

Fixed version (ground truth):
@Override public FastStr resolve(String value){
  if (null == value) {
    return null;
  }
  return FastStr.of(value);
}
Program: 91553
Project: 91553
Buggy source:
private PropertyGetter getterViaField(Class entityClass,String propName){
  while (!Object.class.equals(entityClass)) {
    try {
      Field f=entityClass.getDeclaredField(propName);
      f.setAccessible(true);
      return newGetter(entityClass,null,f);
    }
 catch (    NoSuchFieldException e3) {
      entityClass=entityClass.getSuperclass();
      throw E.unexpected(e3,"String_Node_Str",propName,entityClass);
    }
  }
  throw E.unexpected("String_Node_Str");
}

Fixed version (ground truth):
private PropertyGetter getterViaField(Class entityClass,String propName){
  while (!Object.class.equals(entityClass)) {
    try {
      Field f=entityClass.getDeclaredField(propName);
      f.setAccessible(true);
      return newGetter(entityClass,null,f);
    }
 catch (    NoSuchFieldException e3) {
      entityClass=entityClass.getSuperclass();
    }
  }
  throw E.unexpected("String_Node_Str",propName,entityClass);
}
Program: 91554
Project: 91554
Buggy source:
@Override public PropertySetter createPropertySetter(Class c,String propName){
  String p=S.capFirst(propName);
  String setter="String_Node_Str" + p;
  String isser="String_Node_Str" + p;
  Method[] ma=c.getMethods();
  for (  Method m : ma) {
    String mn=m.getName();
    if (S.neq(setter,mn) && S.neq(isser,mn) && S.neq(p,mn)) {
      continue;
    }
    Class[] ca=m.getParameterTypes();
    if (ca != null && ca.length == 1) {
      return newSetter(c,m,null);
    }
  }
  try {
    Field f=c.getDeclaredField(propName);
    f.setAccessible(true);
    return newSetter(c,null,f);
  }
 catch (  NoSuchFieldException e) {
    throw E.unexpected(e,"String_Node_Str",propName,c);
  }
}

Fixed version (ground truth):
@Override public PropertySetter createPropertySetter(Class c,String propName){
  String p=S.capFirst(propName);
  String setter="String_Node_Str" + p;
  String isser="String_Node_Str" + p;
  Method[] ma=c.getMethods();
  for (  Method m : ma) {
    String mn=m.getName();
    if (S.neq(setter,mn) && S.neq(isser,mn) && S.neq(p,mn)) {
      continue;
    }
    Class[] ca=m.getParameterTypes();
    if (ca != null && ca.length == 1) {
      return newSetter(c,m,null);
    }
  }
  return setterViaField(c,propName);
}
Program: 91555
Project: 91555
Buggy source:
@Override public Object get(Object entity,Object index){
  List list=(List)entity;
  int id=-1;
  if (index instanceof Integer) {
    id=(Integer)index;
  }
 else {
    String s=S.string(index);
    if (S.notBlank(s)) {
      id=Integer.parseInt(s);
    }
  }
  Object val=null;
  if (id > -1 && id <= list.size()) {
    val=list.get(id);
  }
  if (null == val) {
switch (nullValuePolicy) {
case NPE:
      throw new NullPointerException();
case CREATE_NEW:
    val=objectFactory.apply(itemType);
  if (id < 0) {
    list.add(val);
  }
 else   if (id >= list.size()) {
    for (int i=list.size(); i < id - 1; ++i) {
      list.add(null);
    }
    list.add(val);
  }
 else {
    list.set(id,val);
  }
default :
}
}
return val;
}

Fixed version (ground truth):
@Override public Object get(Object entity,Object index){
  List list=(List)entity;
  int id=-1;
  if (index instanceof Integer) {
    id=(Integer)index;
  }
 else {
    String s=S.string(index);
    if (S.notBlank(s)) {
      id=Integer.parseInt(s);
    }
  }
  Object val=null;
  if (id > -1 && id < list.size()) {
    val=list.get(id);
  }
  if (null == val) {
switch (nullValuePolicy) {
case NPE:
      throw new NullPointerException();
case CREATE_NEW:
    val=objectFactory.apply(itemType);
  if (id < 0) {
    list.add(val);
  }
 else   if (id >= list.size()) {
    for (int i=list.size(); i < id - 1; ++i) {
      list.add(null);
    }
    list.add(val);
  }
 else {
    list.set(id,val);
  }
default :
}
}
return val;
}
Program: 91556
Project: 91556
Buggy source:
ReflectionPropertyGetter(NullValuePolicy nullValuePolicy,Class entityClass,Method m,Field f){
  super(nullValuePolicy,entityClass,m,f);
}

Fixed version (ground truth):
public ReflectionPropertyGetter(NullValuePolicy nullValuePolicy,Class entityClass,Method m,Field f){
  super(nullValuePolicy,entityClass,m,f);
}
Program: 91557
Project: 91557
Buggy source:
@Override public PropertySetter setter(){
  return new ReflectionPropertySetter(entityClass,m,f);
}

Fixed version (ground truth):
@Override public PropertySetter setter(){
  String prop;
  if (null != m) {
    prop=m.getName();
    if (prop.startsWith("String_Node_Str")) {
      prop=prop.substring(3);
    }
  }
 else {
    prop=f.getName();
  }
  return factory.createPropertySetter(entityClass,prop);
}
Program: 91558
Project: 91558
Buggy source:
protected PropertyGetter newGetter(Class c,Method m,Field f){
  return new ReflectionPropertyGetter(c,m,f);
}

Fixed version (ground truth):
protected PropertyGetter newGetter(Class c,Method m,Field f){
  return new ReflectionPropertyGetter(c,m,f,this);
}
Program: 91559
Project: 91559
Buggy source:
ReflectionPropertySetter(Osgl.Function<Class<?>,Object> objectFactory,Osgl.Func2<String,Class<?>,?> stringValueResolver,Class entityClass,Method m,Field f){
  super(objectFactory,stringValueResolver,PropertyGetter.NullValuePolicy.CREATE_NEW,entityClass,m,f);
}

Fixed version (ground truth):
public ReflectionPropertySetter(Osgl.Function<Class<?>,Object> objectFactory,Osgl.Func2<String,Class<?>,?> stringValueResolver,Class entityClass,Method m,Field f){
  super(objectFactory,stringValueResolver,PropertyGetter.NullValuePolicy.CREATE_NEW,entityClass,m,f);
}
Program: 91560
Project: 91560
Buggy source:
@Override public boolean equals(Object obj){
  if (obj == this) {
    return true;
  }
  if (obj instanceof Option) {
    Option that=(Option)obj;
    return eq(get(),that.get());
  }
  return false;
}

Fixed version (ground truth):
@Override public boolean equals(Object o){
  if (o == this) {
    return true;
  }
  if (o instanceof Var) {
    Var v=(Var)o;
    return $.eq(v.get(),this.get());
  }
  return false;
}
Program: 91561
Project: 91561
Buggy source:
private static List<Class<?>> findPropertyParameterizedType(Object entity,String prop){
  Class<?> c=entity.getClass();
  while (null != c && !Object.class.equals(c)) {
    try {
      String p=S.capFirst(prop);
      String getter="String_Node_Str" + p;
      Method m=c.getDeclaredMethod(getter);
      m.setAccessible(true);
      Type type=m.getGenericReturnType();
      if (type instanceof ParameterizedType) {
        ParameterizedType ptype=cast(type);
        return findArgumentTypes(ptype);
      }
    }
 catch (    NoSuchMethodException e) {
      try {
        Method m=c.getDeclaredMethod(prop);
        m.setAccessible(true);
        Type type=m.getGenericReturnType();
        if (type instanceof ParameterizedType) {
          ParameterizedType ptype=cast(type);
          return findArgumentTypes(ptype);
        }
      }
 catch (      NoSuchMethodException e1) {
        try {
          Field f=c.getDeclaredField(prop);
          f.setAccessible(true);
          Type type=f.getGenericType();
          if (type instanceof ParameterizedType) {
            ParameterizedType ptype=cast(type);
            return findArgumentTypes(ptype);
          }
        }
 catch (        NoSuchFieldException e2) {
          c=c.getSuperclass();
        }
      }
    }
  }
  throw E.unexpected("String_Node_Str",prop,entity.getClass());
}

Fixed version (ground truth):
private static List<Class<?>> findPropertyParameterizedType(Object entity,String prop){
  Class<?> c=entity.getClass();
  while (null != c && !Object.class.equals(c)) {
    try {
      String p=S.capFirst(prop);
      String getter="String_Node_Str" + p;
      Method m=c.getDeclaredMethod(getter);
      m.setAccessible(true);
      Type type=m.getGenericReturnType();
      if (type instanceof ParameterizedType) {
        ParameterizedType ptype=cast(type);
        return findArgumentTypes(ptype);
      }
 else {
        return null;
      }
    }
 catch (    NoSuchMethodException e) {
      try {
        Method m=c.getDeclaredMethod(prop);
        m.setAccessible(true);
        Type type=m.getGenericReturnType();
        if (type instanceof ParameterizedType) {
          ParameterizedType ptype=cast(type);
          return findArgumentTypes(ptype);
        }
      }
 catch (      NoSuchMethodException e1) {
        try {
          Field f=c.getDeclaredField(prop);
          f.setAccessible(true);
          Type type=f.getGenericType();
          if (type instanceof ParameterizedType) {
            ParameterizedType ptype=cast(type);
            return findArgumentTypes(ptype);
          }
        }
 catch (        NoSuchFieldException e2) {
          c=c.getSuperclass();
        }
      }
    }
  }
  throw E.unexpected("String_Node_Str",prop,entity.getClass());
}
Program: 91562
Project: 91562
Buggy source:
private static <T>T getProperty(CacheService cache,Object entity,String... propertyPath){
  if (null == entity) {
    return null;
  }
  int len=propertyPath.length;
  E.illegalArgumentIf(len < 1);
  Object lastEntity=null;
  for (int i=0; i < len; ++i) {
    String prop=propertyPath[i];
    String lastProp=i == 0 ? prop : propertyPath[i - 1];
    if (entity instanceof List) {
      List<Class<?>> classList=findPropertyParameterizedType(lastEntity,lastProp);
      ListPropertyGetter getter=propertyHandlerFactory.createListPropertyGetter(classList.get(0));
      lastEntity=entity;
      entity=getter.get(lastEntity,prop);
    }
 else     if (entity instanceof Map) {
      List<Class<?>> classList=findPropertyParameterizedType(lastEntity,lastProp);
      MapPropertyGetter getter=propertyHandlerFactory.createMapPropertyGetter(classList.get(0),classList.get(1));
      lastEntity=entity;
      entity=getter.get(lastEntity,prop);
    }
 else {
      PropertyGetter getter=propertyGetter(cache,entity,prop,false);
      lastEntity=entity;
      entity=getter.get(entity,null);
    }
    if (null == entity) {
      return null;
    }
  }
  return (T)entity;
}

Fixed version (ground truth):
private static <T>T getProperty(CacheService cache,Object entity,String... propertyPath){
  if (null == entity) {
    return null;
  }
  int len=propertyPath.length;
  E.illegalArgumentIf(len < 1);
  Object lastEntity=null;
  for (int i=0; i < len; ++i) {
    String prop=propertyPath[i];
    String lastProp=i == 0 ? prop : propertyPath[i - 1];
    if (entity instanceof List) {
      List<Class<?>> classList=findPropertyParameterizedType(lastEntity,lastProp);
      ListPropertyGetter getter=propertyHandlerFactory.createListPropertyGetter(classList.get(0));
      lastEntity=entity;
      entity=getter.get(lastEntity,prop);
    }
 else     if (entity instanceof Map) {
      List<Class<?>> classList=findPropertyParameterizedType(lastEntity,lastProp);
      if (null == classList) {
        PropertyGetter getter=propertyGetter(cache,entity,prop,false);
        lastEntity=entity;
        entity=getter.get(entity,null);
      }
 else {
        MapPropertyGetter getter=propertyHandlerFactory.createMapPropertyGetter(classList.get(0),classList.get(1));
        lastEntity=entity;
        entity=getter.get(lastEntity,prop);
      }
    }
 else {
      PropertyGetter getter=propertyGetter(cache,entity,prop,false);
      lastEntity=entity;
      entity=getter.get(entity,null);
    }
    if (null == entity) {
      return null;
    }
  }
  return (T)entity;
}
Program: 91563
Project: 91563
Buggy source:
public C.Set<T> toSet(){
  checkState();
  return (C.Set<T>)ImmutableSet.of(buf);
}

Fixed version (ground truth):
public C.Set<T> toSet(){
  checkState();
  trimToSize();
  Object[] data=buf;
  buf=null;
  return (C.Set<T>)ImmutableSet.of(data);
}
Program: 91564
Project: 91564
Buggy source:
public static void copyDirectory(File source,File target){
  if (source.isDirectory()) {
    if (!target.exists()) {
      target.mkdir();
    }
    for (    String child : source.list()) {
      copyDirectory(new File(source,child),new File(target,child));
    }
  }
 else {
    try {
      write(new FileInputStream(source),new FileOutputStream(target));
    }
 catch (    IOException e) {
      throw E.ioException(e);
    }
  }
}

Fixed version (ground truth):
public static void copyDirectory(File source,File target){
  if (source.isDirectory()) {
    if (!target.exists()) {
      target.mkdir();
    }
    for (    String child : source.list()) {
      copyDirectory(new File(source,child),new File(target,child));
    }
  }
 else {
    try {
      write(new FileInputStream(source),new FileOutputStream(target));
    }
 catch (    IOException e) {
      if (target.isDirectory()) {
        if (!target.exists()) {
          if (!target.mkdirs()) {
            throw E.ioException("String_Node_Str",source,target);
          }
        }
        target=new File(target,source.getName());
      }
 else {
        File targetFolder=target.getParentFile();
        if (!targetFolder.exists()) {
          if (!targetFolder.mkdirs()) {
            throw E.ioException("String_Node_Str",source,target);
          }
        }
      }
      try {
        write(new FileInputStream(source),new FileOutputStream(target));
      }
 catch (      IOException e0) {
        throw E.ioException(e0);
      }
    }
  }
}
Program: 91565
Project: 91565
Buggy source:
protected $(){
}

Fixed version (ground truth):
private $(){
}
Program: 91566
Project: 91566
Buggy source:
/** 
 * Convert a <code>Function&lt;T, Boolean&gt;</code> typed function to  {@link Osgl.Predicate Predicate&lt;T&gt;} function.<p>If the function specified is already a  {@link Predicate}, then the function itself is returned</p>
 * @since 0.2
 */
@SuppressWarnings("String_Node_Str") public static <T>Predicate<T> predicate(final Function<? super T,Boolean> f1){
  if (f1 instanceof Predicate) {
    return (Predicate<T>)f1;
  }
  return new Predicate<T>(){
    @Override public boolean test(    T t){
      return f1.apply(t);
    }
  }
;
}

Fixed version (ground truth):
/** 
 * Convert a <code>Function&lt;T, Boolean&gt;</code> typed function to  {@link Osgl.Predicate Predicate&lt;T&gt;} function.<p>If the function specified is already a  {@link Predicate}, then the function itself is returned</p>
 * @param f   the function to be converted
 * @param < T > the argument type
 * @return a function of {@link Predicate} type that is equivalent to function {@code f}
 * @since 0.2
 */
@SuppressWarnings("String_Node_Str") public static <T>Predicate<T> predicate(final Function<? super T,Boolean> f){
  if (f instanceof Predicate) {
    return (Predicate<T>)f;
  }
  return new Predicate<T>(){
    @Override public boolean test(    T t){
      return f.apply(t);
    }
  }
;
}
Program: 91567
Project: 91567
Buggy source:
/** 
 * Return a five variables function that throw out a   {@link Break} when the predicate returns<code>true</code> on an element been tested. There is no payload specified and the <code>Break</code> will use test result i.e. <code>true</code> as the payload
 * @param predicate the predicate function that takes five arguments and returns a {@code boolean} type value
 * @param < T1 > the generic type of the argument 1
 * @param < T2 > the generic type of the argument 2
 * @param < T3 > the generic type of the argument 3
 * @param < T4 > the generic type of the argument 4
 * @param < T4 > the generic type of the argument 5
 * @return a function that check on five arguments and throw out {@code true} if the check returns {@code true}
 * @since 0.2
 */
public static <T1,T2,T3,T4,T5>F5<T1,T2,T3,T4,T5,Void> breakIf(final Func5<? super T1,? super T2,? super T3,? super T4,? super T5,Boolean> predicate){
  return new F5<T1,T2,T3,T4,T5,Void>(){
    @Override public Void apply(    T1 t1,    T2 t2,    T3 t3,    T4 t4,    T5 t5){
      if (predicate.apply(t1,t2,t3,t4,t5)) {
        throw breakOut(true);
      }
      return null;
    }
  }
;
}

Fixed version (ground truth):
/** 
 * Return a five variables function that throw out a   {@link Break} when the predicate returns<code>true</code> on an element been tested. There is no payload specified and the <code>Break</code> will use test result i.e. <code>true</code> as the payload
 * @param predicate the predicate function that takes five arguments and returns a {@code boolean} type value
 * @param < T1 >      the generic type of the argument 1
 * @param < T2 >      the generic type of the argument 2
 * @param < T3 >      the generic type of the argument 3
 * @param < T4 >      the generic type of the argument 4
 * @param < T5 >      the generic type of the argument 5
 * @return a function that check on five arguments and throw out {@code true} if the check returns {@code true}
 * @since 0.2
 */
@SuppressWarnings("String_Node_Str") public static <T1,T2,T3,T4,T5>F5<T1,T2,T3,T4,T5,Void> breakIf(final Func5<? super T1,? super T2,? super T3,? super T4,? super T5,Boolean> predicate){
  return new F5<T1,T2,T3,T4,T5,Void>(){
    @Override public Void apply(    T1 t1,    T2 t2,    T3 t3,    T4 t4,    T5 t5){
      if (predicate.apply(t1,t2,t3,t4,t5)) {
        throw breakOut(true);
      }
      return null;
    }
  }
;
}
Program: 91568
Project: 91568
Buggy source:
/** 
 * The type-safe version of   {@link #NOT_NULL}
 * @since 0.2
 */
@SuppressWarnings("String_Node_Str") public static <T>Predicate<T> notNull(){
  return NOT_NULL;
}

Fixed version (ground truth):
@SuppressWarnings({"String_Node_Str","String_Node_Str"}) public static <T>Predicate<T> notNull(){
  return NOT_NULL;
}
Program: 91569
Project: 91569
Buggy source:
/** 
 * Alias of   {@link #gte(java.util.Comparator)}
 * @since 0.2
 */
public static <T>F2<T,T,Boolean> greaterThanOrEqualsTo(final Func2<? super T,? super T,Integer> c){
  return gte(c);
}

Fixed version (ground truth):
/** 
 * Alias of   {@link #gte(java.util.Comparator)}
 * @param < T > The type of the value been compared, should implements {@link Comparable}
 * @param c   The comparator that can compare the value
 * @return the function that do the comparison
 * @since 0.2
 */
public static <T>F2<T,T,Boolean> greaterThanOrEqualsTo(final Func2<? super T,? super T,Integer> c){
  return gte(c);
}
Program: 91570
Project: 91570
Buggy source:
/** 
 * Check if any objects in the parameter list is null
 */
public static boolean anyNull(Object o,Object... oa){
  if (!isNull(o))   return true;
  for (int i=oa.length - 1; i >= 0; --i) {
    if (!isNull(oa[i]))     return true;
  }
  return false;
}

Fixed version (ground truth):
/** 
 * Check if any objects in the parameter list is null
 * @param o  the first object to be checked
 * @param oa the array of objects to be checked
 * @return {@code true} if any one of the argument is {@code null}
 */
public static boolean anyNull(Object o,Object... oa){
  if (!isNull(o))   return true;
  for (int i=oa.length - 1; i >= 0; --i) {
    if (!isNull(oa[i]))     return true;
  }
  return false;
}
Program: 91571
Project: 91571
Buggy source:
public Map<A,B> asMap(){
  Map<A,B> m=new HashMap<A,B>();
  m.put(_1,_2);
  return m;
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") public Map<A,B> asMap(){
  Map<A,B> m=new HashMap<A,B>();
  m.put(_1,_2);
  return m;
}
Program: 91572
Project: 91572
Buggy source:
/** 
 * See <a href="http://download.java.net/jdk8/docs/api/java/util/Comparator.html#thenComparing(java.util.function.Function)">Java 8 doc</a>
 * @param keyExtractor the function that extract key of type U from instance of type T
 * @param < U > the key type
 * @return a comparator that applied if the result of this comparator is even
 */
public <U extends Comparable<? super U>>Comparator<T> thenComparing(Function<? super T,? extends U> keyExtractor){
  return thenComparing(Osgl.F.comparing(keyExtractor));
}

Fixed version (ground truth):
/** 
 * See <a href="http://download.java.net/jdk8/docs/api/java/util/Comparator.html#thenComparing(java.util.function.Function)">Java 8 doc</a>
 * @param keyExtractor the function that extract key of type U from instance of type T
 * @param < U >          the key type
 * @return a comparator that applied if the result of this comparator is even
 */
public <U extends Comparable<? super U>>Comparator<T> thenComparing(Function<? super T,? extends U> keyExtractor){
  return thenComparing(Osgl.F.comparing(keyExtractor));
}
Program: 91573
Project: 91573
Buggy source:
/** 
 * Alias of   {@link #lt(java.util.Comparator)}
 * @since 0.2
 */
public static <T>F2<T,T,Boolean> lessThan(final Func2<? super T,? super T,Integer> c){
  return lt(c);
}

Fixed version (ground truth):
/** 
 * Alias of   {@link #lt(java.util.Comparator)}
 * @param c   a comparator function
 * @param < T > the element type
 * @return a function that use function {@code c} to check if an element is lesser than another
 * @since 0.2
 */
public static <T>F2<T,T,Boolean> lessThan(final Func2<? super T,? super T,Integer> c){
  return lt(c);
}
Program: 91574
Project: 91574
Buggy source:
public static <A,B>T2<A,B> T2(A a,B b){
  return new T2(a,b);
}

Fixed version (ground truth):
public static <A,B>T2<A,B> T2(A a,B b){
  return new T2<A,B>(a,b);
}
Program: 91575
Project: 91575
Buggy source:
public static <A,B,C>T3<A,B,C> T3(A a,B b,C c){
  return new T3(a,b,c);
}

Fixed version (ground truth):
public static <A,B,C>T3<A,B,C> T3(A a,B b,C c){
  return new T3<A,B,C>(a,b,c);
}
Program: 91576
Project: 91576
Buggy source:
public static <A,B,C,D>T4<A,B,C,D> T4(A a,B b,C c,D d){
  return new T4<A,B,C,D>(a,b,c,d);
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") public static <A,B,C,D>T4<A,B,C,D> T4(A a,B b,C c,D d){
  return new T4<A,B,C,D>(a,b,c,d);
}
Program: 91577
Project: 91577
Buggy source:
public static <A,B,C,D,E>T5<A,B,C,D,E> T5(A a,B b,C c,D d,E e){
  return new T5<A,B,C,D,E>(a,b,c,d,e);
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") public static <A,B,C,D,E>T5<A,B,C,D,E> T5(A a,B b,C c,D d,E e){
  return new T5<A,B,C,D,E>(a,b,c,d,e);
}
Program: 91578
Project: 91578
Buggy source:
/** 
 * Returns a function that when applied, run   {@link Osgl.Option#orElse(Osgl.Func0)}on this   {@code Option}
 */
public final <B>F0<T> orElse(final Func0<? extends T> other){
  return new F0<T>(){
    @Override public T apply() throws NotAppliedException, Break {
      return Option.this.orElse(other);
    }
  }
;
}

Fixed version (ground truth):
/** 
 * Returns a function that when applied, run   {@link Osgl.Option#orElse(Osgl.Func0)}on this   {@code Option}
 * @param other the function that generates another {@code T} element when thisoption is empty
 * @return the function that implement the {@code else if} semantic on this Option
 */
@SuppressWarnings("String_Node_Str") public final F0<T> orElse(final Func0<? extends T> other){
  return new F0<T>(){
    @Override public T apply() throws NotAppliedException, Break {
      return Option.this.orElse(other);
    }
  }
;
}
Program: 91579
Project: 91579
Buggy source:
/** 
 * The type-safe version of   {@link #IS_NULL}
 * @since 0.2
 */
@SuppressWarnings("String_Node_Str") public static <T>Predicate<T> isNull(Class<T> c){
  return IS_NULL;
}

Fixed version (ground truth):
@SuppressWarnings({"String_Node_Str","String_Node_Str"}) public static <T>Predicate<T> isNull(Class<T> c){
  return IS_NULL;
}
Program: 91580
Project: 91580
Buggy source:
/** 
 * Returns String representation of an object instance. Predicate the object specified is   {@code null} or {@code Osgl.NONE}, then an empty string is returned
 * @param o
 * @return a String representation of object
 */
public static String toString(Object o){
  if (isNull(o)) {
    return "String_Node_Str";
  }
  return o.toString();
}

Fixed version (ground truth):
/** 
 * Returns String representation of an object instance. Predicate the object specified is   {@code null} or {@code Osgl.NONE}, then an empty string is returned
 * @param o the object which will be converted into a string
 * @return a String representation of object
 */
public static String toString(Object o){
  if (isNull(o)) {
    return "String_Node_Str";
  }
  return o.toString();
}
Program: 91581
Project: 91581
Buggy source:
/** 
 * Convert a general   {@link Osgl.Func0} typed function to {@link F0} type
 * @param f0 a function of type {@link Func0} that returns type R value
 * @param < R > the generic type of the return value when applying function f0
 * @return a {@link F0} type that is equaivlent to function f0
 * @since 0.2
 */
@SuppressWarnings("String_Node_Str") public static <R>F0<R> f0(final Func0<? extends R> f0){
  E.NPE(f0);
  if (f0 instanceof F0) {
    return (F0<R>)f0;
  }
  return new F0<R>(){
    @Override public R apply(){
      return f0.apply();
    }
  }
;
}

Fixed version (ground truth):
/** 
 * Convert a general   {@link Osgl.Func0} typed function to {@link F0} type
 * @param f0  a function of type {@link Func0} that returns type R value
 * @param < R > the generic type of the return value when applying function f0
 * @return a {@link F0} type that is equaivlent to function f0
 * @since 0.2
 */
@SuppressWarnings("String_Node_Str") public static <R>F0<R> f0(final Func0<? extends R> f0){
  E.NPE(f0);
  if (f0 instanceof F0) {
    return (F0<R>)f0;
  }
  return new F0<R>(){
    @Override public R apply(){
      return f0.apply();
    }
  }
;
}
Program: 91582
Project: 91582
Buggy source:
/** 
 * Convert a general   {@link Osgl.Func2} function into a {@link F2} typedfunction
 * @param < P1 > the type of the first param the new function applied to
 * @param < P2 > the type of the second param the new function applied to
 * @param < R >  the type of new function application result
 * @return a {@code F2} instance corresponding to the specified {@code Func2} instance
 * @since 0.2
 */
@SuppressWarnings("String_Node_Str") public static <P1,P2,R>F2<P1,P2,R> f2(final Func2<? super P1,? super P2,? extends R> f2){
  E.NPE(f2);
  if (f2 instanceof F2) {
    return (F2<P1,P2,R>)f2;
  }
  return new F2<P1,P2,R>(){
    @Override public R apply(    P1 p1,    P2 p2){
      return f2.apply(p1,p2);
    }
  }
;
}

Fixed version (ground truth):
/** 
 * Convert a general   {@link Osgl.Func2} function into a {@link F2} typedfunction
 * @param f2   the function that takes two arguments and return type {@code R}
 * @param < P1 > the type of the first param the new function applied to
 * @param < P2 > the type of the second param the new function applied to
 * @param < R >  the type of new function application result
 * @return a {@code F2} instance corresponding to the specified {@code Func2} instance
 * @since 0.2
 */
@SuppressWarnings("String_Node_Str") public static <P1,P2,R>F2<P1,P2,R> f2(final Func2<? super P1,? super P2,? extends R> f2){
  E.NPE(f2);
  if (f2 instanceof F2) {
    return (F2<P1,P2,R>)f2;
  }
  return new F2<P1,P2,R>(){
    @Override public R apply(    P1 p1,    P2 p2){
      return f2.apply(p1,p2);
    }
  }
;
}
Program: 91583
Project: 91583
Buggy source:
/** 
 * Alias of   {@link org.osgl.util.S#fmt(String,Object)}
 * @since 0.2
 */
public static final String fmt(String tmpl,Object... args){
  return S.fmt(tmpl,args);
}

Fixed version (ground truth):
/** 
 * Alias of   {@link org.osgl.util.S#fmt(String,Object)}
 * @param tmpl the format template
 * @param args the format arguments
 * @return the formatted string
 * @since 0.2
 */
public static String fmt(String tmpl,Object... args){
  return S.fmt(tmpl,args);
}
Program: 91584
Project: 91584
Buggy source:
/** 
 * Convert a general   {@link Osgl.Func3} function into a {@link F3} typedfunction
 * @param f3 the general function with three params
 * @return the {@link #F3} typed instance which is equivalent to f3
 * @since 0.2
 */
@SuppressWarnings("String_Node_Str") public static <P1,P2,P3,R>F3<P1,P2,P3,R> f3(final Func3<? super P1,? super P2,? super P3,? extends R> f3){
  E.NPE(f3);
  if (f3 instanceof F3) {
    return (F3<P1,P2,P3,R>)f3;
  }
  return new F3<P1,P2,P3,R>(){
    @Override public R apply(    P1 p1,    P2 p2,    P3 p3){
      return f3.apply(p1,p2,p3);
    }
  }
;
}

Fixed version (ground truth):
/** 
 * Convert a general   {@link Osgl.Func3} function into a {@link F3} typedfunction
 * @param f3   the general function with three params
 * @param < P1 > type of argument 1
 * @param < P2 > type of argument 2
 * @param < P3 > type of argument 3
 * @param < R >  return type
 * @return the {@link #F3} typed instance which is equivalent to f3
 * @since 0.2
 */
@SuppressWarnings("String_Node_Str") public static <P1,P2,P3,R>F3<P1,P2,P3,R> f3(final Func3<? super P1,? super P2,? super P3,? extends R> f3){
  E.NPE(f3);
  if (f3 instanceof F3) {
    return (F3<P1,P2,P3,R>)f3;
  }
  return new F3<P1,P2,P3,R>(){
    @Override public R apply(    P1 p1,    P2 p2,    P3 p3){
      return f3.apply(p1,p2,p3);
    }
  }
;
}
Program: 91585
Project: 91585
Buggy source:
/** 
 * Convert a general   {@link Osgl.Func4} function into a {@link F4} typedfunction
 * @since 0.2
 */
@SuppressWarnings("String_Node_Str") public static <P1,P2,P3,P4,R>F4<P1,P2,P3,P4,R> f4(final Func4<? super P1,? super P2,? super P3,? super P4,? extends R> f4){
  E.NPE(f4);
  if (f4 instanceof F4) {
    return (F4<P1,P2,P3,P4,R>)f4;
  }
  return new F4<P1,P2,P3,P4,R>(){
    @Override public R apply(    P1 p1,    P2 p2,    P3 p3,    P4 p4){
      return f4.apply(p1,p2,p3,p4);
    }
  }
;
}

Fixed version (ground truth):
/** 
 * Convert a general   {@link Osgl.Func4} function into a {@link F4} typedfunction
 * @param f4   the function to be converted
 * @param < P1 > type of first argument
 * @param < P2 > type of second argument
 * @param < P3 > type of third argument
 * @param < P4 > type of fourth argument
 * @param < R >  type of return value
 * @return the function of {@link F4} type that is equivalent to function {@code f4}
 * @since 0.2
 */
@SuppressWarnings("String_Node_Str") public static <P1,P2,P3,P4,R>F4<P1,P2,P3,P4,R> f4(final Func4<? super P1,? super P2,? super P3,? super P4,? extends R> f4){
  E.NPE(f4);
  if (f4 instanceof F4) {
    return (F4<P1,P2,P3,P4,R>)f4;
  }
  return new F4<P1,P2,P3,P4,R>(){
    @Override public R apply(    P1 p1,    P2 p2,    P3 p3,    P4 p4){
      return f4.apply(p1,p2,p3,p4);
    }
  }
;
}
Program: 91586
Project: 91586
Buggy source:
/** 
 * Convert a general   {@link Osgl.Func5} function into a {@link F5} typedfunction
 * @since 0.2
 */
@SuppressWarnings("String_Node_Str") public static <P1,P2,P3,P4,P5,R>F5<P1,P2,P3,P4,P5,R> f5(final Func5<? super P1,? super P2,? super P3,? super P4,? super P5,? extends R> f5){
  E.NPE(f5);
  if (f5 instanceof F5) {
    return (F5<P1,P2,P3,P4,P5,R>)f5;
  }
  return new F5<P1,P2,P3,P4,P5,R>(){
    @Override public R apply(    P1 p1,    P2 p2,    P3 p3,    P4 p4,    P5 p5){
      return f5.apply(p1,p2,p3,p4,p5);
    }
  }
;
}

Fixed version (ground truth):
/** 
 * Convert a general   {@link Osgl.Func5} function into a {@link F5} typedfunction
 * @param f5   the function to be converted
 * @param < P1 > type of first argument
 * @param < P2 > type of second argument
 * @param < P3 > type of third argument
 * @param < P4 > type of fourth argument
 * @param < P5 > type of fifth argument
 * @param < R >  type of return value
 * @return the function of {@link F5} type that is equivalent to function {@code f5}
 * @since 0.2
 */
@SuppressWarnings("String_Node_Str") public static <P1,P2,P3,P4,P5,R>F5<P1,P2,P3,P4,P5,R> f5(final Func5<? super P1,? super P2,? super P3,? super P4,? super P5,? extends R> f5){
  E.NPE(f5);
  if (f5 instanceof F5) {
    return (F5<P1,P2,P3,P4,P5,R>)f5;
  }
  return new F5<P1,P2,P3,P4,P5,R>(){
    @Override public R apply(    P1 p1,    P2 p2,    P3 p3,    P4 p4,    P5 p5){
      return f5.apply(p1,p2,p3,p4,p5);
    }
  }
;
}
Program: 91587
Project: 91587
Buggy source:
/** 
 * @param f
 * @param < X >
 * @param < Y >
 * @return
 */
public static <X,Y>Bijection<Y,X> invert(final Bijection<X,Y> f){
  return Osgl.f1(f.invert());
}

Fixed version (ground truth):
/** 
 * Returns a inverted function of   {@link Bijection} which map from X to Y, and thereturned function map from Y to X. This function will call  {@link Bijection#invert()}to get the return function
 * @param f   the bijection function to be inverted
 * @param < X > the argument type, and the result type of the return function
 * @param < Y > the result type, and the argument type of the return function
 * @return the inverted function of input function {@code f}
 */
public static <X,Y>Bijection<Y,X> invert(final Bijection<X,Y> f){
  return Osgl.f1(f.invert());
}
Program: 91588
Project: 91588
Buggy source:
/** 
 * Alias of   {@link #ne()}
 * @since 0.2
 */
@SuppressWarnings("String_Node_Str") public static <P1,P2>F2<P1,P2,Boolean> notEqual(){
  return NE;
}

Fixed version (ground truth):
@SuppressWarnings({"String_Node_Str","String_Node_Str"}) public static <P1,P2>F2<P1,P2,Boolean> notEqual(){
  return NE;
}
Program: 91589
Project: 91589
Buggy source:
public static <P>Predicate<P> eq(final P element){
  return new Predicate<P>(){
    @Override public boolean test(    P p){
      return Osgl.eq(p,element);
    }
  }
;
}

Fixed version (ground truth):
/** 
 * Returns a   {@link Predicate} that checkes if the argumentequals to the element specified
 * @param element the object to be checked with argument when applyingthe function
 * @param < P >     the element type
 * @return the function that returns {@code true} if the argument equalswith the element specified or  {@code false} otherwise
 */
public static <P>Predicate<P> eq(final P element){
  return new Predicate<P>(){
    @Override public boolean test(    P p){
      return Osgl.eq(p,element);
    }
  }
;
}
Program: 91590
Project: 91590
Buggy source:
/** 
 * A type-safe version of   {@link #TRUE}
 * @since 0.2
 */
@SuppressWarnings("String_Node_Str") public static <T>Predicate<T> yes(){
  return TRUE;
}

Fixed version (ground truth):
/** 
 * A type-safe version of   {@link #TRUE}
 * @param < T > the argument type
 * @return a function that always returns {@code true}
 * @since 0.2
 */
@SuppressWarnings("String_Node_Str") public static <T>Predicate<T> yes(){
  return TRUE;
}
Program: 91591
Project: 91591
Buggy source:
/** 
 * Alias of   {@link #eq()}
 * @since 0.2
 */
@SuppressWarnings("String_Node_Str") public static <P1,P2>F2<P1,P2,Boolean> equal(){
  return EQ;
}

Fixed version (ground truth):
/** 
 * Alias of   {@link #eq()}
 * @param < P1 > the type of the first argument
 * @param < P2 > the type of the second argument
 * @return a type-safe function that check equility of two objects
 * @since 0.2
 */
@SuppressWarnings("String_Node_Str") public static <P1,P2>F2<P1,P2,Boolean> equal(){
  return EQ;
}
Program: 91592
Project: 91592
Buggy source:
/** 
 * Alias of   {@link #lte(java.util.Comparator)}
 * @since 0.2
 */
public static <T>F2<T,T,Boolean> lessThanOrEqualsTo(final Func2<? super T,? super T,Integer> c){
  return lte(c);
}

Fixed version (ground truth):
/** 
 * Alias of   {@link #lte(java.util.Comparator)}
 * @param < T > The type of the value been compared, should implements {@link Comparable}
 * @param c   The comparator that can compare the value
 * @return the function that do the comparison
 * @since 0.2
 */
public static <T>F2<T,T,Boolean> lessThanOrEqualsTo(final Func2<? super T,? super T,Integer> c){
  return lte(c);
}
Program: 91593
Project: 91593
Buggy source:
/** 
 * Check if two objects are equals to each other. The comparison will do array equal matching if needed
 * @param a
 * @param b
 * @return
 */
public static boolean eq2(Object a,Object b){
  if (eq(a,b))   return true;
  Class<?> ca=a.getClass();
  if (!ca.isArray())   return false;
  Class<?> cb=b.getClass();
  if (ca != cb)   return false;
  if (ca == boolean[].class) {
    return Arrays.equals((boolean[])a,(boolean[])b);
  }
 else   if (ca == byte[].class) {
    return Arrays.equals((byte[])a,(byte[])b);
  }
 else   if (ca == int[].class) {
    return Arrays.equals((int[])a,(int[])b);
  }
 else   if (ca == char[].class) {
    return Arrays.equals((char[])a,(char[])b);
  }
 else   if (ca == long[].class) {
    return Arrays.equals((long[])a,(long[])b);
  }
 else   if (ca == float[].class) {
    return Arrays.equals((float[])a,(float[])b);
  }
 else   if (ca == double[].class) {
    return Arrays.equals((double[])a,(double[])b);
  }
 else   if (ca == short[].class) {
    return Arrays.equals((short[])a,(short[])b);
  }
 else {
    return Arrays.equals((Object[])a,(Object[])b);
  }
}

Fixed version (ground truth):
/** 
 * Check if two objects are equals to each other. The comparison will do array equal matching if needed
 * @param a the first object
 * @param b the second object
 * @return {@code true} if the first object equals to the second object
 */
public static boolean eq2(Object a,Object b){
  if (eq(a,b))   return true;
  Class<?> ca=a.getClass();
  if (!ca.isArray())   return false;
  Class<?> cb=b.getClass();
  if (ca != cb)   return false;
  if (ca == boolean[].class) {
    return Arrays.equals((boolean[])a,(boolean[])b);
  }
 else   if (ca == byte[].class) {
    return Arrays.equals((byte[])a,(byte[])b);
  }
 else   if (ca == int[].class) {
    return Arrays.equals((int[])a,(int[])b);
  }
 else   if (ca == char[].class) {
    return Arrays.equals((char[])a,(char[])b);
  }
 else   if (ca == long[].class) {
    return Arrays.equals((long[])a,(long[])b);
  }
 else   if (ca == float[].class) {
    return Arrays.equals((float[])a,(float[])b);
  }
 else   if (ca == double[].class) {
    return Arrays.equals((double[])a,(double[])b);
  }
 else   if (ca == short[].class) {
    return Arrays.equals((short[])a,(short[])b);
  }
 else {
    return Arrays.equals((Object[])a,(Object[])b);
  }
}
Program: 91594
Project: 91594
Buggy source:
/** 
 * Applies this partial function to the given argument when it is contained in the function domain. Applies fallback function where this partial function is not defined.
 * @param p1 the first argument
 * @param p2 the second argument
 * @param p3 the third argument
 * @param p4 the fourth argument
 * @param p5 the fifth argument
 * @param fallback the function to be called if application of this function failed with any runtime exception
 * @return a composite function apply to this function and then the callback function if this function failed
 */
public R applyOrElse(P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,F5<? super P1,? super P2,? super P3,? super P4,? super P5,? extends R> fallback){
  try {
    return apply(p1,p2,p3,p4,p5);
  }
 catch (  RuntimeException e) {
    return fallback.apply(p1,p2,p3,p4,p5);
  }
}

Fixed version (ground truth):
/** 
 * Applies this partial function to the given argument when it is contained in the function domain. Applies fallback function where this partial function is not defined.
 * @param p1       the first argument
 * @param p2       the second argument
 * @param p3       the third argument
 * @param p4       the fourth argument
 * @param p5       the fifth argument
 * @param fallback the function to be called if application of this function failed with any runtime exception
 * @return a composite function apply to this function and then the callback function if this function failed
 */
public R applyOrElse(P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,F5<? super P1,? super P2,? super P3,? super P4,? super P5,? extends R> fallback){
  try {
    return apply(p1,p2,p3,p4,p5);
  }
 catch (  RuntimeException e) {
    return fallback.apply(p1,p2,p3,p4,p5);
  }
}
Program: 91595
Project: 91595
Buggy source:
/** 
 * Negation of   {@link #or(Osgl.Function[])}
 * @param predicates an array of predicate functions
 * @param < T > the generic type of the argument the predicate functions take
 * @return a function that apply the argument to all predicate functions and return{@code true} if all of them return {@code false} on the argument, or{@code false} if any one of them returns {@code true}
 * @since 0.2
 */
public static <T>Predicate<T> none(final Function<? super T,Boolean>... predicates){
  return negate(or(predicates));
}

Fixed version (ground truth):
/** 
 * Negation of   {@link #or(Osgl.Function[])}
 * @param predicates an array of predicate functions
 * @param < T >        the generic type of the argument the predicate functions take
 * @return a function that apply the argument to all predicate functions and return{@code true} if all of them return {@code false} on the argument, or{@code false} if any one of them returns {@code true}
 * @since 0.2
 */
public static <T>Predicate<T> none(final Function<? super T,Boolean>... predicates){
  return negate(or(predicates));
}
Program: 91596
Project: 91596
Buggy source:
/** 
 * Type safe version of   {@link #AS_STRING}. It returns a function that takes argument of type   {@code T} and returns a String by calling{@link Object#toString()} function on the argument
 * @param tClass the class specify the generic type
 * @param < T > the generic type T of the returning function
 * @return a function of type {@link F1 F1&lt;T, String&gt;}
 */
public static <T>F1<T,String> asString(Class<T> tClass){
  return AS_STRING;
}

Fixed version (ground truth):
/** 
 * Type safe version of   {@link #AS_STRING}. It returns a function that takes argument of type   {@code T} and returns a String by calling{@link Object#toString()} function on the argument
 * @param tClass the class specify the generic type
 * @param < T >    the generic type T of the returning function
 * @return a function of type {@link F1 F1&lt;T, String&gt;}
 */
public static <T>F1<T,String> asString(Class<T> tClass){
  return AS_STRING;
}
Program: 91597
Project: 91597
Buggy source:
/** 
 * Negate of   {@link #isDefined()}
 * @since 0.2
 */
public boolean notDefined(){
  return !isDefined();
}

Fixed version (ground truth):
/** 
 * Negate of   {@link #isDefined()}
 * @return {@code true} if this option is not defined
 * @since 0.2
 */
public boolean notDefined(){
  return !isDefined();
}