nus-yam/ex-repair huggingface dataset:
Program: 44543
Project: 44543
Buggy source:
@Test @SuppressWarnings("String_Node_Str") public void testMoveTo() throws Exception {
  URI toUri=new URI(blobStoreUri.toASCIIString() + "String_Node_Str");
  expect(mockConnection.getBlobStore()).andReturn(mockStore).times(2);
  expect(mockStore.getId()).andReturn(blobStoreUri).times(2);
  expect(mockConnection.getFileSystem()).andReturn(mockFs).times(9);
  expect(mockFs.exists((Path)anyObject())).andReturn(true);
  expect(mockConnection.getBlob((URI)anyObject(),(Map<String,String>)anyObject())).andReturn(new HDFSBlob(toUri,mockConnection));
  expect(mockFs.exists((Path)anyObject())).andReturn(false);
  expect(mockFs.exists((Path)anyObject())).andReturn(true);
  byte[] buf=new byte[1024];
  new Random().nextBytes(buf);
  expect(mockFs.open((Path)anyObject())).andReturn(new FSDataInputStream(new SeekableInputStream(buf)));
  expect(mockFs.exists((Path)anyObject())).andReturn(true);
  expect(mockFs.getFileStatus((Path)anyObject())).andReturn(createTestFileStatus());
  expect(mockFs.exists((Path)anyObject())).andReturn(false);
  expect(mockFs.create((Path)anyObject())).andReturn(new FSDataOutputStream(new ByteArrayOutputStream(1024),null));
  expect(mockFs.delete((Path)anyObject(),anyBoolean())).andReturn(true);
  replay(mockConnection,mockFs,mockStore);
  HDFSBlob b=new HDFSBlob(blobUri,mockConnection);
  HDFSBlob newBlob=(HDFSBlob)b.moveTo(toUri,null);
  assertNotNull(newBlob);
  assertEquals(toUri,newBlob.getId());
}

Fixed version (ground truth):
@Test @Ignore public void testMoveTo() throws Exception {
  URI toUri=new URI(blobStoreUri.toASCIIString() + "String_Node_Str");
  expect(mockConnection.getBlobStore()).andReturn(mockStore).times(1);
  expect(mockConnection.getBlob(anyObject(URI.class),anyObject(Map.class))).andReturn(new HDFSBlob(toUri,mockConnection));
  expect(mockStore.getId()).andReturn(blobStoreUri).times(2);
  expect(mockConnection.getFileSystem()).andReturn(mockFs).times(1);
  expect(mockFs.exists((Path)anyObject())).andReturn(true);
  expect(mockFs.exists((Path)anyObject())).andReturn(false);
  expect(mockFs.exists((Path)anyObject())).andReturn(true);
  byte[] buf=new byte[1024];
  new Random().nextBytes(buf);
  expect(mockFs.open((Path)anyObject())).andReturn(new FSDataInputStream(new SeekableInputStream(buf)));
  expect(mockFs.exists((Path)anyObject())).andReturn(true);
  expect(mockFs.getFileStatus((Path)anyObject())).andReturn(createTestFileStatus());
  expect(mockFs.exists((Path)anyObject())).andReturn(false);
  expect(mockFs.create((Path)anyObject())).andReturn(new FSDataOutputStream(new ByteArrayOutputStream(1024),null));
  expect(mockFs.delete((Path)anyObject(),anyBoolean())).andReturn(true);
  replay(mockConnection,mockFs,mockStore);
  HDFSBlob b=new HDFSBlob(blobUri,mockConnection);
  HDFSBlob newBlob=(HDFSBlob)b.moveTo(toUri,null);
  assertNotNull(newBlob);
  assertEquals(toUri,newBlob.getId());
}
Program: 44544
Project: 44544
Buggy source:
@Test public void testGetId() throws Exception {
  expect(mockConnection.getBlobStore()).andReturn(mockStore).times(2);
  expect(mockStore.getId()).andReturn(blobStoreUri).times(2);
  replay(mockConnection,mockFs,mockStore);
  HDFSBlob b=new HDFSBlob(blobUri,mockConnection);
  assertEquals(new URI(blobStoreUri + blobUri.toASCIIString().substring(5)),b.getId());
}

Fixed version (ground truth):
@Test public void testGetId() throws Exception {
  expect(mockConnection.getBlobStore()).andReturn(mockStore).times(3);
  expect(mockStore.getId()).andReturn(blobStoreUri).times(2);
  replay(mockConnection,mockFs,mockStore);
  HDFSBlob b=new HDFSBlob(blobUri,mockConnection);
  assertEquals(blobUri,b.getId());
}
Program: 44545
Project: 44545
Buggy source:
@Test public void testDelete() throws Exception {
  expect(mockConnection.getBlobStore()).andReturn(mockStore).times(2);
  expect(mockStore.getId()).andReturn(blobStoreUri).times(2);
  expect(mockConnection.getFileSystem()).andReturn(mockFs);
  expect(mockFs.delete((Path)anyObject(),anyBoolean())).andReturn(true);
  replay(mockConnection,mockFs,mockStore);
  HDFSBlob b=new HDFSBlob(blobUri,mockConnection);
  b.delete();
}

Fixed version (ground truth):
@Test public void testDelete() throws Exception {
  expect(mockConnection.getBlobStore()).andReturn(mockStore);
  expect(mockStore.getId()).andReturn(blobStoreUri);
  expect(mockConnection.getFileSystem()).andReturn(mockFs).times(2);
  expect(mockFs.delete((Path)anyObject(),anyBoolean())).andReturn(true);
  replay(mockConnection,mockFs,mockStore);
  HDFSBlob b=new HDFSBlob(blobUri,mockConnection);
  b.delete();
}
Program: 44546
Project: 44546
Buggy source:
@Test public void testGetCanonicalId() throws Exception {
  expect(mockConnection.getBlobStore()).andReturn(mockStore).times(2);
  expect(mockStore.getId()).andReturn(blobStoreUri).times(2);
  expect(mockConnection.getFileSystem()).andReturn(mockFs);
  replay(mockConnection,mockFs,mockStore);
  HDFSBlob b=new HDFSBlob(blobUri,mockConnection);
  assertEquals(new URI(blobStoreUri + blobUri.toASCIIString().substring(5)),b.getCanonicalId());
}

Fixed version (ground truth):
@Test public void testGetCanonicalId() throws Exception {
  expect(mockConnection.getBlobStore()).andReturn(mockStore).times(3);
  expect(mockStore.getId()).andReturn(blobStoreUri).times(2);
  expect(mockConnection.getFileSystem()).andReturn(mockFs);
  replay(mockConnection,mockFs,mockStore);
  HDFSBlob b=new HDFSBlob(blobUri,mockConnection);
  assertEquals(blobUri,b.getCanonicalId());
}
Program: 44547
Project: 44547
Buggy source:
@Test public void testOpenInputStream() throws Exception {
  expect(mockConnection.getBlobStore()).andReturn(mockStore).times(2);
  expect(mockConnection.getFileSystem()).andReturn(mockFs).times(2);
  expect(mockStore.getId()).andReturn(blobStoreUri).times(2);
  expect(mockFs.exists((Path)anyObject())).andReturn(true);
  byte[] buf=new byte[1024];
  new Random().nextBytes(buf);
  expect(mockFs.open((Path)anyObject())).andReturn(new FSDataInputStream(new SeekableInputStream(buf)));
  replay(mockConnection,mockFs,mockStore);
  HDFSBlob b=new HDFSBlob(blobUri,mockConnection);
  assertNotNull(b.openInputStream());
}

Fixed version (ground truth):
@Test public void testOpenInputStream() throws Exception {
  expect(mockConnection.getBlobStore()).andReturn(mockStore).times(3);
  expect(mockConnection.getFileSystem()).andReturn(mockFs).times(2);
  expect(mockStore.getId()).andReturn(blobStoreUri).times(2);
  expect(mockFs.exists((Path)anyObject())).andReturn(true);
  byte[] buf=new byte[1024];
  new Random().nextBytes(buf);
  expect(mockFs.open((Path)anyObject())).andReturn(new FSDataInputStream(new SeekableInputStream(buf)));
  replay(mockConnection,mockFs,mockStore);
  HDFSBlob b=new HDFSBlob(blobUri,mockConnection);
  assertNotNull(b.openInputStream());
}
Program: 44548
Project: 44548
Buggy source:
@Test public void testOpenOutputStream() throws Exception {
  expect(mockConnection.getBlobStore()).andReturn(mockStore).times(2);
  expect(mockStore.getId()).andReturn(blobStoreUri).times(2);
  expect(mockConnection.getFileSystem()).andReturn(mockFs).times(2);
  expect(mockFs.exists((Path)anyObject())).andReturn(false);
  expect(mockFs.create((Path)anyObject())).andReturn(new FSDataOutputStream(new ByteArrayOutputStream(1024),null));
  replay(mockConnection,mockFs,mockStore);
  HDFSBlob b=new HDFSBlob(blobUri,mockConnection);
  assertNotNull(b.openOutputStream(0,false));
}

Fixed version (ground truth):
@Test public void testOpenOutputStream() throws Exception {
  expect(mockConnection.getBlobStore()).andReturn(mockStore).times(3);
  expect(mockStore.getId()).andReturn(blobStoreUri).times(2);
  expect(mockConnection.getFileSystem()).andReturn(mockFs).times(2);
  expect(mockFs.exists((Path)anyObject())).andReturn(false);
  expect(mockFs.create((Path)anyObject())).andReturn(new FSDataOutputStream(new ByteArrayOutputStream(1024),null));
  replay(mockConnection,mockFs,mockStore);
  HDFSBlob b=new HDFSBlob(blobUri,mockConnection);
  assertNotNull(b.openOutputStream(0,false));
}
Program: 44549
Project: 44549
Buggy source:
@Test public void testGetConnection() throws Exception {
  expect(mockConnection.getBlobStore()).andReturn(mockStore).times(2);
  expect(mockStore.getId()).andReturn(blobStoreUri).times(2);
  replay(mockConnection,mockFs,mockStore);
  HDFSBlob b=new HDFSBlob(blobUri,mockConnection);
  assertEquals(mockConnection,b.getConnection());
}

Fixed version (ground truth):
@Test public void testGetConnection() throws Exception {
  expect(mockConnection.getBlobStore()).andReturn(mockStore).times(3);
  expect(mockStore.getId()).andReturn(blobStoreUri).times(2);
  replay(mockConnection,mockFs,mockStore);
  HDFSBlob b=new HDFSBlob(blobUri,mockConnection);
  assertEquals(mockConnection,b.getConnection());
}
Program: 44550
Project: 44550
Buggy source:
@Test public void testGetSize() throws Exception {
  expect(mockConnection.getBlobStore()).andReturn(mockStore).times(2);
  expect(mockStore.getId()).andReturn(blobStoreUri).times(2);
  expect(mockConnection.getFileSystem()).andReturn(mockFs).times(2);
  expect(mockFs.exists((Path)anyObject())).andReturn(true);
  expect(mockFs.getFileStatus((Path)anyObject())).andReturn(createTestFileStatus());
  replay(mockConnection,mockFs,mockStore);
  HDFSBlob b=new HDFSBlob(blobUri,mockConnection);
  assertTrue(b.getSize() == 1024);
}

Fixed version (ground truth):
@Test public void testGetSize() throws Exception {
  expect(mockConnection.getBlobStore()).andReturn(mockStore).times(3);
  expect(mockStore.getId()).andReturn(blobStoreUri).times(2);
  expect(mockConnection.getFileSystem()).andReturn(mockFs).times(2);
  expect(mockFs.exists((Path)anyObject())).andReturn(true);
  expect(mockFs.getFileStatus((Path)anyObject())).andReturn(createTestFileStatus());
  replay(mockConnection,mockFs,mockStore);
  HDFSBlob b=new HDFSBlob(blobUri,mockConnection);
  assertTrue(b.getSize() == 1024);
}
Program: 44552
Project: 44552
Buggy source:
/** 
 * Initialize the string format.
 */
private void init(){
  final Matcher matcher=PATTERN.matcher(format);
  int position=0;
  int i=0;
  while (i < format.length()) {
    if (matcher.find(i)) {
      if (matcher.start() != i) {
        formatParts.add(StringPart.of(position++,format.substring(i,matcher.start())));
      }
      final String[] formatGroup=new String[6];
      for (int groupIndex=0; groupIndex < matcher.groupCount(); groupIndex++) {
        formatGroup[groupIndex]=matcher.group(groupIndex + 1);
      }
      final StringFormatPart stringFormatPart=StringFormatPart.of(position++,formatGroup);
      formatParts.add(stringFormatPart);
      formats.add(stringFormatPart);
      i=matcher.end();
    }
 else {
      checkText(format.substring(i));
      formatParts.add(StringPart.of(position,format.substring(i)));
      break;
    }
  }
  final Set<Integer> counted=new HashSet<Integer>();
  for (  StringFormatPart stringFormatPart : formats) {
    if (stringFormatPart.conversion().isLineSeparator() || stringFormatPart.conversion().isPercent())     continue;
    if (stringFormatPart.index() > 0) {
      if (counted.add(stringFormatPart.index()))       argumentCount++;
    }
 else     if (stringFormatPart.index() == 0) {
      argumentCount++;
    }
  }
}

Fixed version (ground truth):
/** 
 * Initialize the string format.
 */
private void init(){
  final Matcher matcher=PATTERN.matcher(format);
  int position=0;
  int i=0;
  while (i < format.length()) {
    if (matcher.find(i)) {
      if (matcher.start() != i) {
        formatParts.add(StringPart.of(position++,format.substring(i,matcher.start())));
      }
      final String[] formatGroup=new String[6];
      for (int groupIndex=0; groupIndex < matcher.groupCount(); groupIndex++) {
        formatGroup[groupIndex]=matcher.group(groupIndex + 1);
      }
      final StringFormatPart stringFormatPart=StringFormatPart.of(position++,formatGroup);
      formatParts.add(stringFormatPart);
      formats.add(stringFormatPart);
      i=matcher.end();
    }
 else {
      checkText(format.substring(i));
      formatParts.add(StringPart.of(position,format.substring(i)));
      break;
    }
  }
  final Set<Integer> counted=new HashSet<Integer>();
  int count=1;
  for (  StringFormatPart stringFormatPart : formats) {
    if (stringFormatPart.conversion().isLineSeparator() || stringFormatPart.conversion().isPercent())     continue;
    if (stringFormatPart.index() > 0) {
      if (counted.add(stringFormatPart.index())) {
        argumentCount++;
      }
    }
 else     if (stringFormatPart.index() == 0) {
      if (!counted.contains(count)) {
        argumentCount++;
        counted.add(count);
        count++;
      }
    }
  }
}
Program: 44554
Project: 44554
Buggy source:
static List<StringFormatPart> sortParts(final Collection<StringFormatPart> parts){
  final TreeMap<Integer,List<StringFormatPart>> paramMap=new TreeMap<Integer,List<StringFormatPart>>();
  int counter=0;
  int index=0;
  for (  StringFormatPart part : parts) {
    if (part.index() > 0 || part.index() == 0) {
      index=part.index();
    }
 else     if (part.index() < -1) {
      index=0;
    }
    final List<StringFormatPart> params;
    if (paramMap.containsKey(index)) {
      params=paramMap.get(index);
      if (index > 0) {
        continue;
      }
    }
 else {
      params=new ArrayList<StringFormatPart>();
      paramMap.put(index,params);
    }
    counter++;
    params.add(part);
  }
  final List<StringFormatPart> result=new ArrayList<StringFormatPart>(parts.size());
  for (  List<StringFormatPart> list : paramMap.values()) {
    result.addAll(list);
  }
  return result;
}

Fixed version (ground truth):
static List<StringFormatPart> sortParts(final Collection<StringFormatPart> parts){
  final TreeMap<Integer,StringFormatPart> paramMap=new TreeMap<Integer,StringFormatPart>();
  int index=0;
  int count=0;
  for (  StringFormatPart part : parts) {
    if (part.index() > 0) {
      index=part.index();
    }
 else     if (part.index() == 0) {
      index=++count;
    }
    if (!paramMap.containsKey(index)) {
      paramMap.put(index,part);
    }
  }
  return new ArrayList<StringFormatPart>(paramMap.values());
}
Program: 44555
Project: 44555
Buggy source:
private void compare(final int handlerIndex,final String key,final Properties properties,final Object... params){
  final String expectedMessage=getFormattedProperty(key,properties,params);
  final String loggedMessage=HANDLER.getMessage(handlerIndex).replaceAll(LOGGER_ID_PATTERN,"String_Node_Str");
  Assert.assertEquals(expectedMessage,loggedMessage);
}

Fixed version (ground truth):
private void compare(final int handlerIndex,final String key,final Properties properties,final Object... params){
  final String expectedMessage=getFormattedProperty(key,properties,params);
  final String loggedMessage=HANDLER.getMessage(handlerIndex).replaceAll(LOGGER_ID_PATTERN,"String_Node_Str");
  Assert.assertEquals(loggedMessage,expectedMessage);
}
Program: 44556
Project: 44556
Buggy source:
@Test public void testStringFormat() throws Exception {
  final String fileName="String_Node_Str";
  final Properties en=findFile(String.format(fileName,"String_Node_Str"));
  final Properties es=findFile(String.format(fileName,"String_Node_Str"));
  final StringFormatLogger logger=Logger.getMessageLogger(StringFormatLogger.class,CATEGORY,new Locale("String_Node_Str"));
  final Date date=new Date();
  logger.dukesBirthday(date);
  logger.dukesBirthdayFailure(date);
  logger.stringInt("String_Node_Str",1);
  logger.stringIntFailure("String_Node_Str",1);
  compare(0,"String_Node_Str",es,date);
  compare(1,"String_Node_Str",en,date);
  compare(2,"String_Node_Str",es,"String_Node_Str",1);
  compare(3,"String_Node_Str",en,"String_Node_Str",1);
}

Fixed version (ground truth):
@Test public void testStringFormat() throws Exception {
  final String fileName="String_Node_Str";
  final Properties en=findFile(String.format(fileName,"String_Node_Str"));
  final Properties es=findFile(String.format(fileName,"String_Node_Str"));
  final StringFormatLogger logger=Logger.getMessageLogger(StringFormatLogger.class,CATEGORY,new Locale("String_Node_Str"));
  final Date date=new Date();
  logger.dukesBirthday(date);
  logger.dukesBirthdayFailure(date);
  compare(0,"String_Node_Str",es,date);
  compare(1,"String_Node_Str",en,date);
  logger.stringInt("String_Node_Str",1);
  logger.stringIntFailure("String_Node_Str",1);
  compare(2,"String_Node_Str",es,"String_Node_Str",1);
  compare(3,"String_Node_Str",en,"String_Node_Str",1);
  logger.repeat("String_Node_Str");
  logger.repeatFailure("String_Node_Str");
  compare(4,"String_Node_Str",es,"String_Node_Str");
  compare(5,"String_Node_Str",en,"String_Node_Str");
}
Program: 44557
Project: 44557
Buggy source:
@Test public void validateParameterTypePerPosition(){
  StringFormatValidator validator=StringFormatValidator.of("String_Node_Str","String_Node_Str",10,"String_Node_Str");
  assertTrue(validator.isValid(),validator.detailMessage());
  validator=StringFormatValidator.of("String_Node_Str","String_Node_Str",42,"String_Node_Str");
  assertFalse(validator.isValid(),validator.detailMessage());
  validator=StringFormatValidator.of("String_Node_Str","String_Node_Str",42);
  assertTrue(validator.isValid(),validator.detailMessage());
  validator=StringFormatValidator.of("String_Node_Str",42,new Date(),"String_Node_Str");
  assertTrue(validator.isValid(),validator.detailMessage());
  validator=StringFormatValidator.of("String_Node_Str","String_Node_Str",42);
  assertTrue(validator.isValid(),validator.detailMessage());
}

Fixed version (ground truth):
@Test public void validateParameterTypePerPosition(){
  StringFormatValidator validator=StringFormatValidator.of("String_Node_Str","String_Node_Str",10,"String_Node_Str");
  assertTrue(validator.isValid(),validator.detailMessage());
  validator=StringFormatValidator.of("String_Node_Str","String_Node_Str",42,"String_Node_Str");
  assertFalse(validator.isValid(),validator.detailMessage());
  validator=StringFormatValidator.of("String_Node_Str","String_Node_Str",42);
  assertTrue(validator.isValid(),validator.detailMessage());
  validator=StringFormatValidator.of("String_Node_Str",42,new Date(),"String_Node_Str");
  assertTrue(validator.isValid(),validator.detailMessage());
  validator=StringFormatValidator.of("String_Node_Str","String_Node_Str",42);
  assertTrue(validator.isValid(),validator.detailMessage());
  validator=StringFormatValidator.of("String_Node_Str","String_Node_Str");
  assertTrue(validator.isValid(),validator.detailMessage());
}
Program: 44558
Project: 44558
Buggy source:
@Override public boolean isAssignableFrom(final Class<?> type){
  final TypeMirror typeMirror=elements.getTypeElement(type.getName().replace("String_Node_Str","String_Node_Str")).asType();
  return types.isAssignable(param.asType(),typeMirror);
}

Fixed version (ground truth):
@Override public boolean isAssignableFrom(final Class<?> type){
  final TypeMirror typeMirror=elements.getTypeElement(typeToString(type)).asType();
  return types.isAssignable(param.asType(),typeMirror);
}
Program: 44559
Project: 44559
Buggy source:
@Override public boolean isSubtypeOf(final Class<?> type){
  final TypeMirror typeMirror=elements.getTypeElement(type.getName().replace("String_Node_Str","String_Node_Str")).asType();
  return types.isSubtype(typeMirror,param.asType());
}

Fixed version (ground truth):
@Override public boolean isSubtypeOf(final Class<?> type){
  final TypeMirror typeMirror=elements.getTypeElement(typeToString(type)).asType();
  return types.isSubtype(typeMirror,param.asType());
}
Program: 44560
Project: 44560
Buggy source:
private boolean checkType(final Parameter parameter,final TypeMirror type){
  if (parameter.isPrimitive()) {
    return parameter.type().equalsIgnoreCase(type.getKind().name());
  }
  return types.isAssignable(elements.getTypeElement(parameter.type()).asType(),type);
}

Fixed version (ground truth):
private boolean checkType(final Parameter parameter,final TypeMirror type){
  if (parameter.isPrimitive()) {
    if (type.getKind().isPrimitive()) {
      return parameter.type().equalsIgnoreCase(type.getKind().name());
    }
    return types.isAssignable(elements.getTypeElement(unbox(parameter)).asType(),type);
  }
  if (type.getKind().isPrimitive()) {
    final TypeElement primitiveType=types.boxedClass((PrimitiveType)type);
    return types.isAssignable(elements.getTypeElement(parameter.type()).asType(),primitiveType.asType());
  }
  return types.isAssignable(elements.getTypeElement(parameter.type()).asType(),type);
}
Program: 44561
Project: 44561
Buggy source:
/** 
 * Generate the code corresponding to this class model
 * @return the generated code
 * @throws IllegalStateException if the class has already been defined.
 */
JCodeModel generateModel() throws IllegalStateException {
  final JDefinedClass definedClass=getDefinedClass();
  JAnnotationUse generatedAnnotation=definedClass.annotate(javax.annotation.Generated.class);
  generatedAnnotation.param("String_Node_Str",getClass().getName());
  generatedAnnotation.param("String_Node_Str",ClassModelHelper.generatedDateValue());
  JDocComment docComment=definedClass.javadoc();
  docComment.add("String_Node_Str");
  if (superClassName != null) {
    definedClass._extends(codeModel.ref(superClassName));
  }
  definedClass._implements(codeModel.ref(messageInterface.name().replace("String_Node_Str","String_Node_Str")));
  if (!messageInterface.extendedInterfaces().isEmpty()) {
    for (    MessageInterface intf : messageInterface.extendedInterfaces()) {
      final String interfaceName=intf.name().replace("String_Node_Str","String_Node_Str");
      definedClass._implements(codeModel.ref(interfaceName));
    }
  }
  return codeModel;
}

Fixed version (ground truth):
/** 
 * Generate the code corresponding to this class model
 * @return the generated code
 * @throws IllegalStateException if the class has already been defined.
 */
JCodeModel generateModel() throws IllegalStateException {
  final JDefinedClass definedClass=getDefinedClass();
  JAnnotationUse generatedAnnotation=definedClass.annotate(javax.annotation.Generated.class);
  generatedAnnotation.param("String_Node_Str",getClass().getName());
  generatedAnnotation.param("String_Node_Str",ClassModelHelper.generatedDateValue());
  JDocComment docComment=definedClass.javadoc();
  docComment.add("String_Node_Str");
  if (superClassName != null) {
    definedClass._extends(codeModel.ref(superClassName));
  }
  definedClass._implements(codeModel.ref(typeToString(messageInterface.name())));
  if (!messageInterface.extendedInterfaces().isEmpty()) {
    for (    MessageInterface intf : messageInterface.extendedInterfaces()) {
      final String interfaceName=typeToString(intf.name());
      definedClass._implements(codeModel.ref(interfaceName));
    }
  }
  return codeModel;
}
Program: 44562
Project: 44562
Buggy source:
/** 
 * Returns the number of parameters excluding the   {@link org.jboss.logging.generator.Annotations#cause()} parameterand any  {@link org.jboss.logging.generator.Annotations#param()} parameters if found.
 * @param params the parameters to get the count for.
 * @return the number of parameters.
 */
public static int parameterCount(final Collection<? extends VariableElement> params){
  int result=params.size();
  for (  VariableElement param : params) {
    if (isAnnotatedWith(param,annotations().param())) {
      --result;
    }
  }
  return (result - (hasCause(params) ? 1 : 0));
}

Fixed version (ground truth):
/** 
 * Returns the number of parameters excluding the   {@link org.jboss.logging.generator.Annotations#cause()} parameterand any  {@link org.jboss.logging.generator.Annotations#param()} parameters if found.
 * @param params the parameters to get the count for.
 * @return the number of parameters.
 */
public static int parameterCount(final Collection<? extends VariableElement> params){
  int result=params.size();
  for (  VariableElement param : params) {
    if (isAnnotatedWith(param,annotations().param()) || isAnnotatedWith(param,annotations().field()) || isAnnotatedWith(param,annotations().property())) {
      --result;
    }
  }
  return (result - (hasCause(params) ? 1 : 0));
}
Program: 44563
Project: 44563
Buggy source:
@Override public void processTypeElement(final TypeElement annotation,final TypeElement element,final MessageInterface messageInterface){
  if (generatedFilesPath != null) {
    if (element.getKind().isInterface()) {
      String packageName=elementUtils().getPackageOf(element).getQualifiedName().toString();
      String relativePath=packageName.replaceAll("String_Node_Str",FILE_SEPARATOR);
      String fileName=getPrimaryClassNamePrefix(element) + GENERATED_FILE_EXTENSION;
      this.generateSkeletalTranslationFile(relativePath,fileName,messageInterface);
    }
  }
}

Fixed version (ground truth):
@Override public void processTypeElement(final TypeElement annotation,final TypeElement element,final MessageInterface messageInterface){
  if (generatedFilesPath != null) {
    if (element.getKind().isInterface()) {
      String packageName=elementUtils().getPackageOf(element).getQualifiedName().toString();
      String relativePath=packageName.replace('.',File.separatorChar);
      String fileName=getPrimaryClassNamePrefix(element) + GENERATED_FILE_EXTENSION;
      this.generateSkeletalTranslationFile(relativePath,fileName,messageInterface);
    }
  }
}
Program: 44564
Project: 44564
Buggy source:
/** 
 * Initializes the instance.
 * @param typeUtil the type utilities for internal usage.
 * @param method   the method to process.
 */
private void init(final Types typeUtil,ExecutableElement method){
  this.method=method;
  Message message=method.getAnnotation(Message.class);
  LogMessage logMessage=method.getAnnotation(LogMessage.class);
  if (method.getReturnType().getKind() != TypeKind.VOID) {
    try {
      this.returnTypeDescriptor=ReturnType.of(this.returnType());
    }
 catch (    ClassNotFoundException ex) {
      throw new IllegalStateException(String.format("String_Node_Str",method.getReturnType(),method));
    }
  }
  final Collection<MethodDescriptor> methodDescriptors=find(this.name());
  for (  MethodDescriptor methodDesc : methodDescriptors) {
    if (methodDesc.message() != null && message == null) {
      message=methodDesc.message();
    }
    if (message != null) {
      break;
    }
  }
  for (  MethodDescriptor methodDesc : methodDescriptors) {
    if (methodDesc.message == null) {
      methodDesc.message=message;
      descriptors.remove(methodDesc);
      descriptors.add(methodDesc);
    }
  }
  for (  VariableElement param : method.getParameters()) {
    if (param.getAnnotation(Cause.class) != null) {
      this.cause=new MethodParameter(typeUtil.asElement(param.asType()).toString(),param);
    }
    if (param.asType().getKind().isPrimitive()) {
      this.parameters.add(new MethodParameter(param.asType().toString(),param));
    }
 else {
      this.parameters.add(new MethodParameter(typeUtil.asElement(param.asType()).toString(),param));
    }
  }
  this.logMessage=logMessage;
  this.message=message;
}

Fixed version (ground truth):
/** 
 * Initializes the instance.
 * @param typeUtil the type utilities for internal usage.
 * @param method   the method to process.
 */
private void init(final Types typeUtil,ExecutableElement method){
  this.method=method;
  Message message=method.getAnnotation(Message.class);
  LogMessage logMessage=method.getAnnotation(LogMessage.class);
  this.returnType=ReturnType.of(method.getReturnType(),typeUtil);
  final Collection<MethodDescriptor> methodDescriptors=find(this.name());
  for (  MethodDescriptor methodDesc : methodDescriptors) {
    if (methodDesc.message() != null && message == null) {
      message=methodDesc.message();
    }
    if (message != null) {
      break;
    }
  }
  for (  MethodDescriptor methodDesc : methodDescriptors) {
    if (methodDesc.message == null) {
      methodDesc.message=message;
      descriptors.remove(methodDesc);
      descriptors.add(methodDesc);
    }
  }
  for (  VariableElement param : method.getParameters()) {
    if (param.getAnnotation(Cause.class) != null) {
      this.cause=new MethodParameter(typeUtil.asElement(param.asType()).toString(),param);
    }
    if (param.asType().getKind().isPrimitive()) {
      this.parameters.add(new MethodParameter(param.asType().toString(),param));
    }
 else {
      this.parameters.add(new MethodParameter(typeUtil.asElement(param.asType()).toString(),param));
    }
  }
  this.logMessage=logMessage;
  this.message=message;
}
Program: 44565
Project: 44565
Buggy source:
/** 
 * Returns the return type for the method.
 * @return the return type for the method.
 */
public String returnType(){
  return method.getReturnType().toString();
}

Fixed version (ground truth):
/** 
 * Returns the return type descriptor.
 * @return the return type descriptor.
 */
public ReturnType returnType(){
  return returnType;
}
Program: 44566
Project: 44566
Buggy source:
/** 
 * Initializes the object.
 */
private void init(){
  if (!primitive) {
    final Constructor<?>[] constructors=returnType.getConstructors();
    for (    Constructor<?> construct : constructors) {
      final Class<?>[] params=construct.getParameterTypes();
switch (params.length) {
case 1:
        final Class<?> param=params[0];
      if (param.isAssignableFrom(String.class)) {
        stringConsturctor=true;
      }
 else       if (Throwable.class.isAssignableFrom(param)) {
        throwableConstructor=true;
      }
    break;
case 2:
  final Class<?> param1=params[0];
final Class<?> param2=params[1];
if (param1.isAssignableFrom(String.class) && Throwable.class.isAssignableFrom(param2)) {
stringAndThrowableConstructor=true;
}
 else if (Throwable.class.isAssignableFrom(param1) && param2.isAssignableFrom(String.class)) {
throwableAndStringConstructor=true;
}
break;
}
}
}
}

Fixed version (ground truth):
/** 
 * Initializes the object.
 */
private void init(final Types typeUtil){
  if (!returnType.getKind().isPrimitive() && returnType.getKind() != TypeKind.VOID) {
    final Element element=typeUtil.asElement(returnType);
    final List<ExecutableElement> constructors=ElementFilter.constructorsIn(element.getEnclosedElements());
    for (    ExecutableElement constructor : constructors) {
      List<? extends VariableElement> params=constructor.getParameters();
switch (params.size()) {
case 1:
        if (ElementHelper.isAssignableFrom(params.get(0).asType(),String.class)) {
          stringConsturctor=true;
        }
 else         if (ElementHelper.isAssignableFrom(Throwable.class,params.get(0).asType())) {
          throwableConstructor=true;
        }
      break;
case 2:
    if (ElementHelper.isAssignableFrom(params.get(0).asType(),String.class) && ElementHelper.isAssignableFrom(Throwable.class,params.get(1).asType())) {
      stringAndThrowableConstructor=true;
    }
 else     if (ElementHelper.isAssignableFrom(Throwable.class,params.get(0).asType()) && ElementHelper.isAssignableFrom(params.get(1).asType(),String.class)) {
      throwableAndStringConstructor=true;
    }
  break;
}
}
}
}
Program: 44567
Project: 44567
Buggy source:
/** 
 * Creates a new descriptor.
 * @param returnTypeName the name of the return type.
 * @param primitive      {@code true} if the return type is a primitive, otherwise  {@code false}.
 * @throws ClassNotFoundException if the return type is not found in the classpath.
 */
private ReturnType(final String returnTypeName,final boolean primitive) throws ClassNotFoundException {
  this.returnTypeClassName=returnTypeName;
  this.primitive=primitive;
  if (primitive) {
    returnType=null;
  }
 else {
    returnType=Class.forName(returnTypeClassName);
  }
}

Fixed version (ground truth):
/** 
 * Creates a new descriptor that is not primitive.
 * @param returnTypeClassName the class name of the return type.
 */
private ReturnType(final TypeMirror returnType){
  this.returnType=returnType;
}
Program: 44568
Project: 44568
Buggy source:
@Override public int hashCode(){
  final int prime=31;
  int result=1;
  result=prime * result + ((returnType == null) ? 0 : returnType.hashCode());
  result=prime * result + ((stringConsturctor) ? 1 : 0);
  result=prime * result + ((throwableConstructor) ? 1 : 0);
  result=prime * result + ((stringAndThrowableConstructor) ? 1 : 0);
  result=prime * result + ((throwableAndStringConstructor) ? 1 : 0);
  return result;
}

Fixed version (ground truth):
@Override public int hashCode(){
  final int prime=31;
  int result=1;
  result=prime * result + ((returnType == null) ? 0 : returnType.hashCode());
  return result;
}
Program: 44569
Project: 44569
Buggy source:
/** 
 * Creates a new descriptor.
 * @param returnTypeName the name of the return type.
 * @param primitive      {@code true} if the return type is a primitive, otherwise  {@code false}.
 * @throws ClassNotFoundException if the return type is not found in the classpath.
 */
protected static ReturnType of(final String returnTypeName,final boolean primitive) throws ClassNotFoundException {
  final ReturnType result=new ReturnType(returnTypeName,primitive);
  result.init();
  return result;
}

Fixed version (ground truth):
/** 
 * Creates a new descriptor that is not primitive.
 * @param returnTypeClassName the class name of the return type.
 */
protected static ReturnType of(final TypeMirror returnType,final Types typeUtil){
  final ReturnType result=new ReturnType(returnType);
  result.init(typeUtil);
  return result;
}
Program: 44570
Project: 44570
Buggy source:
@Override public boolean equals(final Object obj){
  if (obj == this) {
    return true;
  }
  if (!(obj instanceof ReturnType)) {
    return false;
  }
  final ReturnType other=(ReturnType)obj;
  if ((this.returnType == null) ? other.returnType != null : this.returnType.equals(other.returnType)) {
    return false;
  }
  return (this.stringConsturctor == other.stringConsturctor) && (this.throwableConstructor == other.throwableConstructor) && (this.stringAndThrowableConstructor == other.stringAndThrowableConstructor)&& (this.throwableAndStringConstructor == other.throwableAndStringConstructor);
}

Fixed version (ground truth):
@Override public boolean equals(final Object obj){
  if (obj == this) {
    return true;
  }
  if (!(obj instanceof ReturnType)) {
    return false;
  }
  final ReturnType other=(ReturnType)obj;
  if ((this.returnType == null) ? other.returnType != null : this.returnType.equals(other.returnType)) {
    return false;
  }
  return true;
}
Program: 44571
Project: 44571
Buggy source:
/** 
 * Returns a string version of the return type.
 * @return a string version of the return type.
 */
public String getReturnTypeAsString(){
  return returnTypeClassName;
}

Fixed version (ground truth):
/** 
 * Returns a string version of the return type.
 * @return a string version of the return type.
 */
public String getReturnTypeAsString(){
  return returnType.toString();
}
Program: 44572
Project: 44572
Buggy source:
/** 
 * Indicates whether or not the return type is a primitive.
 * @return {@code true} if a primitive, otherwise {@code false}.
 */
public boolean isPrimitive(){
  return primitive;
}

Fixed version (ground truth):
/** 
 * Indicates whether or not the return type is a primitive.
 * @return {@code true} if a primitive, otherwise {@code false}.
 */
public boolean isPrimitive(){
  return returnType.getKind().isPrimitive();
}
Program: 44574
Project: 44574
Buggy source:
private void initCause(final JVar result,final JClass returnField,final JBlock body,final MethodDescriptor methodDesc,final JInvocation formatterMethod){
  ReturnType desc=methodDesc.returnTypeDescriptor();
  if (desc.hasStringAndThrowableConstructor() && methodDesc.hasCause()) {
    result.init(JExpr._new(returnField).arg(formatterMethod).arg(JExpr.ref(methodDesc.cause().name())));
  }
 else   if (desc.hasThrowableAndStringConstructor() && methodDesc.hasCause()) {
    result.init(JExpr._new(returnField).arg(JExpr.ref(methodDesc.cause().name())).arg(formatterMethod));
  }
 else   if (desc.hasStringConsturctor()) {
    result.init(JExpr._new(returnField).arg(formatterMethod));
    if (methodDesc.hasCause()) {
      JInvocation resultInv=body.invoke(result,"String_Node_Str");
      resultInv.arg(JExpr.ref(methodDesc.cause().name()));
    }
  }
 else   if (desc.hasThrowableConstructor() && methodDesc.hasCause()) {
    result.init(JExpr._new(returnField).arg(methodDesc.cause().name()));
  }
 else   if (methodDesc.hasCause()) {
    result.init(JExpr._new(returnField));
    JInvocation resultInv=body.invoke(result,"String_Node_Str");
    resultInv.arg(JExpr.ref(methodDesc.cause().name()));
  }
 else {
    result.init(JExpr._new(returnField));
  }
}

Fixed version (ground truth):
private void initCause(final JVar result,final JClass returnField,final JBlock body,final MethodDescriptor methodDesc,final JInvocation formatterMethod){
  ReturnType desc=methodDesc.returnType();
  if (desc.hasStringAndThrowableConstructor() && methodDesc.hasCause()) {
    result.init(JExpr._new(returnField).arg(formatterMethod).arg(JExpr.ref(methodDesc.cause().name())));
  }
 else   if (desc.hasThrowableAndStringConstructor() && methodDesc.hasCause()) {
    result.init(JExpr._new(returnField).arg(JExpr.ref(methodDesc.cause().name())).arg(formatterMethod));
  }
 else   if (desc.hasStringConsturctor()) {
    result.init(JExpr._new(returnField).arg(formatterMethod));
    if (methodDesc.hasCause()) {
      JInvocation resultInv=body.invoke(result,"String_Node_Str");
      resultInv.arg(JExpr.ref(methodDesc.cause().name()));
    }
  }
 else   if (desc.hasThrowableConstructor() && methodDesc.hasCause()) {
    result.init(JExpr._new(returnField).arg(methodDesc.cause().name()));
  }
 else   if (methodDesc.hasCause()) {
    result.init(JExpr._new(returnField));
    JInvocation resultInv=body.invoke(result,"String_Node_Str");
    resultInv.arg(JExpr.ref(methodDesc.cause().name()));
  }
 else {
    result.init(JExpr._new(returnField));
  }
}
Program: 44578
Project: 44578
Buggy source:
private void log(final Kind kind,final Element element,final Exception exception,final String messageFormat,final Object... args){
  String stringCause=TransformationHelper.stackTraceToString(exception);
  if (messageFormat == null) {
    log(kind,element,stringCause);
  }
 else {
    String messageWithCause=messageFormat.concat("String_Node_Str");
    log(kind,element,messageWithCause,args,stringCause);
  }
}

Fixed version (ground truth):
private void log(final Kind kind,final Element element,final Exception exception,final String messageFormat,final Object... args){
  String stringCause=TransformationHelper.stackTraceToString(exception);
  if (messageFormat == null) {
    log(kind,element,stringCause);
  }
 else {
    String messageWithCause=messageFormat.concat("String_Node_Str");
    List<Object> newArgs=new ArrayList<Object>();
    newArgs.addAll(Arrays.asList(args));
    newArgs.add(stringCause);
    log(kind,element,messageWithCause,newArgs.toArray());
  }
}
Program: 44579
Project: 44579
Buggy source:
private void log(final Kind kind,final Element element,final Exception exception,final String messageFormat,final Object... args){
  String stringCause=TransformationHelper.stackTraceToString(exception);
  if (messageFormat == null) {
    log(kind,element,stringCause);
  }
 else {
    String messageWithCause=messageFormat.concat("String_Node_Str");
    log(kind,element,messageFormat,args,stringCause);
  }
}

Fixed version (ground truth):
private void log(final Kind kind,final Element element,final Exception exception,final String messageFormat,final Object... args){
  String stringCause=TransformationHelper.stackTraceToString(exception);
  if (messageFormat == null) {
    log(kind,element,stringCause);
  }
 else {
    String messageWithCause=messageFormat.concat("String_Node_Str");
    log(kind,element,messageWithCause,args,stringCause);
  }
}
Program: 44580
Project: 44580
Buggy source:
/** 
 * Check if an element is annotated with the given annotation.
 * @param clazz the annotation class
 * @return true if the element is annotated, false otherwise
 * @throws NullPointerException if element parameter is null
 */
public static boolean isAnnotatedWith(final Element element,final Class<? extends Annotation> clazz){
  if (element == null) {
    throw new NullPointerException("String_Node_Str");
  }
  Annotation annotation=element.getAnnotation(clazz);
  if (clazz != null) {
    return true;
  }
  return false;
}

Fixed version (ground truth):
/** 
 * Check if an element is annotated with the given annotation.
 * @param clazz the annotation class
 * @return true if the element is annotated, false otherwise
 * @throws NullPointerException if element parameter is null
 */
public static boolean isAnnotatedWith(final Element element,final Class<? extends Annotation> clazz){
  if (element == null) {
    throw new NullPointerException("String_Node_Str");
  }
  Annotation annotation=element.getAnnotation(clazz);
  if (annotation != null) {
    return true;
  }
  return false;
}
Program: 44581
Project: 44581
Buggy source:
/** 
 * {@inheritDoc}
 */
@Override public void validate() throws ValidationException {
  for (  ExecutableElement method : methods) {
    boolean invalid=false;
    try {
      if (Throwable.class.isAssignableFrom(Class.forName(method.getReturnType().toString()))) {
        invalid=true;
      }
      if (Class.forName(method.getReturnType().toString()).isAssignableFrom(String.class)) {
        invalid=true;
      }
    }
 catch (    ClassNotFoundException e) {
      throw new ValidationException("String_Node_Str",e,method);
    }
    if (invalid) {
      throw new ValidationException("String_Node_Str",method);
    }
  }
}

Fixed version (ground truth):
/** 
 * {@inheritDoc}
 */
@Override public void validate() throws ValidationException {
  for (  ExecutableElement method : methods) {
    boolean invalid=true;
    try {
      if (Throwable.class.isAssignableFrom(Class.forName(method.getReturnType().toString()))) {
        invalid=false;
      }
      if (Class.forName(method.getReturnType().toString()).isAssignableFrom(String.class)) {
        invalid=false;
      }
    }
 catch (    ClassNotFoundException e) {
      throw new ValidationException("String_Node_Str",e,method);
    }
    if (invalid) {
      throw new ValidationException("String_Node_Str",method);
    }
  }
}
Program: 44582
Project: 44582
Buggy source:
/** 
 * Adds a method to return the message value. The method name should be the method name annotated   {@code org.jboss.logging.Message}. This method will be appended with   {@code $str}. <p/> <p> If the message method has already been defined the previously created method is returned. </p> <p/> <p> Note this method invokes the  {@code addMessageVar(varName,messageValue,id)} to add the variable.</p>
 * @param methodName  the method name.
 * @param returnValue the message value.
 * @param id          the id to prepend the project code/message with.
 * @return the newly created method.
 */
protected JMethod addMessageMethod(final String methodName,final String returnValue,final int id){
  final String internalMethodName=methodName + "String_Node_Str";
  JMethod method=definedClass().getMethod(internalMethodName,EMPTY_TYPE_ARRAY);
  if (method == null) {
    final JClass returnType=codeModel().ref(String.class);
    method=definedClass().method(JMod.PROTECTED,returnType,internalMethodName);
    final JBlock body=method.body();
    if (id > 0) {
      final JVar idVar=definedClass.field(JMod.PRIVATE | JMod.STATIC | JMod.FINAL,String.class,methodName + "String_Node_Str");
      idVar.init(JExpr.lit(ClassModelUtil.formatMessageId(projectCode,id)));
      body._return(idVar.plus(addMessageVar(methodName,returnValue)));
    }
 else {
      body._return(addMessageVar(methodName,returnValue));
    }
  }
  return method;
}

Fixed version (ground truth):
/** 
 * Adds a method to return the message value. The method name should be the method name annotated   {@code org.jboss.logging.Message}. This method will be appended with   {@code $str}. <p/> <p> If the message method has already been defined the previously created method is returned. </p> <p/> <p> Note this method invokes the  {@code addMessageVar(varName,messageValue,id)} to add the variable.</p>
 * @param methodName  the method name.
 * @param returnValue the message value.
 * @return the newly created method.
 */
protected JMethod addMessageMethod(final String methodName,final String returnValue){
  final String internalMethodName=methodName + "String_Node_Str";
  JMethod method=definedClass().getMethod(internalMethodName,EMPTY_TYPE_ARRAY);
  if (method == null) {
    final JClass returnType=codeModel().ref(String.class);
    method=definedClass().method(JMod.PROTECTED,returnType,internalMethodName);
    final JBlock body=method.body();
    body._return(addMessageVar(methodName,returnValue));
  }
  return method;
}
Program: 44584
Project: 44584
Buggy source:
/** 
 * {@inheritDoc}
 */
@Override public void addMethod(final ExecutableElement method){
  methodDescriptor=methodDescriptor.add(method);
  addValidator(new MethodParameterValidator(methodDescriptor));
  addValidator(new BundleReturnTypeValidator(methodDescriptor));
}

Fixed version (ground truth):
/** 
 * {@inheritDoc}
 */
@Override public void addMethod(final ExecutableElement method){
  methodDescriptor=methodDescriptor.add(method);
  addValidator(new MethodParameterValidator(methodDescriptor));
  addValidator(new BundleReturnTypeValidator(methodDescriptor));
  addValidator(new MessageIdValidator(methodDescriptor));
}
Program: 44585
Project: 44585
Buggy source:
/** 
 * {@inheritDoc}
 */
@Override public JCodeModel generateModel() throws IllegalStateException {
  JCodeModel model=super.generateModel();
  JDefinedClass definedClass=definedClass();
  JMethod constructor=definedClass.constructor(JMod.PROTECTED);
  constructor.body().invoke("String_Node_Str");
  JMethod readResolve=ClassModelUtil.createReadResolveMethod(definedClass);
  readResolve.annotate(Override.class);
  Set<Map.Entry<String,String>> entries=this.translations.entrySet();
  for (  Map.Entry<String,String> entry : entries) {
    String key=entry.getKey();
    String value=entry.getValue();
    JMethod method=addMessageMethod(key,value,-1);
    method.annotate(Override.class);
  }
  return model;
}

Fixed version (ground truth):
/** 
 * {@inheritDoc}
 */
@Override public JCodeModel generateModel() throws IllegalStateException {
  JCodeModel model=super.generateModel();
  JDefinedClass definedClass=definedClass();
  JMethod constructor=definedClass.constructor(JMod.PROTECTED);
  constructor.body().invoke("String_Node_Str");
  JMethod readResolve=ClassModelUtil.createReadResolveMethod(definedClass);
  readResolve.annotate(Override.class);
  Set<Map.Entry<String,String>> entries=this.translations.entrySet();
  for (  Map.Entry<String,String> entry : entries) {
    String key=entry.getKey();
    String value=entry.getValue();
    JMethod method=addMessageMethod(key,value);
    method.annotate(Override.class);
  }
  return model;
}
Program: 44587
Project: 44587
Buggy source:
/** 
 * {@inheritDoc}
 */
@Override public void addMethod(final ExecutableElement method){
  methodDescriptor=methodDescriptor.add(method);
  addValidator(new MethodParameterValidator(methodDescriptor));
  addValidator(new LoggerReturnTypeValidator(methodDescriptor));
}

Fixed version (ground truth):
/** 
 * {@inheritDoc}
 */
@Override public void addMethod(final ExecutableElement method){
  methodDescriptor=methodDescriptor.add(method);
  addValidator(new MethodParameterValidator(methodDescriptor));
  addValidator(new LoggerReturnTypeValidator(methodDescriptor));
  addValidator(new MessageIdValidator(methodDescriptor));
}