nus-yam/ex-repair huggingface dataset:
Program: 44152
Project: 44152
Buggy source:
public void addObjectFactory(ObjectFactory objectFactory){
  if (objectFactory == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  objectFactories.add(objectFactory);
}

Fixed version (ground truth):
/** 
 * Adds the given object factory as possible object factory to this parser.
 * @param objectFactory object factory
 */
public void addObjectFactory(ObjectFactory objectFactory){
  if (objectFactory == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  objectFactories.add(objectFactory);
}
Program: 44153
Project: 44153
Buggy source:
/** 
 * Returns <code>true</code> if the factory can create objects of the given class
 * @param cls
 * @return
 */
boolean supports(Class<T> cls);

Fixed version (ground truth):
/** 
 * Returns <code>true</code> if the factory can create objects of the given class
 * @param cls   Class to check for support of
 * @return  <code>true</code> if the given class can be created by this factory
 */
boolean supports(Class<T> cls);
Program: 44154
Project: 44154
Buggy source:
/** 
 * Creates an instance of the given type.
 * @param typeHint
 * @return
 */
T create(Class<T> typeHint);

Fixed version (ground truth):
/** 
 * Creates an instance of the given type.
 * @param cls   Class to create an instance of
 * @return  new instance
 */
T create(Class<T> cls);
Program: 44155
Project: 44155
Buggy source:
/** 
 * @param value
 * @return Class or <code>null</code>
 * @throws IllegalStateException if there is no class configured for thisvalue and  {@link #allowUndefined} is false.
 */
@Override protected Class getTypeHintFromTypeProperty(Object value) throws IllegalStateException {
  Class cls=typeMap.get(value);
  if (cls == null) {
    if (allowUndefined) {
      cls=HashMap.class;
    }
 else {
      throw new IllegalStateException("String_Node_Str" + value + "String_Node_Str"+ value+ "String_Node_Str");
    }
  }
  return cls;
}

Fixed version (ground truth):
/** 
 * Converts a property value into a type hint class
 * @param value     property value.
 * @return Class or <code>null</code>
 * @throws IllegalStateException if there is no class configured for thisvalue and  {@link #allowUndefined} is false.
 */
@Override protected Class getTypeHintFromTypeProperty(Object value) throws IllegalStateException {
  Class cls=typeMap.get(value);
  if (cls == null) {
    if (allowUndefined) {
      cls=HashMap.class;
    }
 else {
      throw new IllegalStateException("String_Node_Str" + value + "String_Node_Str"+ value+ "String_Node_Str");
    }
  }
  return cls;
}
Program: 44162
Project: 44162
Buggy source:
private static String getPropertyNameFromAnnotation(Object target,String value){
  for (  PropertyDescriptor pd : PropertyUtils.getPropertyDescriptors(target.getClass())) {
    JSONProperty jsonProperty=null;
    Method readMethod=pd.getReadMethod();
    Method writeMethod=pd.getWriteMethod();
    if (readMethod != null) {
      jsonProperty=readMethod.getAnnotation(JSONProperty.class);
    }
    if (jsonProperty == null && writeMethod != null) {
      jsonProperty=writeMethod.getAnnotation(JSONProperty.class);
    }
    if (jsonProperty != null && jsonProperty.value().equals(value)) {
      return pd.getName();
    }
  }
  return value;
}

Fixed version (ground truth):
public static String getPropertyNameFromAnnotation(Object target,String value){
  for (  PropertyDescriptor pd : PropertyUtils.getPropertyDescriptors(target.getClass())) {
    JSONProperty jsonProperty=null;
    Method readMethod=pd.getReadMethod();
    Method writeMethod=pd.getWriteMethod();
    if (readMethod != null) {
      jsonProperty=readMethod.getAnnotation(JSONProperty.class);
    }
    if (jsonProperty == null && writeMethod != null) {
      jsonProperty=writeMethod.getAnnotation(JSONProperty.class);
    }
    if (jsonProperty != null && jsonProperty.value().equals(value)) {
      return pd.getName();
    }
  }
  return value;
}
Program: 44164
Project: 44164
Buggy source:
public static String getPropertyNameFromAnnotation(Object target,String value){
  for (  PropertyDescriptor pd : PropertyUtils.getPropertyDescriptors(target.getClass())) {
    JSONProperty jsonProperty=null;
    Method readMethod=pd.getReadMethod();
    Method writeMethod=pd.getWriteMethod();
    if (readMethod != null) {
      jsonProperty=readMethod.getAnnotation(JSONProperty.class);
    }
    if (jsonProperty == null && writeMethod != null) {
      jsonProperty=writeMethod.getAnnotation(JSONProperty.class);
    }
    if (jsonProperty != null && jsonProperty.value().equals(value)) {
      return pd.getName();
    }
  }
  return value;
}

Fixed version (ground truth):
/** 
 * Returns the java bean property name for the given json property name.
 * @param target    bean
 * @param value     json property name
 * @return java bean name, not guaranteed to actually exist.
 */
public static String getPropertyNameFromAnnotation(Object target,String value){
  for (  PropertyDescriptor pd : PropertyUtils.getPropertyDescriptors(target.getClass())) {
    String jsonPropertyName=getJSONPropertyNameFromDescriptor(target,pd);
    if (jsonPropertyName.equals(value)) {
      return pd.getName();
    }
  }
  return value;
}
Program: 44165
Project: 44165
Buggy source:
/** 
 * Returns all readable and writable bean property names of the given object
 * @param dynamicProperties object
 * @return
 */
public static Set<String> getBeanPropertyNames(Object dynamicProperties){
  PropertyDescriptor[] pds=PropertyUtils.getPropertyDescriptors(dynamicProperties.getClass());
  Set<String> names=new HashSet<String>();
  for (  PropertyDescriptor pd : pds) {
    Method readMethod=pd.getReadMethod();
    Method writeMethod=pd.getWriteMethod();
    if (readMethod != null && writeMethod != null) {
      String name=JSONParser.getPropertyNameFromAnnotation(dynamicProperties,pd.getName());
      names.add(name);
    }
  }
  return names;
}

Fixed version (ground truth):
/** 
 * Returns all readable and writable bean property JSON names of the given object.
 * @param dynamicProperties object
 * @return
 */
public static Set<String> getBeanPropertyNames(Object dynamicProperties){
  PropertyDescriptor[] pds=PropertyUtils.getPropertyDescriptors(dynamicProperties.getClass());
  Set<String> names=new HashSet<String>();
  for (  PropertyDescriptor pd : pds) {
    Method readMethod=pd.getReadMethod();
    Method writeMethod=pd.getWriteMethod();
    if (readMethod != null && writeMethod != null) {
      String name=JSONParser.getJSONPropertyNameFromDescriptor(dynamicProperties,pd);
      names.add(name);
    }
  }
  return names;
}
Program: 44166
Project: 44166
Buggy source:
/** 
 * Gets the bean or dynamic property with the given name. if the class has a bean property with the given name, the value of that property is returned. otherwise, the dynamic property with the given name is returned.
 * @param dynamicProperties     java bean
 * @param name                  property name
 * @return                      the property value.
 * @throws IllegalArgumentException if there is no bean property with the given name on the given dynamicProperties object and the class of the beandoes not implement  {@link DynamicProperties}
 */
public static Object getProperty(Object dynamicProperties,String name) throws IllegalArgumentException {
  if (PropertyUtils.isReadable(dynamicProperties,name)) {
    try {
      return PropertyUtils.getProperty(dynamicProperties,name);
    }
 catch (    IllegalAccessException e) {
      throw ExceptionWrapper.wrap(e);
    }
catch (    InvocationTargetException e) {
      throw ExceptionWrapper.wrap(e);
    }
catch (    NoSuchMethodException e) {
      throw ExceptionWrapper.wrap(e);
    }
  }
 else   if (dynamicProperties instanceof DynamicProperties) {
    return ((DynamicProperties)dynamicProperties).getProperty(name);
  }
 else {
    throw new IllegalArgumentException(dynamicProperties + "String_Node_Str" + name+ "String_Node_Str");
  }
}

Fixed version (ground truth):
/** 
 * Gets the bean or dynamic property with the given JSON property name. if the class has a bean property with the given name, the value of that property is returned. otherwise, the dynamic property with the given name is returned.
 * @param dynamicProperties java bean
 * @param name JSON property name
 * @return the property value.
 * @throws IllegalArgumentException if there is no bean property with thegiven name on the given dynamicProperties object and the class of the bean does not implement {@link DynamicProperties}
 */
public static Object getProperty(Object dynamicProperties,String name) throws IllegalArgumentException {
  try {
    String propertyName=JSONParser.getPropertyNameFromAnnotation(dynamicProperties,name);
    if (PropertyUtils.isReadable(dynamicProperties,propertyName)) {
      return PropertyUtils.getProperty(dynamicProperties,propertyName);
    }
 else     if (dynamicProperties instanceof DynamicProperties) {
      return ((DynamicProperties)dynamicProperties).getProperty(name);
    }
 else {
      throw new IllegalArgumentException(dynamicProperties + "String_Node_Str" + name+ "String_Node_Str");
    }
  }
 catch (  IllegalAccessException e) {
    throw ExceptionWrapper.wrap(e);
  }
catch (  InvocationTargetException e) {
    throw ExceptionWrapper.wrap(e);
  }
catch (  NoSuchMethodException e) {
    throw ExceptionWrapper.wrap(e);
  }
}
Program: 44167
Project: 44167
Buggy source:
/** 
 * Sets the bean or dynamic property with the given name to the given value. if the class has a bean property with the given name, the value of that property is overwritten. otherwise, the dynamic property with the given name is overwritten.
 * @param dynamicProperties         bean or dynamic properties instance
 * @param name                      property name
 * @param value                     property value
 * @throws IllegalArgumentException if there is no bean property with the given name on the given dynamicProperties object and the class of the beandoes not implement  {@link DynamicProperties}
 */
public static void setProperty(Object dynamicProperties,String name,Object value) throws IllegalArgumentException {
  if (PropertyUtils.isWriteable(dynamicProperties,name)) {
    try {
      PropertyUtils.setProperty(dynamicProperties,name,value);
    }
 catch (    IllegalAccessException e) {
      throw ExceptionWrapper.wrap(e);
    }
catch (    InvocationTargetException e) {
      throw ExceptionWrapper.wrap(e);
    }
catch (    NoSuchMethodException e) {
      throw ExceptionWrapper.wrap(e);
    }
  }
 else   if (dynamicProperties instanceof DynamicProperties) {
    ((DynamicProperties)dynamicProperties).setProperty(name,value);
  }
 else {
    throw new IllegalArgumentException(dynamicProperties + "String_Node_Str" + name+ "String_Node_Str");
  }
}

Fixed version (ground truth):
/** 
 * Sets the bean or dynamic property with the given JSON property name to the given value. if the class has a bean property with the given name, the value of that property is overwritten. otherwise, the dynamic property with the given name is overwritten.
 * @param dynamicProperties bean or dynamic properties instance
 * @param name JSON property name
 * @param value property value
 * @throws IllegalArgumentException if there is no bean property with thegiven name on the given dynamicProperties object and the class of the bean does not implement {@link DynamicProperties}
 */
public static void setProperty(Object dynamicProperties,String name,Object value) throws IllegalArgumentException {
  try {
    String propertyName=JSONParser.getPropertyNameFromAnnotation(dynamicProperties,name);
    if (PropertyUtils.isWriteable(dynamicProperties,propertyName)) {
      PropertyUtils.setProperty(dynamicProperties,propertyName,value);
    }
 else     if (dynamicProperties instanceof DynamicProperties) {
      ((DynamicProperties)dynamicProperties).setProperty(name,value);
    }
 else {
      throw new IllegalArgumentException(dynamicProperties + "String_Node_Str" + name+ "String_Node_Str");
    }
  }
 catch (  IllegalAccessException e) {
    throw ExceptionWrapper.wrap(e);
  }
catch (  InvocationTargetException e) {
    throw ExceptionWrapper.wrap(e);
  }
catch (  NoSuchMethodException e) {
    throw ExceptionWrapper.wrap(e);
  }
}
Program: 44168
Project: 44168
Buggy source:
/** 
 * Returns all properties of this dynamic properties object including the java bean properties.
 * @param dynamicProperties
 * @return
 */
public static Set<String> getAllPropertyNames(DynamicProperties dynamicProperties){
  Set<String> names=new HashSet<String>(dynamicProperties.propertyNames());
  names.addAll(getBeanPropertyNames(dynamicProperties));
  return names;
}

Fixed version (ground truth):
/** 
 * Returns the names of all properties of this dynamic properties object including the java bean properties. Note that the method will return the <em>JSON property name</em> of the java bean methods.
 * @param dynamicProperties     DynamicProperties object
 * @return a set containing all property names, both dynamic and static (JSON) names.
 */
public static Set<String> getAllPropertyNames(DynamicProperties dynamicProperties){
  Set<String> names=new HashSet<String>(dynamicProperties.propertyNames());
  names.addAll(getBeanPropertyNames(dynamicProperties));
  return names;
}
Program: 44169
Project: 44169
Buggy source:
@Test public void thatGetAllPropertyNamesWorks(){
  DynAttrsBean bean=new DynAttrsBean();
  bean.setFoo("String_Node_Str");
  bean.setProperty("String_Node_Str",42);
  Set<String> names=DynamicPropertiesUtil.getAllPropertyNames(bean);
  assertThat(names,is(notNullValue()));
  assertThat(names.size(),is(2));
  assertThat(names.contains("String_Node_Str"),is(true));
  assertThat(names.contains("String_Node_Str"),is(true));
}

Fixed version (ground truth):
@Test public void thatGetAllPropertyNamesWorks(){
  DynPropTestBean bean=new DynPropTestBean();
  bean.setFoo("String_Node_Str");
  bean.setProperty("String_Node_Str",42);
  Set<String> names=DynamicPropertiesUtil.getAllPropertyNames(bean);
  assertThat(names,is(notNullValue()));
  assertThat(names.size(),is(2));
  assertThat(names.contains("String_Node_Str"),is(true));
  assertThat(names.contains("String_Node_Str"),is(true));
}
Program: 44170
Project: 44170
Buggy source:
@Test public void thatWritingBeanPropertiesWorks(){
  DynAttrsBean bean=new DynAttrsBean();
  DynamicPropertiesUtil.setProperty(bean,"String_Node_Str","String_Node_Str");
  assertThat(bean.getFoo(),is("String_Node_Str"));
}

Fixed version (ground truth):
@Test public void thatWritingBeanPropertiesWorks(){
  DynPropTestBean bean=new DynPropTestBean();
  DynamicPropertiesUtil.setProperty(bean,"String_Node_Str","String_Node_Str");
  assertThat(bean.getFoo(),is("String_Node_Str"));
}
Program: 44171
Project: 44171
Buggy source:
@Test public void thatGetBeanPropertyNamesWorks(){
  DynAttrsBean bean=new DynAttrsBean();
  Set<String> names=DynamicPropertiesUtil.getBeanPropertyNames(bean);
  assertThat(names,is(notNullValue()));
  assertThat(names.size(),is(1));
  assertThat(names.contains("String_Node_Str"),is(true));
}

Fixed version (ground truth):
@Test public void thatGetBeanPropertyNamesWorks(){
  DynPropTestBean bean=new DynPropTestBean();
  Set<String> names=DynamicPropertiesUtil.getBeanPropertyNames(bean);
  assertThat(names,is(notNullValue()));
  assertThat(names.size(),is(1));
  assertThat(names.contains("String_Node_Str"),is(true));
}
Program: 44172
Project: 44172
Buggy source:
@Test public void thatReadingBeanPropertiesWorks(){
  DynAttrsBean bean=new DynAttrsBean();
  bean.setFoo("String_Node_Str");
  assertThat((String)DynamicPropertiesUtil.getProperty(bean,"String_Node_Str"),is("String_Node_Str"));
}

Fixed version (ground truth):
@Test public void thatReadingBeanPropertiesWorks(){
  DynPropTestBean bean=new DynPropTestBean();
  bean.setFoo("String_Node_Str");
  assertThat((String)DynamicPropertiesUtil.getProperty(bean,"String_Node_Str"),is("String_Node_Str"));
}
Program: 44173
Project: 44173
Buggy source:
/** 
 * Returns a set of tuples from the parsed console input string
 * @param consoleinput
 * @return 
 */
private HashMap<String,Boolean> parseProjectRootFolders(List<String> consoleinput){
  HashMap<String,Boolean> rootFolders=new HashMap<String,Boolean>();
  for (  String s : consoleinput) {
    if (!s.startsWith("String_Node_Str")) {
      continue;
    }
    Matcher m=pattern_catcs.matcher(s);
    if (m.matches()) {
      try {
        String key=m.group(2) + m.group(3);
        key=key.substring(1,key.length() - 1);
        key=key.replace("String_Node_Str","String_Node_Str");
        logger.info("String_Node_Str" + key);
        Boolean readOnly=s.contains("String_Node_Str");
        rootFolders.put(key,readOnly);
      }
 catch (      Exception ex) {
        logger.log(Level.SEVERE,"String_Node_Str" + s,ex);
      }
    }
  }
  return rootFolders;
}

Fixed version (ground truth):
/** 
 * Returns a set of tuples from the parsed console input string
 * @param consoleinput
 * @return 
 */
private HashMap<String,Boolean> parseProjectRootFolders(List<String> consoleinput){
  HashMap<String,Boolean> rootFolders=new HashMap<String,Boolean>();
  for (  String s : consoleinput) {
    if (!s.startsWith("String_Node_Str")) {
      continue;
    }
    Matcher m=pattern_catcs.matcher(s);
    if (m.matches()) {
      try {
        String key=m.group(2) + m.group(3);
        key=key.substring(1,key.length() - 1);
        key=key.replaceAll("String_Node_Str","String_Node_Str");
        logger.info("String_Node_Str" + key);
        Boolean readOnly=s.contains("String_Node_Str");
        rootFolders.put(key,readOnly);
      }
 catch (      Exception ex) {
        logger.log(Level.SEVERE,"String_Node_Str" + s,ex);
      }
    }
  }
  return rootFolders;
}
Program: 44174
Project: 44174
Buggy source:
public boolean rebase(boolean complete) throws RebaseException {
  logger.fine("String_Node_Str");
  String cmd="String_Node_Str" + (complete ? "String_Node_Str" : "String_Node_Str") + "String_Node_Str";
  if (view != null) {
    cmd+="String_Node_Str" + view.getViewtag();
  }
 else   if (stream != null) {
    cmd+="String_Node_Str" + stream;
    if (dropFromStream) {
      List<Baseline> fbls=stream.getFoundationBaselines();
      logger.fine("String_Node_Str" + fbls);
      for (      Baseline fbl : fbls) {
        if (!baselines.contains(fbl)) {
          logger.finest("String_Node_Str" + fbl);
          droppedBaselines.add(fbl);
        }
      }
    }
    if (viewTag != null) {
      cmd+="String_Node_Str" + viewTag;
    }
  }
 else   if (viewTag != null) {
    cmd+="String_Node_Str" + viewTag;
  }
 else {
    throw new IllegalStateException("String_Node_Str");
  }
  if (baselines != null && baselines.size() > 0) {
    cmd+="String_Node_Str";
    for (    Baseline b : baselines) {
      cmd+=b.getNormalizedName() + "String_Node_Str";
    }
    cmd=cmd.substring(0,(cmd.length() - 1));
  }
  if (droppedBaselines != null && droppedBaselines.size() > 0) {
    cmd+="String_Node_Str";
    for (    Baseline b : droppedBaselines) {
      cmd+=b.getNormalizedName() + "String_Node_Str";
    }
    cmd=cmd.substring(0,(cmd.length() - 1));
  }
  try {
    CmdResult res=Cleartool.run(cmd,viewPath);
    if (res.stdoutBuffer.toString().matches("String_Node_Str")) {
      return false;
    }
 else {
      return true;
    }
  }
 catch (  AbnormalProcessTerminationException e) {
    throw new RebaseException(this,e);
  }
}

Fixed version (ground truth):
public boolean rebase(boolean complete) throws RebaseException {
  return rebase(complete,false);
}
Program: 44175
Project: 44175
Buggy source:
public static boolean isInProgress(Stream stream) throws CleartoolException {
  String cmd="String_Node_Str" + stream;
  try {
    String result=Cleartool.run(cmd).stdoutBuffer.toString();
    if (result.matches(rx_rebase_in_progress)) {
      return true;
    }
 else {
      return false;
    }
  }
 catch (  AbnormalProcessTerminationException e) {
    throw new CleartoolException("String_Node_Str" + stream,e);
  }
}

Fixed version (ground truth):
public static boolean isInProgress(Stream stream) throws CleartoolException {
  String cmd="String_Node_Str" + stream;
  logger.fine(String.format("String_Node_Str",stream));
  try {
    logger.info(String.format("String_Node_Str",stream,cmd));
    String result=Cleartool.run(cmd).stdoutBuffer.toString();
    logger.fine(result);
    if (result.contains("String_Node_Str")) {
      logger.fine(String.format("String_Node_Str",stream));
      return true;
    }
 else {
      logger.fine(String.format("String_Node_Str",stream));
      return false;
    }
  }
 catch (  AbnormalProcessTerminationException e) {
    throw new CleartoolException("String_Node_Str" + stream,e);
  }
}
Program: 44176
Project: 44176
Buggy source:
public RebaseException(Rebase rebase,Exception e){
  super(e);
  this.rebase=rebase;
}

Fixed version (ground truth):
public RebaseException(String message,Rebase rebase,Exception e){
  super(message,e);
  this.rebase=rebase;
}
Program: 44177
Project: 44177
Buggy source:
public static Activity get(String name,PVob pvob) throws UnableToInitializeEntityException {
  if (!name.startsWith("String_Node_Str")) {
    name="String_Node_Str" + name;
  }
  Activity entity=(Activity)UCMEntity.getEntity(Activity.class,name + "String_Node_Str" + pvob);
  return entity;
}

Fixed version (ground truth):
public static Activity get(String name,PVob pvob) throws UnableToInitializeEntityException {
  if (!name.startsWith("String_Node_Str")) {
    name="String_Node_Str" + name;
  }
  System.out.println("String_Node_Str");
  Activity entity=(Activity)UCMEntity.getEntity(Activity.class,name + "String_Node_Str" + pvob);
  return entity;
}
Program: 44178
Project: 44178
Buggy source:
/** 
 * Create an activity. If name is null an anonymous activity is created and the return value is null.
 * @param name
 * @param in
 * @param pvob
 * @param force
 * @param comment
 * @param headline
 * @param view
 * @return
 * @throws UnableToCreateEntityException
 * @throws UCMEntityNotFoundException
 * @throws UnableToGetEntityException
 * @throws UnableToInitializeEntityException
 */
public static Activity create(String name,Stream in,PVob pvob,boolean force,String comment,String headline,File view) throws UnableToCreateEntityException, UCMEntityNotFoundException, UnableToGetEntityException, UnableToInitializeEntityException {
  String cmd="String_Node_Str" + (comment != null ? "String_Node_Str" + comment + "String_Node_Str" : "String_Node_Str") + (headline != null ? "String_Node_Str" + headline + "String_Node_Str" : "String_Node_Str")+ (in != null ? "String_Node_Str" + in.getNormalizedName() : "String_Node_Str")+ (force ? "String_Node_Str" : "String_Node_Str")+ (name != null ? "String_Node_Str" + name + "String_Node_Str"+ pvob : "String_Node_Str");
  try {
    Cleartool.run(cmd,view);
  }
 catch (  Exception e) {
    throw new UnableToCreateEntityException(Activity.class,e);
  }
  Activity activity=null;
  if (name != null) {
    activity=get(name,pvob);
  }
  return activity;
}

Fixed version (ground truth):
/** 
 * Create an activity. If name is null an anonymous activity is created and the return value is null.
 * @param name
 * @param in
 * @param pvob
 * @param force
 * @param comment
 * @param headline
 * @param view
 * @return
 * @throws UnableToCreateEntityException
 * @throws UCMEntityNotFoundException
 * @throws UnableToGetEntityException
 * @throws UnableToInitializeEntityException
 */
public static Activity create(String name,Stream in,PVob pvob,boolean force,String comment,String headline,File view) throws UnableToCreateEntityException, UCMEntityNotFoundException, UnableToGetEntityException, UnableToInitializeEntityException {
  String cmd="String_Node_Str" + (comment != null ? "String_Node_Str" + comment + "String_Node_Str" : "String_Node_Str") + (headline != null ? "String_Node_Str" + headline + "String_Node_Str" : "String_Node_Str")+ (in != null ? "String_Node_Str" + in.getNormalizedName() : "String_Node_Str")+ (force ? "String_Node_Str" : "String_Node_Str")+ (name != null ? "String_Node_Str" + name + "String_Node_Str"+ pvob : "String_Node_Str");
  try {
    System.out.println("String_Node_Str");
    System.out.println("String_Node_Str" + cmd);
    System.out.println("String_Node_Str" + view);
    Cleartool.run(cmd,view);
    System.out.println("String_Node_Str");
  }
 catch (  Exception e) {
    System.out.println("String_Node_Str");
    throw new UnableToCreateEntityException(Activity.class,e);
  }
  Activity activity=null;
  System.out.println("String_Node_Str");
  if (name != null) {
    System.out.println("String_Node_Str");
    activity=get(name,pvob);
    System.out.println("String_Node_Str");
  }
  return activity;
}
Program: 44179
Project: 44179
Buggy source:
public static List<Version> getVersions(Activity activity,File path) throws UnableToInitializeEntityException {
  logger.fine("String_Node_Str" + activity);
  String output=null;
  try {
    output=new Describe(activity).addModifier(Describe.versions).setPath(path).executeGetFirstLine();
  }
 catch (  CleartoolException e) {
    logger.fine(e.getMessage());
    return Collections.emptyList();
  }
  String[] versionNames=output.split("String_Node_Str");
  List<Version> versions=new ArrayList<Version>(versionNames.length);
  for (  String versionName : versionNames) {
    versions.add(Version.get(versionName.trim()));
  }
  return versions;
}

Fixed version (ground truth):
public static List<Version> getVersions(Activity activity,File path) throws UnableToInitializeEntityException {
  logger.fine("String_Node_Str" + activity);
  String output=null;
  try {
    output=new Describe(activity).addModifier(Describe.versions).setPath(path).executeGetFirstLine();
  }
 catch (  CleartoolException e) {
    logger.fine("String_Node_Str" + e.getMessage());
    return Collections.emptyList();
  }
  String[] versionNames=output.split("String_Node_Str");
  List<Version> versions=new ArrayList<Version>(versionNames.length);
  for (  String versionName : versionNames) {
    versions.add(Version.get(versionName.trim()));
  }
  return versions;
}
Program: 44182
Project: 44182
Buggy source:
public String stringify(){
  if (!loaded) {
    try {
      load();
    }
 catch (    ClearCaseException e) {
      throw new EntityNotLoadedException(fqname,fqname + "String_Node_Str",e);
    }
  }
  StringBuffer sb=new StringBuffer();
  try {
    if (!this.loaded)     load();
    sb.append("String_Node_Str" + this.plevel + linesep);
    sb.append("String_Node_Str" + this.component.toString() + linesep);
    sb.append("String_Node_Str" + this.stream.toString() + linesep);
    sb.append("String_Node_Str" + this.date.toString() + linesep);
  }
 catch (  Exception e) {
  }
 finally {
    sb.insert(0,super.stringify());
  }
  return sb.toString();
}

Fixed version (ground truth):
@Override public String stringify(){
  if (!loaded) {
    try {
      load();
    }
 catch (    ClearCaseException e) {
      throw new EntityNotLoadedException(fqname,fqname + "String_Node_Str",e);
    }
  }
  StringBuffer sb=new StringBuffer();
  try {
    if (!this.loaded) {
      load();
    }
    sb.append("String_Node_Str" + this.plevel + linesep);
    sb.append("String_Node_Str" + this.component.toString() + linesep);
    sb.append("String_Node_Str" + this.stream.toString() + linesep);
    sb.append("String_Node_Str" + this.date.toString() + linesep);
  }
 catch (  Exception e) {
  }
 finally {
    sb.insert(0,super.stringify());
  }
  return sb.toString();
}
Program: 44183
Project: 44183
Buggy source:
public String toString(){
  return value + "String_Node_Str" + fixed+ "String_Node_Str";
}

Fixed version (ground truth):
@Override public String toString(){
  return value + "String_Node_Str" + fixed+ "String_Node_Str";
}
Program: 44184
Project: 44184
Buggy source:
/** 
 * Returns a set of tuples from the parsed console input string
 * @param consoleinput
 * @return 
 */
private HashMap<String,Boolean> parseProjectRootFolders(List<String> consoleinput){
  HashMap<String,Boolean> rootFolders=new HashMap<String,Boolean>();
  for (  String s : consoleinput) {
    if (!s.startsWith("String_Node_Str")) {
      continue;
    }
    Matcher m=pattern_catcs.matcher(s);
    if (m.matches()) {
      try {
        String key=m.group(2) + m.group(3);
        key=key.substring(1,key.length() - 1);
        logger.info("String_Node_Str" + key);
        Boolean readOnly=s.contains("String_Node_Str");
        rootFolders.put(key,readOnly);
      }
 catch (      Exception ex) {
        logger.log(Level.SEVERE,"String_Node_Str" + s,ex);
      }
    }
  }
  return rootFolders;
}

Fixed version (ground truth):
/** 
 * Returns a set of tuples from the parsed console input string
 * @param consoleinput
 * @return 
 */
private HashMap<String,Boolean> parseProjectRootFolders(List<String> consoleinput){
  HashMap<String,Boolean> rootFolders=new HashMap<String,Boolean>();
  for (  String s : consoleinput) {
    if (!s.startsWith("String_Node_Str")) {
      continue;
    }
    Matcher m=pattern_catcs.matcher(s);
    if (m.matches()) {
      try {
        String key=m.group(2) + m.group(3);
        key=key.substring(1,key.length() - 1);
        key=key.replace("String_Node_Str","String_Node_Str");
        logger.info("String_Node_Str" + key);
        Boolean readOnly=s.contains("String_Node_Str");
        rootFolders.put(key,readOnly);
      }
 catch (      Exception ex) {
        logger.log(Level.SEVERE,"String_Node_Str" + s,ex);
      }
    }
  }
  return rootFolders;
}
Program: 44185
Project: 44185
Buggy source:
/** 
 * Load the Activity into memory from ClearCase.<br> This function is automatically called when needed by other functions.
 * @return 
 * @throws UnableToLoadEntityException
 */
public Activity load() throws UnableToLoadEntityException {
  String[] result=new String[2];
  if (isSpecialCase()) {
    result[0]="String_Node_Str";
    result[1]="String_Node_Str";
  }
 else {
    String cmd="String_Node_Str" + this;
    try {
      String line=Cleartool.run(cmd).stdoutBuffer.toString();
      result=line.split("String_Node_Str");
    }
 catch (    AbnormalProcessTerminationException e) {
      throw new UnableToLoadEntityException(this,e);
    }
  }
  setUser(result[0].trim());
  headline=result[1].trim();
  return this;
}

Fixed version (ground truth):
/** 
 * Load the Activity into memory from ClearCase.<br> This function is automatically called when needed by other functions.
 * @return 
 * @throws UnableToLoadEntityException
 */
public Activity load() throws UnableToLoadEntityException {
  String[] result=new String[2];
  if (isSpecialCase()) {
    result[0]="String_Node_Str";
    result[1]="String_Node_Str";
  }
 else {
    String cmd="String_Node_Str" + this;
    try {
      String line=Cleartool.run(cmd).stdoutBuffer.toString();
      result=line.split("String_Node_Str");
    }
 catch (    AbnormalProcessTerminationException e) {
      throw new UnableToLoadEntityException(this,e);
    }
  }
  setUser(result[0].trim());
  headline=result[1].trim();
  this.loaded=true;
  return this;
}
Program: 44186
Project: 44186
Buggy source:
public Version load() throws UnableToLoadEntityException {
  try {
    String cmd="String_Node_Str" + this + "String_Node_Str";
    String[] list=Cleartool.run(cmd).stdoutBuffer.toString().split("String_Node_Str");
    logger.finest("String_Node_Str" + Arrays.asList(list));
    setUser(list[0]);
    String vn=list[1];
    String ven=list[2];
    Matcher m=rx_extendedName.matcher(ven);
    if (list[3].equals("String_Node_Str")) {
      setKind(Kind.FILE_ELEMENT);
    }
 else     if (list[3].equals("String_Node_Str")) {
      setKind(Kind.DIRECTORY_ELEMENT);
    }
    activity=getActivity(this);
  }
 catch (  Exception e) {
    throw new UnableToLoadEntityException(this,e);
  }
  return this;
}

Fixed version (ground truth):
public Version load() throws UnableToLoadEntityException {
  try {
    String cmd="String_Node_Str" + this + "String_Node_Str";
    String[] list=Cleartool.run(cmd).stdoutBuffer.toString().split("String_Node_Str");
    logger.finest("String_Node_Str" + Arrays.asList(list));
    setUser(list[0]);
    String vn=list[1];
    String ven=list[2];
    Matcher m=rx_extendedName.matcher(ven);
    if (list[3].equals("String_Node_Str")) {
      setKind(Kind.FILE_ELEMENT);
    }
 else     if (list[3].equals("String_Node_Str")) {
      setKind(Kind.DIRECTORY_ELEMENT);
    }
    activity=getActivity(this);
  }
 catch (  Exception e) {
    throw new UnableToLoadEntityException(this,e);
  }
  this.loaded=true;
  return this;
}
Program: 44187
Project: 44187
Buggy source:
public Stream load() throws UCMEntityNotFoundException, UnableToLoadEntityException, UnableToInitializeEntityException {
  logger.fine("String_Node_Str");
  String rawdata="String_Node_Str";
  String cmd="String_Node_Str" + this;
  try {
    rawdata=Cleartool.run(cmd).stdoutBuffer.toString();
  }
 catch (  AbnormalProcessTerminationException e) {
    if (e.getMessage().matches(rx_stream_load)) {
      throw new UCMEntityNotFoundException(this,e);
    }
 else {
      throw new UnableToLoadEntityException(this,e);
    }
  }
  String[] data=rawdata.split("String_Node_Str");
  logger.fine("String_Node_Str" + data);
  setProject(Project.get(data[1]));
  if (!data[2].trim().equals("String_Node_Str")) {
    try {
      defaultTarget=Stream.get(data[2].trim());
    }
 catch (    Exception e) {
      logger.log(Level.WARNING,"String_Node_Str",e);
    }
  }
  if (data[3].length() > 0) {
    setReadOnly(true);
  }
 else {
    setReadOnly(false);
  }
  try {
    String[] blss=data[4].split("String_Node_Str");
    for (    String bls : blss) {
      addFoundationBaseline(Baseline.get(bls));
    }
  }
 catch (  Exception e) {
    logger.warning("String_Node_Str" + e.getMessage());
  }
  try {
    String ms=data[5].trim();
    this.mastership=ms;
  }
 catch (  Exception e) {
    logger.warning("String_Node_Str" + e.getMessage());
  }
  this.loaded=true;
  return this;
}

Fixed version (ground truth):
public Stream load() throws UCMEntityNotFoundException, UnableToLoadEntityException, UnableToInitializeEntityException {
  logger.fine("String_Node_Str");
  String rawdata="String_Node_Str";
  String cmd="String_Node_Str" + this;
  try {
    rawdata=Cleartool.run(cmd).stdoutBuffer.toString();
  }
 catch (  AbnormalProcessTerminationException e) {
    if (e.getMessage().matches(rx_stream_load)) {
      throw new UCMEntityNotFoundException(this,e);
    }
 else {
      throw new UnableToLoadEntityException(this,e);
    }
  }
  String[] data=rawdata.split("String_Node_Str");
  logger.fine("String_Node_Str" + Arrays.asList(data));
  setProject(Project.get(data[1]));
  if (!data[2].trim().equals("String_Node_Str")) {
    try {
      defaultTarget=Stream.get(data[2].trim());
    }
 catch (    Exception e) {
      logger.log(Level.WARNING,"String_Node_Str",e);
    }
  }
  if (data[3].length() > 0) {
    setReadOnly(true);
  }
 else {
    setReadOnly(false);
  }
  try {
    String[] blss=data[4].split("String_Node_Str");
    for (    String bls : blss) {
      addFoundationBaseline(Baseline.get(bls));
    }
  }
 catch (  Exception e) {
    logger.warning("String_Node_Str" + e.getMessage());
  }
  try {
    String ms=data[5].trim();
    this.mastership=ms;
  }
 catch (  Exception e) {
    logger.warning("String_Node_Str" + e.getMessage());
  }
  this.loaded=true;
  return this;
}
Program: 44188
Project: 44188
Buggy source:
public Stream load() throws UCMEntityNotFoundException, UnableToLoadEntityException, UnableToInitializeEntityException {
  logger.fine("String_Node_Str");
  String rawdata="String_Node_Str";
  String cmd="String_Node_Str" + this;
  try {
    rawdata=Cleartool.run(cmd).stdoutBuffer.toString();
  }
 catch (  AbnormalProcessTerminationException e) {
    if (e.getMessage().matches(rx_stream_load)) {
      throw new UCMEntityNotFoundException(this,e);
    }
 else {
      throw new UnableToLoadEntityException(this,e);
    }
  }
  String[] data=rawdata.split("String_Node_Str");
  logger.fine("String_Node_Str" + data);
  setProject(Project.get(data[1]));
  if (!data[2].trim().equals("String_Node_Str")) {
    try {
      setDefaultTarget(Stream.get(data[2].trim()));
    }
 catch (    Exception e) {
      logger.fine("String_Node_Str");
    }
  }
  if (data[3].length() > 0) {
    setReadOnly(true);
  }
 else {
    setReadOnly(false);
  }
  try {
    String[] blss=data[4].split("String_Node_Str");
    for (    String bls : blss) {
      addFoundationBaseline(Baseline.get(bls));
    }
  }
 catch (  Exception e) {
    logger.warning("String_Node_Str" + e.getMessage());
  }
  try {
    String ms=data[5].trim();
    this.mastership=ms;
  }
 catch (  Exception e) {
    logger.warning("String_Node_Str" + e.getMessage());
  }
  this.loaded=true;
  return this;
}

Fixed version (ground truth):
public Stream load() throws UCMEntityNotFoundException, UnableToLoadEntityException, UnableToInitializeEntityException {
  logger.fine("String_Node_Str");
  String rawdata="String_Node_Str";
  String cmd="String_Node_Str" + this;
  try {
    rawdata=Cleartool.run(cmd).stdoutBuffer.toString();
  }
 catch (  AbnormalProcessTerminationException e) {
    if (e.getMessage().matches(rx_stream_load)) {
      throw new UCMEntityNotFoundException(this,e);
    }
 else {
      throw new UnableToLoadEntityException(this,e);
    }
  }
  String[] data=rawdata.split("String_Node_Str");
  logger.fine("String_Node_Str" + data);
  setProject(Project.get(data[1]));
  if (!data[2].trim().equals("String_Node_Str")) {
    try {
      defaultTarget=Stream.get(data[2].trim());
    }
 catch (    Exception e) {
      logger.log(Level.WARNING,"String_Node_Str",e);
    }
  }
  if (data[3].length() > 0) {
    setReadOnly(true);
  }
 else {
    setReadOnly(false);
  }
  try {
    String[] blss=data[4].split("String_Node_Str");
    for (    String bls : blss) {
      addFoundationBaseline(Baseline.get(bls));
    }
  }
 catch (  Exception e) {
    logger.warning("String_Node_Str" + e.getMessage());
  }
  try {
    String ms=data[5].trim();
    this.mastership=ms;
  }
 catch (  Exception e) {
    logger.warning("String_Node_Str" + e.getMessage());
  }
  this.loaded=true;
  return this;
}
Program: 44189
Project: 44189
Buggy source:
public boolean deliver(boolean force,boolean complete,boolean abort,boolean resume) throws DeliverException, CleartoolException {
  try {
    return _deliver(force,complete,abort,false);
  }
 catch (  DeliverException e) {
    if (e.getType().equals(Type.DELIVER_IN_PROGRESS)) {
      String status=getStatus(stream);
      if (status.replace(System.getProperty("String_Node_Str"),"String_Node_Str").contains("String_Node_Str")) {
        try {
          return deliver(force,complete,abort,true);
        }
 catch (        DeliverException e1) {
          logger.warning("String_Node_Str" + e1.getMessage());
          throw e1;
        }
      }
 else {
        throw e;
      }
    }
    throw e;
  }
}

Fixed version (ground truth):
public boolean deliver(boolean force,boolean complete,boolean abort,boolean resume) throws DeliverException, CleartoolException {
  logger.debug("String_Node_Str" + baseline + "String_Node_Str"+ stream+ "String_Node_Str"+ target+ "String_Node_Str"+ context+ "String_Node_Str"+ viewtag);
  try {
    return _deliver(force,complete,abort,false);
  }
 catch (  DeliverException e) {
    if (e.getType().equals(Type.DELIVER_IN_PROGRESS)) {
      String status=getStatus(stream);
      if (status.replace(System.getProperty("String_Node_Str"),"String_Node_Str").contains("String_Node_Str")) {
        logger.debug("String_Node_Str");
        try {
          return _deliver(force,complete,abort,true);
        }
 catch (        DeliverException e1) {
          logger.warning("String_Node_Str" + e1.getMessage());
          throw e1;
        }
      }
 else {
        throw e;
      }
    }
    throw e;
  }
}
Program: 44190
Project: 44190
Buggy source:
public Deliver complete() throws DeliverException {
  String cmd="String_Node_Str";
  try {
    Cleartool.run(cmd,context);
    return this;
  }
 catch (  Exception e) {
    throw new DeliverException(this,Type.UNABLE_TO_COMPLETE,e);
  }
}

Fixed version (ground truth):
public Deliver complete() throws DeliverException {
  String cmd="String_Node_Str";
  cmd+=(baseline != null ? "String_Node_Str" + baseline : "String_Node_Str");
  cmd+=(stream != null ? "String_Node_Str" + stream : "String_Node_Str");
  cmd+=(target != null ? "String_Node_Str" + target : "String_Node_Str");
  cmd+=(viewtag != null ? "String_Node_Str" + viewtag : "String_Node_Str");
  try {
    Cleartool.run(cmd,context);
    return this;
  }
 catch (  Exception e) {
    throw new DeliverException(this,Type.UNABLE_TO_COMPLETE,e);
  }
}
Program: 44192
Project: 44192
Buggy source:
public List<Baseline> getPostedBaselinesFor(Component component) throws UnableToInitializeEntityException, UnableToListBaselinesException {
  logger.debug("String_Node_Str" + this.getFullyQualifiedName() + "String_Node_Str"+ component.getFullyQualifiedName());
  List<String> bls_str=null;
  String cmd="String_Node_Str" + this.getFullyQualifiedName();
  try {
    bls_str=Cleartool.run(cmd).stdoutList;
  }
 catch (  AbnormalProcessTerminationException e) {
    throw new UnableToListBaselinesException(getStream(),component,getPromotionLevel(true),e);
  }
  logger.debug("String_Node_Str" + bls_str.size() + "String_Node_Str");
  List<Baseline> bls=new ArrayList<Baseline>();
  int c=0;
  for (  String bl : bls_str) {
    logger.debug("String_Node_Str" + bl);
    logger.debug("String_Node_Str" + getStream().getFullyQualifiedName());
    Baseline b=Baseline.get(bl,getStream().getPVob());
    logger.debug("String_Node_Str" + b.getFullyQualifiedName() + "String_Node_Str"+ b.getComponent().getFullyQualifiedName());
    logger.debug("String_Node_Str" + component.getFullyQualifiedName());
    logger.debug("String_Node_Str" + b.getComponent().getFullyQualifiedName());
    if (b.getComponent().equals(component))     bls.add(b);
    c++;
  }
  return bls;
}

Fixed version (ground truth):
public List<Baseline> getPostedBaselinesFor(Component component) throws UnableToInitializeEntityException, UnableToListBaselinesException, UnableToLoadEntityException {
  logger.debug("String_Node_Str" + this.getFullyQualifiedName() + "String_Node_Str"+ component.getFullyQualifiedName());
  List<String> bls_str=null;
  String cmd="String_Node_Str" + this.getFullyQualifiedName();
  try {
    bls_str=Cleartool.run(cmd,null,false).stdoutList;
  }
 catch (  AbnormalProcessTerminationException e) {
    throw new UnableToListBaselinesException(getStream(),component,getPromotionLevel(true),e);
  }
  List<Baseline> bls=new ArrayList<Baseline>();
  for (  String bl_lines : bls_str) {
    logger.debug("String_Node_Str" + bl_lines);
    String[] baselines=bl_lines.split("String_Node_Str");
    logger.debug("String_Node_Str" + baselines.length + "String_Node_Str");
    for (    String bl : baselines) {
      logger.debug("String_Node_Str" + bl);
      Baseline b=Baseline.get(bl).load();
      logger.debug("String_Node_Str" + b.getFullyQualifiedName() + "String_Node_Str"+ b.getComponent().getFullyQualifiedName());
      logger.debug("String_Node_Str" + component.getFullyQualifiedName());
      logger.debug("String_Node_Str" + b.getComponent().getFullyQualifiedName());
      if (b.getComponent().equals(component))       bls.add(b);
    }
  }
  return bls;
}
Program: 44193
Project: 44193
Buggy source:
@Override public void tearDown() throws Exception {
  coolTest.tearDown();
  try {
    super.tearDown();
  }
 catch (  Exception e) {
    System.out.println("String_Node_Str" + super.jenkins.getRootDir());
    FileUtils.deleteDirectory(super.jenkins.getRootDir());
  }
}

Fixed version (ground truth):
@Override public void tearDown() throws Exception {
  coolTest.tearDown();
  try {
    super.tearDown();
  }
 catch (  Exception e) {
    System.out.println("String_Node_Str" + super.jenkins.getRootDir());
    try {
      FileUtils.forceDelete(super.jenkins.getRootDir());
    }
 catch (    IOException ioex) {
      System.out.println("String_Node_Str");
    }
  }
}
Program: 44194
Project: 44194
Buggy source:
@Override public void parse(Element e,Context context) throws ClearCaseException {
  String name=e.getAttribute("String_Node_Str");
  String label=e.getAttribute("String_Node_Str");
  String identical=e.getAttribute("String_Node_Str");
  String comment=e.getAttribute("String_Node_Str").length() > 0 ? e.getAttribute("String_Node_Str") : null;
  PVob pvob=new PVob(Cool.filesep + getValue("String_Node_Str",e,context));
  Component component=Component.get(e.getAttribute("String_Node_Str"),pvob);
  Element c=getFirstElement(e,"String_Node_Str");
  List<Component> components=null;
  try {
    components=new ArrayList<Component>();
    for (    Element c2 : getElements(c)) {
      PVob bpvob=new PVob(Cool.filesep + getValue("String_Node_Str",c2,context));
      components.add(Component.get(c2.getAttribute("String_Node_Str"),bpvob));
    }
  }
 catch (  Exception e1) {
  }
  Baseline.create(name,component,context.path,LabelBehaviour.valueOf(label),identical.length() > 0,null,components);
}

Fixed version (ground truth):
@Override public void parse(Element e,Context context) throws ClearCaseException {
  String name=e.getAttribute("String_Node_Str");
  String label=e.getAttribute("String_Node_Str");
  String identical=e.getAttribute("String_Node_Str");
  String comment=e.getAttribute("String_Node_Str").length() > 0 ? e.getAttribute("String_Node_Str") : null;
  PVob pvob=new PVob(Cool.filesep + getValue("String_Node_Str",e,context));
  Component component=Component.get(e.getAttribute("String_Node_Str"),pvob);
  List<Component> components=null;
  try {
    Element c=getFirstElement(e,"String_Node_Str");
    components=new ArrayList<Component>();
    for (    Element c2 : getElements(c)) {
      PVob bpvob=new PVob(Cool.filesep + getValue("String_Node_Str",c2,context));
      components.add(Component.get(c2.getAttribute("String_Node_Str"),bpvob));
    }
  }
 catch (  Exception e1) {
  }
  Baseline.create(name,component,context.path,LabelBehaviour.valueOf(label),identical.length() > 0,null,components);
}
Program: 44195
Project: 44195
Buggy source:
@Override public void parse(Element e,Context context) throws ClearCaseException {
  File file=new File(e.getAttribute("String_Node_Str"));
  if (!file.exists()) {
    try {
      file.createNewFile();
    }
 catch (    IOException e1) {
      throw new ClearCaseException(e1);
    }
  }
  Version.addToSourceControl(file,file.isDirectory(),context.path);
}

Fixed version (ground truth):
@Override public void parse(Element e,Context context) throws ClearCaseException {
  File file=new File(context.path,e.getAttribute("String_Node_Str"));
  if (!file.exists()) {
    try {
      file.createNewFile();
    }
 catch (    IOException e1) {
      throw new ClearCaseException(e1);
    }
  }
  Version.addToSourceControl(file,file.isDirectory(),context.path);
}
Program: 44196
Project: 44196
Buggy source:
@Override public void parse(Element e,Context context) throws ClearCaseException {
  File file=new File(e.getAttribute("String_Node_Str"));
  String content=e.getAttribute("String_Node_Str");
  try {
    FileWriter fw=new FileWriter(file);
    fw.write(content);
  }
 catch (  IOException e1) {
    throw new ClearCaseException(e1);
  }
}

Fixed version (ground truth):
@Override public void parse(Element e,Context context) throws ClearCaseException {
  File file=new File(context.path,e.getAttribute("String_Node_Str"));
  String content=e.getAttribute("String_Node_Str");
  try {
    FileWriter fw=new FileWriter(file);
    fw.write(content);
  }
 catch (  IOException e1) {
    throw new ClearCaseException(e1);
  }
}