nus-yam/ex-repair huggingface dataset:
Program: 11969
Project: 11969
Buggy source:
static void appendExtensionPostAssignSourceCode(StringBuilder buf,String code,String[] fromList,String to){
  Assertion.on("String_Node_Str").mustNotBeNull(code);
  Assertion.on("String_Node_Str").mustNotBeNull(fromList);
  Assertion.on("String_Node_Str").mustNotBeNull(to);
  String[] separatedListBySemicolon=code.split(StringValue.Semicolon);
  for (  String separatedBySemicolon : separatedListBySemicolon) {
    if (separatedBySemicolon != null && separatedBySemicolon.trim().length() > 0) {
      separatedBySemicolon=separatedBySemicolon.trim().replaceAll(StringValue.CarriageReturn,"String_Node_Str");
      String[] lines=separatedBySemicolon.split(StringValue.LineFeed);
      for (      String line : lines) {
        if (line != null && line.trim().length() > 0) {
          appendTabs(buf,2);
          line=line.trim();
          for (          String from : fromList) {
            line=line.replaceAll(from,to);
          }
          buf.append(line);
          if (!line.endsWith("String_Node_Str") && !line.endsWith("String_Node_Str") && !line.endsWith("String_Node_Str")&& !line.endsWith("String_Node_Str")) {
            buf.append(StringValue.Semicolon);
          }
          appendCRLF(buf);
        }
      }
    }
  }
}

Fixed version (ground truth):
static void appendExtensionPostAssignSourceCode(StringBuilder buf,String code,String[] fromList,String to){
  Assertion.on("String_Node_Str").mustNotBeNull(code);
  Assertion.on("String_Node_Str").mustNotBeNull(fromList);
  Assertion.on("String_Node_Str").mustNotBeNull(to);
  String[] separatedListBySemicolon=code.split(StringValue.Semicolon);
  for (  String separatedBySemicolon : separatedListBySemicolon) {
    if (separatedBySemicolon != null && separatedBySemicolon.trim().length() > 0) {
      separatedBySemicolon=separatedBySemicolon.trim().replaceAll(StringValue.CarriageReturn,"String_Node_Str");
      String[] lines=separatedBySemicolon.split(StringValue.LineFeed);
      for (int i=0; i < (lines.length - 1); i++) {
        String line=lines[i];
        if (line != null && line.trim().length() > 0) {
          appendTabs(buf,2);
          buf.append(line.trim());
          appendCRLF(buf);
        }
      }
      String lastLine=lines[lines.length - 1];
      if (lastLine != null && lastLine.trim().length() > 0) {
        appendTabs(buf,2);
        buf.append(lastLine.trim());
        if (!lastLine.endsWith("String_Node_Str") && !lastLine.endsWith("String_Node_Str")) {
          buf.append(StringValue.Semicolon);
        }
        appendCRLF(buf);
      }
    }
  }
}
Program: 11970
Project: 11970
Buggy source:
static void appendExtensionSourceCode(StringBuilder buf,String code){
  Assertion.on("String_Node_Str").mustNotBeNull(buf);
  Assertion.on("String_Node_Str").mustNotBeNull(code);
  String[] separatedListBySemicolon=code.split(StringValue.Semicolon);
  for (  String separatedBySemicolon : separatedListBySemicolon) {
    if (separatedBySemicolon != null && separatedBySemicolon.trim().length() > 0) {
      separatedBySemicolon=separatedBySemicolon.trim().replaceAll(StringValue.CarriageReturn,"String_Node_Str");
      String[] lines=separatedBySemicolon.split(StringValue.LineFeed);
      for (      String line : lines) {
        if (line != null && line.trim().length() > 0) {
          appendTabs(buf,2);
          buf.append(line.trim());
          if (!line.endsWith("String_Node_Str") && !line.endsWith("String_Node_Str") && !line.endsWith("String_Node_Str")&& !line.endsWith("String_Node_Str")) {
            buf.append(StringValue.Semicolon);
          }
          appendCRLF(buf);
        }
      }
    }
  }
}

Fixed version (ground truth):
static void appendExtensionSourceCode(StringBuilder buf,String code){
  Assertion.on("String_Node_Str").mustNotBeNull(buf);
  Assertion.on("String_Node_Str").mustNotBeNull(code);
  String[] separatedListBySemicolon=code.split(StringValue.Semicolon);
  for (  String separatedBySemicolon : separatedListBySemicolon) {
    if (separatedBySemicolon != null && separatedBySemicolon.trim().length() > 0) {
      separatedBySemicolon=separatedBySemicolon.trim().replaceAll(StringValue.CarriageReturn,"String_Node_Str");
      String[] lines=separatedBySemicolon.split(StringValue.LineFeed);
      for (int i=0; i < (lines.length - 1); i++) {
        String line=lines[i];
        if (line != null && line.trim().length() > 0) {
          appendTabs(buf,2);
          buf.append(line.trim());
          appendCRLF(buf);
        }
      }
      String lastLine=lines[lines.length - 1];
      if (lastLine != null && lastLine.trim().length() > 0) {
        appendTabs(buf,2);
        buf.append(lastLine.trim());
        if (!lastLine.endsWith("String_Node_Str") && !lastLine.endsWith("String_Node_Str")) {
          buf.append(StringValue.Semicolon);
        }
        appendCRLF(buf);
      }
    }
  }
}
Program: 11974
Project: 11974
Buggy source:
private static boolean isNeedToExclude(File javaFile){
  String canonicalClassName=javaFile.getAbsolutePath().replaceAll("String_Node_Str","String_Node_Str").replace("String_Node_Str","String_Node_Str").trim();
  String[] regexpListForExclusion=config.target.getRegexpArrayForExclusion();
  for (  String regexp : regexpListForExclusion) {
    if (regexp != null && regexp.trim().length() > 0 && canonicalClassName.matches("String_Node_Str" + regexp + "String_Node_Str")) {
      return true;
    }
  }
  return false;
}

Fixed version (ground truth):
private static boolean isNeedToExclude(File javaFile){
  String canonicalClassName=javaFile.getAbsolutePath().replaceAll("String_Node_Str","String_Node_Str").replace("String_Node_Str","String_Node_Str").trim();
  String[] regexpListForExclusion=config.target.getRegexpArrayForExclusion();
  for (  String regexp : regexpListForExclusion) {
    if (regexp != null && regexp.trim().length() > 0 && canonicalClassName.matches("String_Node_Str" + regexp.trim() + "String_Node_Str")) {
      return true;
    }
  }
  return false;
}
Program: 11975
Project: 11975
Buggy source:
public String[] getRegexpArrayForExclusion(){
  return regexpCsvForExclusion.split("String_Node_Str");
}

Fixed version (ground truth):
public String[] getRegexpArrayForExclusion(){
  return regexpCsvForExclusion.replaceAll("String_Node_Str","String_Node_Str").replaceAll("String_Node_Str","String_Node_Str").trim().split("String_Node_Str");
}
Program: 11976
Project: 11976
Buggy source:
String getFirstInstantiationSourceCode(ClassMeta classMeta);

Fixed version (ground truth):
String getFirstInstantiationSourceCode(Configuration config,ClassMeta classMeta);
Program: 11977
Project: 11977
Buggy source:
String getInstantiationSourceCode(ClassMeta classMeta,ConstructorMeta constructorMeta);

Fixed version (ground truth):
String getInstantiationSourceCode(Configuration config,ClassMeta classMeta,ConstructorMeta constructorMeta);
Program: 11978
Project: 11978
Buggy source:
List<String> getAllInstantiationSourceCodeList(ClassMeta classMeta);

Fixed version (ground truth):
List<String> getAllInstantiationSourceCodeList(Configuration config,ClassMeta classMeta);
Program: 11979
Project: 11979
Buggy source:
@Override public String getFirstInstantiationSourceCode(ClassMeta classMeta){
  return getInstantiationSourceCode(classMeta,getFirstConstructor(classMeta));
}

Fixed version (ground truth):
@Override public String getFirstInstantiationSourceCode(Configuration config,ClassMeta classMeta){
  return getInstantiationSourceCode(config,classMeta,getFirstConstructor(classMeta));
}
Program: 11981
Project: 11981
Buggy source:
@Override public List<String> getAllInstantiationSourceCodeList(ClassMeta classMeta){
  List<String> dest=new ArrayList<String>();
  for (  ConstructorMeta constructorMeta : classMeta.constructors) {
    dest.add(getInstantiationSourceCode(classMeta,constructorMeta));
  }
  return dest;
}

Fixed version (ground truth):
@Override public List<String> getAllInstantiationSourceCodeList(Configuration config,ClassMeta classMeta){
  List<String> dest=new ArrayList<String>();
  for (  ConstructorMeta constructorMeta : classMeta.constructors) {
    dest.add(getInstantiationSourceCode(config,classMeta,constructorMeta));
  }
  return dest;
}
Program: 11982
Project: 11982
Buggy source:
static String getInstantiationSourceCode(Configuration config,TestMethodMeta testMethodMeta){
  Assertion.on("String_Node_Str").mustNotBeNull(config);
  Assertion.on("String_Node_Str").mustNotBeNull(testMethodMeta);
  if (config.isExtensionEnabled && config.extConfiguration.extInstantiations != null) {
    for (    ExtInstantiation ins : config.extConfiguration.extInstantiations) {
      if (isCanonicalClassNameUsed(ins.canonicalClassName,testMethodMeta.classMeta.name,testMethodMeta.classMeta)) {
        for (        String newImport : ins.importList) {
          testMethodMeta.classMeta.importedList.add(newImport);
        }
        StringBuilder buf=new StringBuilder();
        if (ins.preAssignCode != null && ins.preAssignCode.trim().length() > 0) {
          appendExtensionSourceCode(buf,ins.preAssignCode);
        }
        buf.append(StringValue.Tab);
        buf.append(StringValue.Tab);
        buf.append(testMethodMeta.classMeta.name);
        buf.append("String_Node_Str");
        buf.append(ins.assignCode.trim());
        buf.append(StringValue.CarriageReturn);
        buf.append(StringValue.LineFeed);
        if (ins.postAssignCode != null && ins.postAssignCode.trim().length() > 0) {
          appendExtensionPostAssignSourceCode(buf,ins.postAssignCode,new String[]{"String_Node_Str"},"String_Node_Str");
        }
        return buf.toString();
      }
    }
  }
  return new DefaultConstructorGenerator().getFirstInstantiationSourceCode(testMethodMeta.classMeta);
}

Fixed version (ground truth):
static String getInstantiationSourceCode(Configuration config,TestMethodMeta testMethodMeta){
  Assertion.on("String_Node_Str").mustNotBeNull(config);
  Assertion.on("String_Node_Str").mustNotBeNull(testMethodMeta);
  if (config.isExtensionEnabled && config.extConfiguration.extInstantiations != null) {
    for (    ExtInstantiation ins : config.extConfiguration.extInstantiations) {
      if (isCanonicalClassNameUsed(ins.canonicalClassName,testMethodMeta.classMeta.name,testMethodMeta.classMeta)) {
        for (        String newImport : ins.importList) {
          testMethodMeta.classMeta.importedList.add(newImport);
        }
        StringBuilder buf=new StringBuilder();
        if (ins.preAssignCode != null && ins.preAssignCode.trim().length() > 0) {
          appendExtensionSourceCode(buf,ins.preAssignCode);
        }
        buf.append(StringValue.Tab);
        buf.append(StringValue.Tab);
        buf.append(testMethodMeta.classMeta.name);
        buf.append("String_Node_Str");
        buf.append(ins.assignCode.trim());
        buf.append(StringValue.CarriageReturn);
        buf.append(StringValue.LineFeed);
        if (ins.postAssignCode != null && ins.postAssignCode.trim().length() > 0) {
          appendExtensionPostAssignSourceCode(buf,ins.postAssignCode,new String[]{"String_Node_Str"},"String_Node_Str");
        }
        return buf.toString();
      }
    }
  }
  return new DefaultConstructorGenerator().getFirstInstantiationSourceCode(config,testMethodMeta.classMeta);
}
Program: 11983
Project: 11983
Buggy source:
static void appendExtensionPostAssignSourceCode(StringBuilder buf,String code,String[] fromList,String to){
  Assertion.on("String_Node_Str").mustNotBeNull(code);
  Assertion.on("String_Node_Str").mustNotBeNull(fromList);
  Assertion.on("String_Node_Str").mustNotBeNull(to);
  String[] separatedListBySemicolon=code.split(StringValue.Semicolon);
  for (  String separatedBySemicolon : separatedListBySemicolon) {
    if (separatedBySemicolon != null && separatedBySemicolon.trim().length() > 0) {
      separatedBySemicolon=separatedBySemicolon.trim().replaceAll(StringValue.CarriageReturn,"String_Node_Str");
      String[] lines=separatedBySemicolon.split(StringValue.LineFeed);
      for (      String line : lines) {
        if (line != null && line.trim().length() > 0) {
          appendTabs(buf,2);
          line=line.trim();
          for (          String from : fromList) {
            line=line.replaceAll(from,to);
          }
          buf.append(line);
          if (!line.endsWith("String_Node_Str") && !line.endsWith("String_Node_Str")) {
            buf.append(StringValue.Semicolon);
          }
          appendCRLF(buf);
        }
      }
    }
  }
}

Fixed version (ground truth):
static void appendExtensionPostAssignSourceCode(StringBuilder buf,String code,String[] fromList,String to){
  Assertion.on("String_Node_Str").mustNotBeNull(code);
  Assertion.on("String_Node_Str").mustNotBeNull(fromList);
  Assertion.on("String_Node_Str").mustNotBeNull(to);
  String[] separatedListBySemicolon=code.split(StringValue.Semicolon);
  for (  String separatedBySemicolon : separatedListBySemicolon) {
    if (separatedBySemicolon != null && separatedBySemicolon.trim().length() > 0) {
      separatedBySemicolon=separatedBySemicolon.trim().replaceAll(StringValue.CarriageReturn,"String_Node_Str");
      String[] lines=separatedBySemicolon.split(StringValue.LineFeed);
      for (      String line : lines) {
        if (line != null && line.trim().length() > 0) {
          appendTabs(buf,2);
          line=line.trim();
          for (          String from : fromList) {
            line=line.replaceAll(from,to);
          }
          buf.append(line);
          if (!line.endsWith("String_Node_Str") && !line.endsWith("String_Node_Str") && !line.endsWith("String_Node_Str")&& !line.endsWith("String_Node_Str")) {
            buf.append(StringValue.Semicolon);
          }
          appendCRLF(buf);
        }
      }
    }
  }
}
Program: 11984
Project: 11984
Buggy source:
static void appendExtensionSourceCode(StringBuilder buf,String code){
  Assertion.on("String_Node_Str").mustNotBeNull(code);
  String[] separatedListBySemicolon=code.split(StringValue.Semicolon);
  for (  String separatedBySemicolon : separatedListBySemicolon) {
    if (separatedBySemicolon != null && separatedBySemicolon.trim().length() > 0) {
      separatedBySemicolon=separatedBySemicolon.trim().replaceAll(StringValue.CarriageReturn,"String_Node_Str");
      String[] lines=separatedBySemicolon.split(StringValue.LineFeed);
      for (      String line : lines) {
        if (line != null && line.trim().length() > 0) {
          appendTabs(buf,2);
          buf.append(line.trim());
          if (!line.endsWith("String_Node_Str") && !line.endsWith("String_Node_Str")) {
            buf.append(StringValue.Semicolon);
          }
          appendCRLF(buf);
        }
      }
    }
  }
}

Fixed version (ground truth):
static void appendExtensionSourceCode(StringBuilder buf,String code){
  Assertion.on("String_Node_Str").mustNotBeNull(buf);
  Assertion.on("String_Node_Str").mustNotBeNull(code);
  String[] separatedListBySemicolon=code.split(StringValue.Semicolon);
  for (  String separatedBySemicolon : separatedListBySemicolon) {
    if (separatedBySemicolon != null && separatedBySemicolon.trim().length() > 0) {
      separatedBySemicolon=separatedBySemicolon.trim().replaceAll(StringValue.CarriageReturn,"String_Node_Str");
      String[] lines=separatedBySemicolon.split(StringValue.LineFeed);
      for (      String line : lines) {
        if (line != null && line.trim().length() > 0) {
          appendTabs(buf,2);
          buf.append(line.trim());
          if (!line.endsWith("String_Node_Str") && !line.endsWith("String_Node_Str") && !line.endsWith("String_Node_Str")&& !line.endsWith("String_Node_Str")) {
            buf.append(StringValue.Semicolon);
          }
          appendCRLF(buf);
        }
      }
    }
  }
}
Program: 11985
Project: 11985
Buggy source:
@Test public void appendIfNotExists_A$StringBuilder$String$String_StringIsNull() throws Exception {
  StringBuilder buf=new StringBuilder();
  String src=null;
  String importLine=null;
  try {
    DefaultGeneratorUtil.appendIfNotExists(buf,src,importLine);
    fail();
  }
 catch (  JUnitHelperCoreException e) {
  }
}

Fixed version (ground truth):
@Test(expected=JUnitHelperCoreException.class) public void appendIfNotExists_A$StringBuilder$String$String_StringIsNull() throws Exception {
  StringBuilder buf=new StringBuilder();
  String src=null;
  String importLine=null;
  DefaultGeneratorUtil.appendIfNotExists(buf,src,importLine);
}
Program: 11986
Project: 11986
Buggy source:
@Test public void appendTabs_A$StringBuilder$int_intIsMaxValue() throws Exception {
  StringBuilder buf=null;
  int times=Integer.MAX_VALUE;
  try {
    DefaultGeneratorUtil.appendTabs(buf,times);
    fail();
  }
 catch (  JUnitHelperCoreException e) {
  }
}

Fixed version (ground truth):
@Test(expected=JUnitHelperCoreException.class) public void appendTabs_A$StringBuilder$int_intIsMaxValue() throws Exception {
  StringBuilder buf=null;
  int times=Integer.MAX_VALUE;
  DefaultGeneratorUtil.appendTabs(buf,times);
}
Program: 11987
Project: 11987
Buggy source:
@Test public void appendTabs_A$StringBuilder$int_intIsMinValue() throws Exception {
  StringBuilder buf=null;
  int times=Integer.MIN_VALUE;
  try {
    DefaultGeneratorUtil.appendTabs(buf,times);
    fail();
  }
 catch (  JUnitHelperCoreException e) {
  }
}

Fixed version (ground truth):
@Test(expected=JUnitHelperCoreException.class) public void appendTabs_A$StringBuilder$int_intIsMinValue() throws Exception {
  StringBuilder buf=null;
  int times=Integer.MIN_VALUE;
  DefaultGeneratorUtil.appendTabs(buf,times);
}
Program: 11988
Project: 11988
Buggy source:
@Test public void appendExtensionPostAssignSourceCode_A$StringBuilder$String$StringArray$String_StringIsNull() throws Exception {
  StringBuilder buf=new StringBuilder();
  String code=null;
  String[] fromList=new String[]{};
  String to=null;
  try {
    DefaultGeneratorUtil.appendExtensionPostAssignSourceCode(buf,code,fromList,to);
    fail();
  }
 catch (  JUnitHelperCoreException e) {
  }
}

Fixed version (ground truth):
@Test(expected=JUnitHelperCoreException.class) public void appendExtensionPostAssignSourceCode_A$StringBuilder$String$StringArray$String_StringIsNull() throws Exception {
  StringBuilder buf=new StringBuilder();
  String code=null;
  String[] fromList=new String[]{};
  String to=null;
  DefaultGeneratorUtil.appendExtensionPostAssignSourceCode(buf,code,fromList,to);
}
Program: 11989
Project: 11989
Buggy source:
@Test public void getInstantiationSourceCode_A$Configuration$TestMethodMeta_Null() throws Exception {
  Configuration config=null;
  TestMethodMeta testMethodMeta=null;
  try {
    DefaultGeneratorUtil.getInstantiationSourceCode(config,testMethodMeta);
    fail();
  }
 catch (  JUnitHelperCoreException e) {
  }
}

Fixed version (ground truth):
@Test(expected=JUnitHelperCoreException.class) public void getInstantiationSourceCode_A$Configuration$TestMethodMeta_Null() throws Exception {
  Configuration config=null;
  TestMethodMeta testMethodMeta=null;
  DefaultGeneratorUtil.getInstantiationSourceCode(config,testMethodMeta);
}
Program: 11990
Project: 11990
Buggy source:
@Test public void appendExtensionSourceCode_A$StringBuilder$String_StringIsNull() throws Exception {
  StringBuilder buf=new StringBuilder();
  String code=null;
  try {
    DefaultGeneratorUtil.appendExtensionSourceCode(buf,code);
    fail();
  }
 catch (  JUnitHelperCoreException e) {
  }
}

Fixed version (ground truth):
@Test(expected=JUnitHelperCoreException.class) public void appendExtensionSourceCode_A$StringBuilder$String_StringIsNull() throws Exception {
  StringBuilder buf=new StringBuilder();
  String code=null;
  DefaultGeneratorUtil.appendExtensionSourceCode(buf,code);
}
Program: 11991
Project: 11991
Buggy source:
@Test public void appendTabs_A$StringBuilder$int_intIsMinus1() throws Exception {
  StringBuilder buf=new StringBuilder();
  int times=-1;
  try {
    DefaultGeneratorUtil.appendTabs(buf,times);
    fail();
  }
 catch (  JUnitHelperCoreException e) {
  }
}

Fixed version (ground truth):
@Test(expected=JUnitHelperCoreException.class) public void appendTabs_A$StringBuilder$int_intIsMinus1() throws Exception {
  StringBuilder buf=new StringBuilder();
  int times=-1;
  DefaultGeneratorUtil.appendTabs(buf,times);
}
Program: 11992
Project: 11992
Buggy source:
@Test public void isCanonicalClassNameUsed_A$String$String$ClassMeta_StringIsNull() throws Exception {
  String expectedCanonicalClassName=null;
  String usedClassName=null;
  ClassMeta targetClassMeta=null;
  try {
    DefaultGeneratorUtil.isCanonicalClassNameUsed(expectedCanonicalClassName,usedClassName,targetClassMeta);
    fail();
  }
 catch (  JUnitHelperCoreException e) {
  }
}

Fixed version (ground truth):
@Test(expected=JUnitHelperCoreException.class) public void isCanonicalClassNameUsed_A$String$String$ClassMeta_StringIsNull() throws Exception {
  String expectedCanonicalClassName=null;
  String usedClassName=null;
  ClassMeta targetClassMeta=null;
  DefaultGeneratorUtil.isCanonicalClassNameUsed(expectedCanonicalClassName,usedClassName,targetClassMeta);
}
Program: 11997
Project: 11997
Buggy source:
protected Configuration getConfiguration(IPreferenceStore store){
  return new PreferenceLoader(store).getConfig();
}

Fixed version (ground truth):
protected Configuration getConfiguration(IPreferenceStore store,ISelection selection){
  StructuredSelection structuredSelection=null;
  if (selection instanceof StructuredSelection) {
    structuredSelection=(StructuredSelection)selection;
  }
  if (!isNotSelected(structuredSelection) && !isSelectedSeveral(structuredSelection)) {
    String projectName=getProjectName(structuredSelection);
    String projectRootPath=getWorkspaceRootAbsolutePath(getIWorkspaceRoot()) + StringValue.DirectorySeparator.General + projectName+ StringValue.DirectorySeparator.General;
    String filepath=projectRootPath + "String_Node_Str";
    File configProperites=new File(filepath);
    if (configProperites.exists()) {
      try {
        return new ConfigurationLoader().load(filepath);
      }
 catch (      Exception e) {
        e.printStackTrace();
      }
    }
  }
  return new PreferenceLoader(store).getConfig();
}
Program: 12003
Project: 12003
Buggy source:
static String getInstantiationSourceCode(Configuration config,TestMethodMeta testMethodMeta){
  Assertion.mustNotBeNull(config,"String_Node_Str");
  Assertion.mustNotBeNull(testMethodMeta,"String_Node_Str");
  if (config.isExtensionEnabled && config.extConfiguration.extInstantiations != null) {
    for (    ExtInstantiation ins : config.extConfiguration.extInstantiations) {
      if (isCanonicalClassNameUsed(ins.canonicalClassName,testMethodMeta.classMeta.name,testMethodMeta.classMeta)) {
        for (        String newImport : ins.importList) {
          testMethodMeta.classMeta.importedList.add(newImport);
        }
        StringBuilder buf=new StringBuilder();
        if (ins.preAssignCode != null && ins.preAssignCode.trim().length() > 0) {
          appendExtensionSourceCode(buf,ins.preAssignCode);
        }
        buf.append(StringValue.Tab);
        buf.append(StringValue.Tab);
        buf.append(testMethodMeta.classMeta.name);
        buf.append("String_Node_Str");
        buf.append(ins.assignCode.trim());
        buf.append(StringValue.CarriageReturn);
        buf.append(StringValue.LineFeed);
        if (ins.postAssignCode != null && ins.postAssignCode.trim().length() > 0) {
          appendExtensionPostAssignSourceCode(buf,ins.postAssignCode,"String_Node_Str","String_Node_Str");
        }
        return buf.toString();
      }
    }
  }
  return new DefaultConstructorGenerator().getFirstInstantiationSourceCode(testMethodMeta.classMeta);
}

Fixed version (ground truth):
static String getInstantiationSourceCode(Configuration config,TestMethodMeta testMethodMeta){
  Assertion.mustNotBeNull(config,"String_Node_Str");
  Assertion.mustNotBeNull(testMethodMeta,"String_Node_Str");
  if (config.isExtensionEnabled && config.extConfiguration.extInstantiations != null) {
    for (    ExtInstantiation ins : config.extConfiguration.extInstantiations) {
      if (isCanonicalClassNameUsed(ins.canonicalClassName,testMethodMeta.classMeta.name,testMethodMeta.classMeta)) {
        for (        String newImport : ins.importList) {
          testMethodMeta.classMeta.importedList.add(newImport);
        }
        StringBuilder buf=new StringBuilder();
        if (ins.preAssignCode != null && ins.preAssignCode.trim().length() > 0) {
          appendExtensionSourceCode(buf,ins.preAssignCode);
        }
        buf.append(StringValue.Tab);
        buf.append(StringValue.Tab);
        buf.append(testMethodMeta.classMeta.name);
        buf.append("String_Node_Str");
        buf.append(ins.assignCode.trim());
        buf.append(StringValue.CarriageReturn);
        buf.append(StringValue.LineFeed);
        if (ins.postAssignCode != null && ins.postAssignCode.trim().length() > 0) {
          appendExtensionPostAssignSourceCode(buf,ins.postAssignCode,new String[]{"String_Node_Str"},"String_Node_Str");
        }
        return buf.toString();
      }
    }
  }
  return new DefaultConstructorGenerator().getFirstInstantiationSourceCode(testMethodMeta.classMeta);
}
Program: 12004
Project: 12004
Buggy source:
static void appendExtensionPostAssignSourceCode(StringBuilder buf,String code,String from,String to){
  String[] separatedListBySemicolon=code.split(StringValue.Semicolon);
  for (  String separatedBySemicolon : separatedListBySemicolon) {
    if (separatedBySemicolon != null && separatedBySemicolon.trim().length() > 0) {
      separatedBySemicolon=separatedBySemicolon.trim().replaceAll(StringValue.CarriageReturn,"String_Node_Str");
      String[] lines=separatedBySemicolon.split(StringValue.LineFeed);
      for (      String line : lines) {
        if (line != null && line.trim().length() > 0) {
          appendTabs(buf,2);
          buf.append(line.trim().replaceAll(from,to));
          if (!line.endsWith("String_Node_Str") && !line.endsWith("String_Node_Str")) {
            buf.append(StringValue.Semicolon);
          }
          appendCRLF(buf);
        }
      }
    }
  }
}

Fixed version (ground truth):
static void appendExtensionPostAssignSourceCode(StringBuilder buf,String code,String[] fromList,String to){
  Assertion.mustNotBeNull(code,"String_Node_Str");
  Assertion.mustNotBeNull(fromList,"String_Node_Str");
  Assertion.mustNotBeNull(to,"String_Node_Str");
  String[] separatedListBySemicolon=code.split(StringValue.Semicolon);
  for (  String separatedBySemicolon : separatedListBySemicolon) {
    if (separatedBySemicolon != null && separatedBySemicolon.trim().length() > 0) {
      separatedBySemicolon=separatedBySemicolon.trim().replaceAll(StringValue.CarriageReturn,"String_Node_Str");
      String[] lines=separatedBySemicolon.split(StringValue.LineFeed);
      for (      String line : lines) {
        if (line != null && line.trim().length() > 0) {
          appendTabs(buf,2);
          line=line.trim();
          for (          String from : fromList) {
            line=line.replaceAll(from,to);
          }
          buf.append(line);
          if (!line.endsWith("String_Node_Str") && !line.endsWith("String_Node_Str")) {
            buf.append(StringValue.Semicolon);
          }
          appendCRLF(buf);
        }
      }
    }
  }
}
Program: 12005
Project: 12005
Buggy source:
static void appendExtensionSourceCode(StringBuilder buf,String code){
  String[] separatedListBySemicolon=code.split(StringValue.Semicolon);
  for (  String separatedBySemicolon : separatedListBySemicolon) {
    if (separatedBySemicolon != null && separatedBySemicolon.trim().length() > 0) {
      separatedBySemicolon=separatedBySemicolon.trim().replaceAll(StringValue.CarriageReturn,"String_Node_Str");
      String[] lines=separatedBySemicolon.split(StringValue.LineFeed);
      for (      String line : lines) {
        if (line != null && line.trim().length() > 0) {
          appendTabs(buf,2);
          buf.append(line.trim());
          if (!line.endsWith("String_Node_Str") && !line.endsWith("String_Node_Str")) {
            buf.append(StringValue.Semicolon);
          }
          appendCRLF(buf);
        }
      }
    }
  }
}

Fixed version (ground truth):
static void appendExtensionSourceCode(StringBuilder buf,String code){
  Assertion.mustNotBeNull(code,"String_Node_Str");
  String[] separatedListBySemicolon=code.split(StringValue.Semicolon);
  for (  String separatedBySemicolon : separatedListBySemicolon) {
    if (separatedBySemicolon != null && separatedBySemicolon.trim().length() > 0) {
      separatedBySemicolon=separatedBySemicolon.trim().replaceAll(StringValue.CarriageReturn,"String_Node_Str");
      String[] lines=separatedBySemicolon.split(StringValue.LineFeed);
      for (      String line : lines) {
        if (line != null && line.trim().length() > 0) {
          appendTabs(buf,2);
          buf.append(line.trim());
          if (!line.endsWith("String_Node_Str") && !line.endsWith("String_Node_Str")) {
            buf.append(StringValue.Semicolon);
          }
          appendCRLF(buf);
        }
      }
    }
  }
}
Program: 12007
Project: 12007
Buggy source:
@Override public void characters(char[] ch,int start,int length) throws SAXException {
  tempValue=new String(ch,start,length);
}

Fixed version (ground truth):
@Override public void characters(char[] ch,int start,int length) throws SAXException {
  if (tempValue == null) {
    tempValue=new StringBuilder();
  }
  tempValue.append(new String(ch,start,length));
}
Program: 12016
Project: 12016
Buggy source:
private static boolean isNeedToExclude(File javaFile){
  String canonicalClassName=javaFile.getAbsolutePath().replaceAll("String_Node_Str","String_Node_Str").replace("String_Node_Str","String_Node_Str").trim();
  String[] regexpListForExclusion=config.target.getRegexpArrayForExclusion();
  for (  String regexp : regexpListForExclusion) {
    if (canonicalClassName.matches("String_Node_Str" + regexp + "String_Node_Str")) {
      return true;
    }
  }
  return false;
}

Fixed version (ground truth):
private static boolean isNeedToExclude(File javaFile){
  String canonicalClassName=javaFile.getAbsolutePath().replaceAll("String_Node_Str","String_Node_Str").replace("String_Node_Str","String_Node_Str").trim();
  String[] regexpListForExclusion=config.target.getRegexpArrayForExclusion();
  for (  String regexp : regexpListForExclusion) {
    if (regexp != null && regexp.trim().length() > 0 && canonicalClassName.matches("String_Node_Str" + regexp + "String_Node_Str")) {
      return true;
    }
  }
  return false;
}
Program: 12019
Project: 12019
Buggy source:
@Test public void getLackingTestMethodMetaList_A$String() throws Exception {
  String sourceCodeString="String_Node_Str";
  ClassMeta targetClassMeta=classMetaExtractor.extract(sourceCodeString);
  target.initialize(targetClassMeta);
  String currentTestCaseSourceCode="String_Node_Str";
  List<TestMethodMeta> actual=target.getLackingTestMethodMetaList(currentTestCaseSourceCode);
  assertEquals(3,actual.size());
  assertEquals(true,actual.get(0).isTypeTest);
  assertEquals(true,actual.get(1).isInstantiationTest);
  assertEquals("String_Node_Str",actual.get(2).methodMeta.name);
}

Fixed version (ground truth):
@Test public void getLackingTestMethodMetaList_A$String() throws Exception {
  String sourceCodeString="String_Node_Str";
  ClassMeta targetClassMeta=classMetaExtractor.extract(sourceCodeString);
  target.initialize(targetClassMeta);
  String currentTestCaseSourceCode="String_Node_Str";
  List<TestMethodMeta> actual=target.getLackingTestMethodMetaList(currentTestCaseSourceCode);
  assertEquals(4,actual.size());
  assertEquals(true,actual.get(0).isTypeTest);
  assertEquals(true,actual.get(1).isInstantiationTest);
  assertEquals("String_Node_Str",actual.get(2).methodMeta.name);
  assertEquals("String_Node_Str",actual.get(3).methodMeta.name);
}
Program: 12021
Project: 12021
Buggy source:
@Test public void getArgValue_A$TestMethodMeta$ArgTypeMeta$String() throws Exception {
  String sourceCodeString="String_Node_Str";
  ClassMeta targetClassMeta=classMetaExtractor.extract(sourceCodeString);
  target.initialize(targetClassMeta);
  MethodMeta targetMethodMeta=targetClassMeta.methods.get(0);
  TestMethodMeta testMethodMeta=target.getTestMethodMeta(targetMethodMeta);
  ArgTypeMeta argTypeMeta=targetMethodMeta.argTypes.get(0);
  String argName=targetMethodMeta.argNames.get(0);
  String actual=target.getArgValue(testMethodMeta,argTypeMeta,argName);
  String expected="String_Node_Str";
  assertEquals(expected,actual);
}

Fixed version (ground truth):
@Test public void getArgValue_A$TestMethodMeta$ArgTypeMeta$String() throws Exception {
  String sourceCodeString="String_Node_Str";
  ClassMeta targetClassMeta=classMetaExtractor.extract(sourceCodeString);
  target.initialize(targetClassMeta);
  MethodMeta targetMethodMeta=targetClassMeta.methods.get(0);
  TestMethodMeta testMethodMeta=target.getTestMethodMeta(targetMethodMeta);
  assertEquals("String_Node_Str",target.getArgValue(testMethodMeta,targetMethodMeta.argTypes.get(0),targetMethodMeta.argNames.get(0)));
  assertEquals("String_Node_Str",target.getArgValue(testMethodMeta,targetMethodMeta.argTypes.get(1),targetMethodMeta.argNames.get(1)));
  assertEquals("String_Node_Str",target.getArgValue(testMethodMeta,targetMethodMeta.argTypes.get(2),targetMethodMeta.argNames.get(2)));
  assertEquals("String_Node_Str",target.getArgValue(testMethodMeta,targetMethodMeta.argTypes.get(3),targetMethodMeta.argNames.get(3)));
  assertEquals("String_Node_Str",target.getArgValue(testMethodMeta,targetMethodMeta.argTypes.get(4),targetMethodMeta.argNames.get(4)));
}
Program: 12036
Project: 12036
Buggy source:
public void setMap(Map<String,Object> map){
}

Fixed version (ground truth):
public void setMap(Map<String,String> map){
  this.map=map;
}
Program: 12037
Project: 12037
Buggy source:
public void setList(List<String> arg){
}

Fixed version (ground truth):
public void setList(List<String> list){
  this.list=list;
}
Program: 12038
Project: 12038
Buggy source:
public Map<String,String> getMap(){
  return null;
}

Fixed version (ground truth):
public Map<String,String> getMap(){
  return map;
}
Program: 12040
Project: 12040
Buggy source:
/** 
 * Trim the all comment areas from source code string
 * @param source
 * @return result without line comments
 */
public static String trimAllComments(String source){
  return trimLineComments(source).replaceAll("String_Node_Str",StrConst.empty);
}

Fixed version (ground truth):
/** 
 * Trim the all comment areas from source code string
 * @param source
 * @return result without line comments
 */
public static String trimAllComments(String source){
  String withoutLineComments=trimLineComments(source);
  String withoutLineBreak=withoutLineComments.replaceAll("String_Node_Str",StrConst.empty);
  String withoutComments=withoutLineBreak.replaceAll("String_Node_Str",StrConst.empty);
  return withoutComments;
}
Program: 12047
Project: 12047
Buggy source:
/** 
 * Get detected encoding charset name
 * @param file
 * @return encoding charset name
 * @throws InvalidPreferenceException
 */
public static String detectEncoding(IFile file) throws InvalidPreferenceException {
  InputStream is=null;
  String encoding=null;
  try {
    is=FileResourceUtil.readFile(file);
    UniversalDetector detector=new UniversalDetector(null);
    byte[] buf=new byte[4096];
    int nread;
    while ((nread=is.read(buf)) > 0 && !detector.isDone())     detector.handleData(buf,0,nread);
    detector.dataEnd();
    encoding=detector.getDetectedCharset();
  }
 catch (  Exception e) {
    e.printStackTrace();
  }
 finally {
    close(is);
    if (encoding == null) {
      return Charset.defaultCharset().name();
    }
  }
  return encoding;
}

Fixed version (ground truth):
/** 
 * Get detected encoding charset name
 * @param file
 * @return encoding charset name
 * @throws InvalidPreferenceException
 */
public static String detectEncoding(IFile file){
  InputStream is=null;
  String encoding=null;
  try {
    is=FileResourceUtil.readFile(file);
    UniversalDetector detector=new UniversalDetector(null);
    byte[] buf=new byte[4096];
    int nread;
    while ((nread=is.read(buf)) > 0 && !detector.isDone())     detector.handleData(buf,0,nread);
    detector.dataEnd();
    encoding=detector.getDetectedCharset();
  }
 catch (  Exception e) {
    e.printStackTrace();
  }
 finally {
    close(is);
    if (encoding == null) {
      return Charset.defaultCharset().name();
    }
  }
  return encoding;
}
Program: 12048
Project: 12048
Buggy source:
/** 
 * Get target methods from source code string
 * @param source
 * @return result
 */
public static List<String> getTargetMethods(String source,boolean publicRequired,boolean protectedRequired,boolean packageLocalRequired){
  source=source.replaceAll("String_Node_Str" + STR.COMMA,STR.COMMA).replaceAll(STR.COMMA + "String_Node_Str",STR.COMMA).replaceAll("String_Node_Str","String_Node_Str").replaceAll("String_Node_Str","String_Node_Str");
  List<String> result=new ArrayList<String>();
  String regexp="String_Node_Str";
  Pattern pat=Pattern.compile(regexp);
  Matcher mat=pat.matcher(source);
  while (mat.find()) {
    String matched=mat.group();
    String prefix="String_Node_Str";
    String postfix="String_Node_Str";
    if (!publicRequired && matched.matches(prefix + "String_Node_Str" + postfix)) {
      continue;
    }
    if (!protectedRequired && matched.matches(prefix + "String_Node_Str" + postfix)) {
      continue;
    }
    if (!packageLocalRequired && matched.matches(prefix + postfix)) {
      continue;
    }
    matched=matched.replaceAll(STR.TAB,STR.SPACE).replaceAll(prefix + "String_Node_Str" + "String_Node_Str",STR.EMPTY).replaceAll(prefix + "String_Node_Str" + "String_Node_Str",STR.EMPTY).replaceAll(prefix + "String_Node_Str",STR.EMPTY).replaceAll("String_Node_Str",STR.SPACE);
    result.add(STR.SPACE + matched);
  }
  return result;
}

Fixed version (ground truth):
/** 
 * Get target methods from source code string
 * @param source
 * @return result
 */
public static List<String> getTargetMethods(String source,boolean publicRequired,boolean protectedRequired,boolean packageLocalRequired){
  source=source.replaceAll("String_Node_Str" + STR.COMMA,STR.COMMA).replaceAll(STR.COMMA + "String_Node_Str",STR.COMMA).replaceAll("String_Node_Str","String_Node_Str").replaceAll("String_Node_Str","String_Node_Str");
  List<String> result=new ArrayList<String>();
  String regexp="String_Node_Str";
  Pattern pat=Pattern.compile(regexp);
  Matcher mat=pat.matcher(source);
  while (mat.find()) {
    String matched=mat.group();
    String prefix="String_Node_Str";
    String postfix="String_Node_Str";
    if (!publicRequired && matched.matches(prefix + "String_Node_Str" + postfix)) {
      continue;
    }
    if (!protectedRequired && matched.matches(prefix + "String_Node_Str" + postfix)) {
      continue;
    }
    if (!packageLocalRequired && !matched.matches(prefix + "String_Node_Str" + postfix) && !matched.matches(prefix + "String_Node_Str" + postfix)) {
      continue;
    }
    matched=matched.replaceAll(STR.TAB,STR.SPACE).replaceAll(prefix + "String_Node_Str" + "String_Node_Str",STR.EMPTY).replaceAll(prefix + "String_Node_Str" + "String_Node_Str",STR.EMPTY).replaceAll(prefix + "String_Node_Str",STR.EMPTY).replaceAll("String_Node_Str",STR.SPACE);
    result.add(STR.SPACE + matched);
  }
  return result;
}
Program: 12055
Project: 12055
Buggy source:
/** 
 * Get type.
 * @param arg
 * @return
 */
private static String getType(String arg){
  arg=arg.trim().replaceAll("String_Node_Str",STR.EMPTY).split("String_Node_Str")[0];
  return arg;
}

Fixed version (ground truth):
/** 
 * Get type.
 * @param arg
 * @return
 */
protected static String getType(String arg){
  arg=arg.trim().replaceAll("String_Node_Str",STR.EMPTY).split("String_Node_Str")[0];
  return arg;
}
Program: 12056
Project: 12056
Buggy source:
/** 
 * Get type converted.
 * @param arg
 * @return
 */
private static String getTypeAvailableInMethodName(String arg){
  arg=arg.replaceAll(RXP_GENERICS_PART,STR.EMPTY);
  arg=arg.replaceAll("String_Node_Str",STR.EMPTY);
  arg=arg.replaceAll("String_Node_Str","String_Node_Str").replaceAll("String_Node_Str","String_Node_Str");
  arg=arg.replaceAll("String_Node_Str",STR.EMPTY);
  arg=arg.trim().split("String_Node_Str")[0];
  return arg;
}

Fixed version (ground truth):
/** 
 * Get type converted.
 * @param arg
 * @return
 */
protected static String getTypeAvailableInMethodName(String arg){
  arg=arg.replaceAll(RXP_GENERICS_PART,STR.EMPTY);
  arg=arg.replaceAll("String_Node_Str",STR.EMPTY);
  arg=arg.replaceAll("String_Node_Str","String_Node_Str").replaceAll("String_Node_Str","String_Node_Str");
  arg=arg.replaceAll("String_Node_Str",STR.EMPTY);
  arg=arg.trim().split("String_Node_Str")[0];
  return arg;
}
Program: 12057
Project: 12057
Buggy source:
private static String getClassInSourceCode(String returnTypeToCheck,String testTargetClassname,List<String> importList){
  if (returnTypeToCheck.matches("String_Node_Str"))   return returnTypeToCheck;
  boolean isArray=false;
  if (returnTypeToCheck.matches("String_Node_Str")) {
    isArray=true;
    returnTypeToCheck=returnTypeToCheck.replaceAll("String_Node_Str","String_Node_Str");
  }
  String returnTypeName="String_Node_Str";
  boolean returnTypeFound=false;
  try {
    if (PrimitiveTypeUtil.isPrimitive(returnTypeToCheck)) {
      returnTypeFound=true;
      if (!returnTypeName.matches("String_Node_Str"))       returnTypeName=PrimitiveTypeUtil.getPrimitiveDefaultValue(returnTypeToCheck);
    }
 else {
      try {
        Class.forName("String_Node_Str" + returnTypeToCheck);
        returnTypeFound=true;
      }
 catch (      Exception ignore) {
      }
      if (!returnTypeFound)       Class.forName(returnTypeToCheck);
    }
  }
 catch (  Exception e) {
    if (returnTypeToCheck.equals(testTargetClassname))     returnTypeFound=true;
    for (    String importedPackage : importList) {
      importedPackage=importedPackage.replaceAll("String_Node_Str",STR.EMPTY);
      if (importedPackage.matches("String_Node_Str" + returnTypeToCheck + "String_Node_Str")) {
        returnTypeFound=true;
        break;
      }
    }
  }
  if (!returnTypeFound) {
    if (isArray)     returnTypeName+="String_Node_Str";
    return returnTypeName;
  }
 else {
    if (isArray)     returnTypeToCheck+="String_Node_Str";
    return returnTypeToCheck;
  }
}

Fixed version (ground truth):
protected static String getClassInSourceCode(String returnTypeToCheck,String testTargetClassname,List<String> importList){
  if (returnTypeToCheck.matches("String_Node_Str"))   return returnTypeToCheck;
  boolean isArray=false;
  if (returnTypeToCheck.matches("String_Node_Str")) {
    isArray=true;
    returnTypeToCheck=returnTypeToCheck.replaceAll("String_Node_Str","String_Node_Str");
  }
  String returnTypeName="String_Node_Str";
  boolean returnTypeFound=false;
  try {
    if (PrimitiveTypeUtil.isPrimitive(returnTypeToCheck)) {
      returnTypeFound=true;
      if (!returnTypeName.matches("String_Node_Str"))       returnTypeName=PrimitiveTypeUtil.getPrimitiveDefaultValue(returnTypeToCheck);
    }
 else {
      try {
        Class.forName("String_Node_Str" + returnTypeToCheck);
        returnTypeFound=true;
      }
 catch (      Exception ignore) {
      }
      if (!returnTypeFound)       Class.forName(returnTypeToCheck);
    }
  }
 catch (  Exception e) {
    if (returnTypeToCheck.equals(testTargetClassname))     returnTypeFound=true;
    for (    String importedPackage : importList) {
      importedPackage=importedPackage.replaceAll("String_Node_Str",STR.EMPTY);
      if (importedPackage.matches("String_Node_Str" + returnTypeToCheck + "String_Node_Str")) {
        returnTypeFound=true;
        break;
      }
    }
  }
  if (!returnTypeFound) {
    if (isArray)     returnTypeName+="String_Node_Str";
    return returnTypeName;
  }
 else {
    if (isArray)     returnTypeToCheck+="String_Node_Str";
    return returnTypeToCheck;
  }
}
Program: 12059
Project: 12059
Buggy source:
public static void methodStaticReturnVoid(){
}

Fixed version (ground truth):
public static void methodStaticReturnVoid(){
  new InputStream(){
    @Override public int read() throws IOException {
      return 0;
    }
  }
;
}
Program: 12065
Project: 12065
Buggy source:
@Override public void initializeDefaultPreferences(){
  IPreferenceStore store=Activator.getDefault().getPreferenceStore();
{
    store.setDefault(Preference.Common.SRC_MAIN_PATH,"String_Node_Str");
    store.setDefault(Preference.Common.SRC_TEST_PATH,"String_Node_Str");
  }
{
    store.setDefault(Preference.TestClassGen.ENABLE,true);
    store.setDefault(Preference.TestClassGen.CLASS_TO_EXTEND,"String_Node_Str");
  }
{
    store.setDefault(Preference.TestMethodGen.ENABLE,true);
    store.setDefault(Preference.TestMethodGen.DELIMITER,"String_Node_Str");
    store.setDefault(Preference.TestMethodGen.ARGS,true);
    store.setDefault(Preference.TestMethodGen.ARGS_PREFIX,"String_Node_Str");
    store.setDefault(Preference.TestMethodGen.ARGS_DELIMITER,"String_Node_Str");
    store.setDefault(Preference.TestMethodGen.RETURN,false);
    store.setDefault(Preference.TestMethodGen.RETURN_PREFIX,"String_Node_Str");
    store.setDefault(Preference.TestMethodGen.RETURN_DELIMITER,"String_Node_Str");
    store.setDefault(Preference.TestMethodGen.EXLCUDES_ACCESSORS,true);
    store.setDefault(Preference.TestMethodGen.METHOD_SAMPLE_IMPLEMENTATION,true);
    store.setDefault(Preference.TestMethodGen.USING_MOCK,"String_Node_Str");
  }
}

Fixed version (ground truth):
@Override public void initializeDefaultPreferences(){
  IPreferenceStore store=Activator.getDefault().getPreferenceStore();
{
    store.setDefault(Preference.Common.SRC_MAIN_PATH,"String_Node_Str");
    store.setDefault(Preference.Common.SRC_TEST_PATH,"String_Node_Str");
  }
{
    store.setDefault(Preference.TestClassGen.ENABLE,true);
    store.setDefault(Preference.TestClassGen.CLASS_TO_EXTEND,"String_Node_Str");
  }
{
    store.setDefault(Preference.TestMethodGen.ENABLE,true);
    store.setDefault(Preference.TestMethodGen.EXLCUDES_ACCESSORS,true);
    store.setDefault(Preference.TestMethodGen.DELIMITER,"String_Node_Str");
    store.setDefault(Preference.TestMethodGen.ARGS,true);
    store.setDefault(Preference.TestMethodGen.ARGS_PREFIX,"String_Node_Str");
    store.setDefault(Preference.TestMethodGen.ARGS_DELIMITER,"String_Node_Str");
    store.setDefault(Preference.TestMethodGen.RETURN,false);
    store.setDefault(Preference.TestMethodGen.RETURN_PREFIX,"String_Node_Str");
    store.setDefault(Preference.TestMethodGen.RETURN_DELIMITER,"String_Node_Str");
    store.setDefault(Preference.TestMethodGen.METHOD_SAMPLE_IMPL,true);
    store.setDefault(Preference.TestMethodGen.USING_MOCK,"String_Node_Str");
  }
}