nus-yam/ex-repair huggingface dataset:
Program: 9214
Project: 9214
Buggy source:
public void abstractMethodMustBeImplemented(SourceTypeBinding type,MethodBinding abstractMethod){
  if (isPointcutDeclaration(abstractMethod))   return;
  if (isIntertypeDeclaration(abstractMethod))   return;
  if (CharOperation.prefixEquals("String_Node_Str".toCharArray(),abstractMethod.selector)) {
    return;
  }
  ResolvedType onTypeX=null;
  if (!type.isAnonymousType()) {
    onTypeX=factory.fromEclipse(type);
  }
 else {
    onTypeX=factory.fromEclipse(type.superclass());
  }
  for (Iterator i=onTypeX.getInterTypeMungersIncludingSupers().iterator(); i.hasNext(); ) {
    ConcreteTypeMunger m=(ConcreteTypeMunger)i.next();
    ResolvedMember sig=m.getSignature();
    if (!Modifier.isAbstract(sig.getModifiers())) {
      if (ResolvedType.matches(AjcMemberMaker.interMethod(sig,m.getAspectType(),sig.getDeclaringType().resolve(factory.getWorld()).isInterface()),factory.makeResolvedMember(abstractMethod))) {
        return;
      }
    }
  }
  super.abstractMethodMustBeImplemented(type,abstractMethod);
}

Fixed version (ground truth):
public void abstractMethodMustBeImplemented(SourceTypeBinding type,MethodBinding abstractMethod){
  if (isPointcutDeclaration(abstractMethod))   return;
  if (isIntertypeDeclaration(abstractMethod))   return;
  if (CharOperation.prefixEquals("String_Node_Str".toCharArray(),abstractMethod.selector)) {
    return;
  }
  ResolvedType onTypeX=null;
  if (!type.isAnonymousType()) {
    onTypeX=factory.fromEclipse(type);
  }
 else {
    onTypeX=factory.fromEclipse(type.superclass());
  }
  if (onTypeX.isRawType())   onTypeX=onTypeX.getGenericType();
  for (Iterator i=onTypeX.getInterTypeMungersIncludingSupers().iterator(); i.hasNext(); ) {
    ConcreteTypeMunger m=(ConcreteTypeMunger)i.next();
    ResolvedMember sig=m.getSignature();
    if (!Modifier.isAbstract(sig.getModifiers())) {
      ResolvedMember abstractMember=factory.makeResolvedMember(abstractMethod);
      if (abstractMember.getName().startsWith("String_Node_Str")) {
        if (ResolvedType.matches(AjcMemberMaker.interMethod(sig,m.getAspectType(),sig.getDeclaringType().resolve(factory.getWorld()).isInterface()),abstractMember)) {
          return;
        }
      }
 else {
        if (ResolvedType.matches(sig,factory.makeResolvedMember(abstractMethod)))         return;
      }
    }
  }
  super.abstractMethodMustBeImplemented(type,abstractMethod);
}
Program: 9215
Project: 9215
Buggy source:
/** 
 * Weave
 * @param className
 * @param bytes
 * @param loader
 * @return weaved bytes
 */
public byte[] preProcess(String className,byte[] bytes,ClassLoader loader){
  if (loader == null || className == null) {
    return bytes;
  }
  if (trace.isTraceEnabled())   trace.enter("String_Node_Str",this,new Object[]{className,bytes,loader});
  if (trace.isTraceEnabled())   trace.event("String_Node_Str",this,new Object[]{loader.getParent(),Thread.currentThread().getContextClassLoader()});
  try {
synchronized (loader) {
      WeavingAdaptor weavingAdaptor=WeaverContainer.getWeaver(loader,weavingContext);
      if (weavingAdaptor == null) {
        if (trace.isTraceEnabled())         trace.exit("String_Node_Str");
        return bytes;
      }
      byte[] newBytes=weavingAdaptor.weaveClass(className,bytes);
      Dump.dumpOnExit(weavingAdaptor.getMessageHolder(),true);
      if (trace.isTraceEnabled())       trace.exit("String_Node_Str",newBytes);
      return newBytes;
    }
  }
 catch (  Throwable th) {
    trace.error(className,th);
    Dump.dumpWithException(th);
    if (trace.isTraceEnabled())     trace.exit("String_Node_Str",th);
    return bytes;
  }
}

Fixed version (ground truth):
/** 
 * Weave
 * @param className
 * @param bytes
 * @param loader
 * @return weaved bytes
 */
public byte[] preProcess(String className,byte[] bytes,ClassLoader loader){
  if (loader == null || className == null) {
    return bytes;
  }
  if (trace.isTraceEnabled())   trace.enter("String_Node_Str",this,new Object[]{className,bytes,loader});
  if (trace.isTraceEnabled())   trace.event("String_Node_Str",this,new Object[]{loader.getParent(),Thread.currentThread().getContextClassLoader()});
  try {
synchronized (loader) {
      WeavingAdaptor weavingAdaptor=WeaverContainer.getWeaver(loader,weavingContext);
      if (weavingAdaptor == null) {
        if (trace.isTraceEnabled())         trace.exit("String_Node_Str");
        return bytes;
      }
      byte[] newBytes=weavingAdaptor.weaveClass(className,bytes,false);
      Dump.dumpOnExit(weavingAdaptor.getMessageHolder(),true);
      if (trace.isTraceEnabled())       trace.exit("String_Node_Str",newBytes);
      return newBytes;
    }
  }
 catch (  Throwable th) {
    trace.error(className,th);
    Dump.dumpWithException(th);
    if (trace.isTraceEnabled())     trace.exit("String_Node_Str",th);
    return bytes;
  }
}
Program: 9216
Project: 9216
Buggy source:
private boolean weaveAndDefineConceteAspects(){
  if (trace.isTraceEnabled())   trace.enter("String_Node_Str",this,concreteAspects);
  boolean success=true;
  for (Iterator iterator=concreteAspects.iterator(); iterator.hasNext(); ) {
    ConcreteAspectCodeGen gen=(ConcreteAspectCodeGen)iterator.next();
    String name=gen.getClassName();
    byte[] bytes=gen.getBytes();
    try {
      byte[] newBytes=weaveClass(name,bytes);
      this.generatedClassHandler.acceptClass(name,newBytes);
    }
 catch (    IOException ex) {
      trace.error("String_Node_Str",ex);
      error("String_Node_Str" + name + "String_Node_Str",ex);
    }
  }
  if (trace.isTraceEnabled())   trace.exit("String_Node_Str",success);
  return success;
}

Fixed version (ground truth):
private boolean weaveAndDefineConceteAspects(){
  if (trace.isTraceEnabled())   trace.enter("String_Node_Str",this,concreteAspects);
  boolean success=true;
  for (Iterator iterator=concreteAspects.iterator(); iterator.hasNext(); ) {
    ConcreteAspectCodeGen gen=(ConcreteAspectCodeGen)iterator.next();
    String name=gen.getClassName();
    byte[] bytes=gen.getBytes();
    try {
      byte[] newBytes=weaveClass(name,bytes,true);
      this.generatedClassHandler.acceptClass(name,newBytes);
    }
 catch (    IOException ex) {
      trace.error("String_Node_Str",ex);
      error("String_Node_Str" + name + "String_Node_Str",ex);
    }
  }
  if (trace.isTraceEnabled())   trace.exit("String_Node_Str",success);
  return success;
}
Program: 9217
Project: 9217
Buggy source:
/** 
 * Override to weave class using WeavingAdaptor 
 */
protected Class defineClass(String name,byte[] b,CodeSource cs) throws IOException {
  if (trace.isTraceEnabled())   trace.enter("String_Node_Str",this,new Object[]{name,b,cs});
  if (!initializingAdaptor) {
    if (adaptor == null && !initializingAdaptor) {
      createAdaptor();
    }
    try {
      b=adaptor.weaveClass(name,b);
    }
 catch (    AbortException ex) {
      trace.error("String_Node_Str",ex);
      throw ex;
    }
catch (    Throwable th) {
      trace.error("String_Node_Str",th);
    }
  }
  Class clazz=super.defineClass(name,b,cs);
  if (trace.isTraceEnabled())   trace.exit("String_Node_Str",clazz);
  return clazz;
}

Fixed version (ground truth):
/** 
 * Override to weave class using WeavingAdaptor 
 */
protected Class defineClass(String name,byte[] b,CodeSource cs) throws IOException {
  if (trace.isTraceEnabled())   trace.enter("String_Node_Str",this,new Object[]{name,b,cs});
  if (!initializingAdaptor) {
    if (adaptor == null && !initializingAdaptor) {
      createAdaptor();
    }
    try {
      b=adaptor.weaveClass(name,b,false);
    }
 catch (    AbortException ex) {
      trace.error("String_Node_Str",ex);
      throw ex;
    }
catch (    Throwable th) {
      trace.error("String_Node_Str",th);
    }
  }
  Class clazz=super.defineClass(name,b,cs);
  if (trace.isTraceEnabled())   trace.exit("String_Node_Str",clazz);
  return clazz;
}
Program: 9218
Project: 9218
Buggy source:
/** 
 * Weave a class using aspects previously supplied to the adaptor.
 * @param name the name of the class
 * @param bytes the class bytes
 * @return the woven bytes
 * @exception IOException weave failed
 */
public byte[] weaveClass(String name,byte[] bytes) throws IOException {
  if (trace.isTraceEnabled())   trace.enter("String_Node_Str",this,new Object[]{name,bytes});
  if (!enabled) {
    if (trace.isTraceEnabled())     trace.exit("String_Node_Str",false);
    return bytes;
  }
  try {
    delegateForCurrentClass=null;
    name=name.replace('/','.');
    if (couldWeave(name,bytes)) {
      if (accept(name,bytes)) {
        debug("String_Node_Str" + name + "String_Node_Str");
        bytes=getWovenBytes(name,bytes);
      }
 else       if (shouldWeaveAnnotationStyleAspect(name,bytes)) {
        debug("String_Node_Str" + name + "String_Node_Str");
        bytes=getAtAspectJAspectBytes(name,bytes);
      }
 else {
        debug("String_Node_Str" + name + "String_Node_Str");
      }
    }
 else {
      debug("String_Node_Str" + name + "String_Node_Str");
    }
  }
  finally {
    delegateForCurrentClass=null;
  }
  if (trace.isTraceEnabled())   trace.exit("String_Node_Str",bytes);
  return bytes;
}

Fixed version (ground truth):
/** 
 * Weave a class using aspects previously supplied to the adaptor.
 * @param name the name of the class
 * @param bytes the class bytes
 * @param mustWeave if true then this class *must* get woven (used for concrete aspects generated from XML)
 * @return the woven bytes
 * @exception IOException weave failed
 */
public byte[] weaveClass(String name,byte[] bytes,boolean mustWeave) throws IOException {
  if (trace.isTraceEnabled())   trace.enter("String_Node_Str",this,new Object[]{name,bytes});
  if (!enabled) {
    if (trace.isTraceEnabled())     trace.exit("String_Node_Str",false);
    return bytes;
  }
  try {
    delegateForCurrentClass=null;
    name=name.replace('/','.');
    if (couldWeave(name,bytes)) {
      if (accept(name,bytes)) {
        debug("String_Node_Str" + name + "String_Node_Str");
        bytes=getWovenBytes(name,bytes);
      }
 else       if (shouldWeaveAnnotationStyleAspect(name,bytes)) {
        if (mustWeave) {
          error("String_Node_Str" + name + "String_Node_Str");
        }
        debug("String_Node_Str" + name + "String_Node_Str");
        bytes=getAtAspectJAspectBytes(name,bytes);
      }
 else {
        debug("String_Node_Str" + name + "String_Node_Str");
      }
    }
 else {
      debug("String_Node_Str" + name + "String_Node_Str");
    }
  }
  finally {
    delegateForCurrentClass=null;
  }
  if (trace.isTraceEnabled())   trace.exit("String_Node_Str",bytes);
  return bytes;
}
Program: 9219
Project: 9219
Buggy source:
static final BranchHandle getBranchHandle(BranchInstruction i){
  if (bh_list == null)   return new BranchHandle(i);
 else {
    BranchHandle bh=bh_list;
    bh_list=(BranchHandle)bh.next;
    bh.setInstruction(i);
    return bh;
  }
}

Fixed version (ground truth):
/** 
 * Factory methods.
 */
static final BranchHandle getBranchHandle(BranchInstruction i){
  return new BranchHandle(i);
}
Program: 9220
Project: 9220
Buggy source:
/** 
 * Factory method.
 */
static final InstructionHandle getInstructionHandle(Instruction i){
  if (ih_list == null)   return new InstructionHandle(i);
 else {
    InstructionHandle ih=ih_list;
    ih_list=ih.next;
    ih.setInstruction(i);
    return ih;
  }
}

Fixed version (ground truth):
/** 
 * Factory method.
 */
static final InstructionHandle getInstructionHandle(Instruction i){
  return new InstructionHandle(i);
}
Program: 9221
Project: 9221
Buggy source:
/** 
 * Delete contents, i.e., remove user access and make handle reusable.
 */
void dispose(){
  next=prev=null;
  instruction.dispose();
  instruction=null;
  i_position=-1;
  attributes=null;
  removeAllTargeters();
  addHandle();
}

Fixed version (ground truth):
/** 
 * Delete contents, i.e., remove user access and make handle reusable.
 */
void dispose(){
  next=prev=null;
  instruction.dispose();
  instruction=null;
  i_position=-1;
  attributes=null;
  removeAllTargeters();
}
Program: 9222
Project: 9222
Buggy source:
public String[] getParameterNames(){
  if (argumentNames != null)   return argumentNames;
  TypeDeclaration typeDecl=getTypeDeclaration();
  AbstractMethodDeclaration methodDecl=typeDecl.declarationOf((MethodBinding)realBinding);
  Argument[] args=(methodDecl == null ? null : methodDecl.arguments);
  if (args == null) {
    argumentNames=NO_ARGS;
  }
 else {
    argumentNames=new String[args.length];
    for (int i=0; i < argumentNames.length; i++) {
      argumentNames[i]=new String(methodDecl.arguments[i].name);
    }
  }
  return argumentNames;
}

Fixed version (ground truth):
public String[] getParameterNames(){
  if (argumentNames != null)   return argumentNames;
  if (realBinding instanceof FieldBinding) {
    argumentNames=NO_ARGS;
  }
 else {
    TypeDeclaration typeDecl=getTypeDeclaration();
    AbstractMethodDeclaration methodDecl=typeDecl.declarationOf((MethodBinding)realBinding);
    Argument[] args=(methodDecl == null ? null : methodDecl.arguments);
    if (args == null) {
      argumentNames=NO_ARGS;
    }
 else {
      argumentNames=new String[args.length];
      for (int i=0; i < argumentNames.length; i++) {
        argumentNames[i]=new String(methodDecl.arguments[i].name);
      }
    }
  }
  return argumentNames;
}
Program: 9223
Project: 9223
Buggy source:
public boolean isNested(){
  return ((declaration.modifiers & ASTNode.IsMemberTypeMASK) != 0);
}

Fixed version (ground truth):
public boolean isNested(){
  if (declaration.binding != null)   return (declaration.binding.isMemberType());
  return ((declaration.modifiers & ASTNode.IsMemberTypeMASK) != 0);
}
Program: 9224
Project: 9224
Buggy source:
public Aj(IWeavingContext context){
  if (trace.isTraceEnabled())   trace.enter("String_Node_Str",this,new Object[]{context});
  this.weavingContext=context;
  if (trace.isTraceEnabled())   trace.exit("String_Node_Str");
}

Fixed version (ground truth):
public Aj(IWeavingContext context){
  if (trace.isTraceEnabled())   trace.enter("String_Node_Str",this,new Object[]{context,getClass().getClassLoader()});
  this.weavingContext=context;
  if (trace.isTraceEnabled())   trace.exit("String_Node_Str");
}
Program: 9225
Project: 9225
Buggy source:
/** 
 * Weave
 * @param className
 * @param bytes
 * @param loader
 * @return weaved bytes
 */
public byte[] preProcess(String className,byte[] bytes,ClassLoader loader){
  if (trace.isTraceEnabled())   trace.enter("String_Node_Str",this,new Object[]{className,bytes,loader});
  if (loader == null || className == null) {
    if (trace.isTraceEnabled())     trace.exit("String_Node_Str",bytes);
    return bytes;
  }
  try {
synchronized (loader) {
      WeavingAdaptor weavingAdaptor=WeaverContainer.getWeaver(loader,weavingContext);
      if (weavingAdaptor == null) {
        if (trace.isTraceEnabled())         trace.exit("String_Node_Str");
        return bytes;
      }
      if (trace.isTraceEnabled())       trace.exit("String_Node_Str",bytes);
      return weavingAdaptor.weaveClass(className,bytes);
    }
  }
 catch (  Exception t) {
    trace.error("String_Node_Str",t);
    t.printStackTrace();
    if (trace.isTraceEnabled())     trace.exit("String_Node_Str",bytes);
    return bytes;
  }
}

Fixed version (ground truth):
/** 
 * Weave
 * @param className
 * @param bytes
 * @param loader
 * @return weaved bytes
 */
public byte[] preProcess(String className,byte[] bytes,ClassLoader loader){
  if (loader == null || className == null) {
    return bytes;
  }
  if (trace.isTraceEnabled())   trace.enter("String_Node_Str",this,new Object[]{className,bytes,loader,Thread.currentThread().getContextClassLoader()});
  try {
synchronized (loader) {
      WeavingAdaptor weavingAdaptor=WeaverContainer.getWeaver(loader,weavingContext);
      if (weavingAdaptor == null) {
        if (trace.isTraceEnabled())         trace.exit("String_Node_Str");
        return bytes;
      }
      byte[] newBytes=weavingAdaptor.weaveClass(className,bytes);
      if (trace.isTraceEnabled())       trace.exit("String_Node_Str",newBytes);
      return newBytes;
    }
  }
 catch (  Exception ex) {
    trace.error("String_Node_Str",ex);
    ex.printStackTrace();
    if (trace.isTraceEnabled())     trace.exit("String_Node_Str",ex);
    return bytes;
  }
}
Program: 9226
Project: 9226
Buggy source:
public CrosscuttingMembersSet(World world){
  this.world=world;
}

Fixed version (ground truth):
public CrosscuttingMembersSet(World world){
  trace.enter("String_Node_Str",this,world);
  this.world=world;
  trace.exit("String_Node_Str");
}
Program: 9227
Project: 9227
Buggy source:
/** 
 * @return whether or not that was a change to the global signatureXXX for efficiency we will need a richer representation than this
 */
public boolean addOrReplaceAspect(ResolvedType aspectType,boolean inWeavingPhase){
  boolean change=false;
  CrosscuttingMembers xcut=(CrosscuttingMembers)members.get(aspectType);
  if (xcut == null) {
    members.put(aspectType,aspectType.collectCrosscuttingMembers(inWeavingPhase));
    clearCaches();
    CflowPointcut.clearCaches(aspectType);
    change=true;
  }
 else {
    if (xcut.replaceWith(aspectType.collectCrosscuttingMembers(inWeavingPhase),inWeavingPhase)) {
      clearCaches();
      CflowPointcut.clearCaches(aspectType);
      change=true;
    }
 else {
      if (!AsmManager.getDefault().getHandleProvider().dependsOnLocation() && inWeavingPhase) {
        shadowMungers=null;
      }
      change=false;
    }
  }
  if (aspectType.isAbstract()) {
    boolean ancestorChange=addOrReplaceDescendantsOf(aspectType,inWeavingPhase);
    change=change || ancestorChange;
  }
  changedSinceLastReset=changedSinceLastReset || change;
  return change;
}

Fixed version (ground truth):
/** 
 * @return whether or not that was a change to the global signatureXXX for efficiency we will need a richer representation than this
 */
public boolean addOrReplaceAspect(ResolvedType aspectType,boolean inWeavingPhase){
  trace.enter("String_Node_Str",this,new Object[]{aspectType,new Boolean(inWeavingPhase)});
  boolean change=false;
  CrosscuttingMembers xcut=(CrosscuttingMembers)members.get(aspectType);
  if (xcut == null) {
    members.put(aspectType,aspectType.collectCrosscuttingMembers(inWeavingPhase));
    clearCaches();
    CflowPointcut.clearCaches(aspectType);
    change=true;
  }
 else {
    if (xcut.replaceWith(aspectType.collectCrosscuttingMembers(inWeavingPhase),inWeavingPhase)) {
      clearCaches();
      CflowPointcut.clearCaches(aspectType);
      change=true;
    }
 else {
      if (!AsmManager.getDefault().getHandleProvider().dependsOnLocation() && inWeavingPhase) {
        shadowMungers=null;
      }
      change=false;
    }
  }
  if (aspectType.isAbstract()) {
    boolean ancestorChange=addOrReplaceDescendantsOf(aspectType,inWeavingPhase);
    change=change || ancestorChange;
  }
  changedSinceLastReset=changedSinceLastReset || change;
  trace.exit("String_Node_Str",change);
  return change;
}
Program: 9228
Project: 9228
Buggy source:
private void weaveAndNotify(UnwovenClassFile classFile,BcelObjectType classType,IWeaveRequestor requestor) throws IOException {
  ContextToken tok=CompilationAndWeavingContext.enteringPhase(CompilationAndWeavingContext.WEAVING_TYPE,classType.getResolvedTypeX().getName());
  LazyClassGen clazz=weaveWithoutDump(classFile,classType);
  classType.finishedWith();
  if (clazz != null) {
    UnwovenClassFile[] newClasses=getClassFilesFor(clazz);
    for (int i=0; i < newClasses.length; i++) {
      requestor.acceptResult(newClasses[i]);
    }
  }
 else {
    requestor.acceptResult(classFile);
  }
  classType.weavingCompleted();
  CompilationAndWeavingContext.leavingPhase(tok);
}

Fixed version (ground truth):
private void weaveAndNotify(UnwovenClassFile classFile,BcelObjectType classType,IWeaveRequestor requestor) throws IOException {
  trace.enter("String_Node_Str",this,new Object[]{classFile,classType,requestor});
  ContextToken tok=CompilationAndWeavingContext.enteringPhase(CompilationAndWeavingContext.WEAVING_TYPE,classType.getResolvedTypeX().getName());
  LazyClassGen clazz=weaveWithoutDump(classFile,classType);
  classType.finishedWith();
  if (clazz != null) {
    UnwovenClassFile[] newClasses=getClassFilesFor(clazz);
    for (int i=0; i < newClasses.length; i++) {
      requestor.acceptResult(newClasses[i]);
    }
  }
 else {
    requestor.acceptResult(classFile);
  }
  classType.weavingCompleted();
  CompilationAndWeavingContext.leavingPhase(tok);
  trace.exit("String_Node_Str");
}
Program: 9230
Project: 9230
Buggy source:
private boolean isAspect(TypeDeclaration declaration){
  if (declaration instanceof AspectDeclaration)   return true;
 else   if (declaration.annotations != null) {
    for (int index=0; index < declaration.annotations.length; index++) {
      TypeDeclaration.resolveAnnotations(declaration.staticInitializerScope,declaration.annotations,declaration.binding);
      Annotation a=declaration.annotations[index];
      if (CharOperation.equals(a.resolvedType.signature(),aspectSig))       return true;
    }
  }
  return false;
}

Fixed version (ground truth):
private boolean isAspect(TypeDeclaration declaration){
  if (declaration instanceof AspectDeclaration)   return true;
 else   if (declaration.annotations != null) {
    for (int index=0; index < declaration.annotations.length; index++) {
      TypeDeclaration.resolveAnnotations(declaration.staticInitializerScope,declaration.annotations,declaration.binding);
      Annotation a=declaration.annotations[index];
      if (a.resolvedType == null)       continue;
      if (CharOperation.equals(a.resolvedType.signature(),aspectSig))       return true;
    }
  }
  return false;
}
Program: 9231
Project: 9231
Buggy source:
public void testDeclareAtTypeInStructureModel_pr115607(){
  AsmManager.setReporting("String_Node_Str",true,true,true,true);
  runTest("String_Node_Str");
  IHierarchy top=AsmManager.getDefault().getHierarchy();
  IProgramElement pe=top.findElementForLabel(top.getRoot(),IProgramElement.Kind.DECLARE_ANNOTATION_AT_TYPE,"String_Node_Str");
  assertNotNull("String_Node_Str",pe);
  List l=AsmManager.getDefault().getRelationshipMap().get(pe);
  assertNotNull("String_Node_Str",l);
}

Fixed version (ground truth):
public void testDeclareAtTypeInStructureModel_pr115607(){
  runTest("String_Node_Str");
  IHierarchy top=AsmManager.getDefault().getHierarchy();
  IProgramElement pe=top.findElementForLabel(top.getRoot(),IProgramElement.Kind.DECLARE_ANNOTATION_AT_TYPE,"String_Node_Str");
  assertNotNull("String_Node_Str",pe);
  List l=AsmManager.getDefault().getRelationshipMap().get(pe);
  assertNotNull("String_Node_Str",l);
}
Program: 9232
Project: 9232
Buggy source:
public void removeUnnecessaryProblems(Member member,int problemLineNumber){
  if (result == null)   return;
  IProblem[] probs=result.getProblems();
  for (int i=0; i < probs.length; i++) {
    IProblem problem=probs[i];
    if (problem == null)     continue;
    if (problem.getID() == IProblem.UnusedMethodDeclaredThrownException || problem.getID() == IProblem.UnusedConstructorDeclaredThrownException) {
      if (problem.getSourceLineNumber() == problemLineNumber) {
        UnusedDeclaredThrownExceptionFilter filter=new UnusedDeclaredThrownExceptionFilter(problem);
        result.removeProblems(filter);
      }
    }
  }
}

Fixed version (ground truth):
public void removeUnnecessaryProblems(Member member,int problemLineNumber){
  if (result == null)   return;
  IProblem[] probs=result.getProblems();
  if (probs != null) {
    for (int i=0; i < probs.length; i++) {
      IProblem problem=probs[i];
      if (problem == null)       continue;
      if (problem.getID() == IProblem.UnusedMethodDeclaredThrownException || problem.getID() == IProblem.UnusedConstructorDeclaredThrownException) {
        if (problem.getSourceLineNumber() == problemLineNumber) {
          UnusedDeclaredThrownExceptionFilter filter=new UnusedDeclaredThrownExceptionFilter(problem);
          result.removeProblems(filter);
        }
      }
    }
  }
}
Program: 9233
Project: 9233
Buggy source:
private void createMessageHandler(){
  messageHolder=new WeavingAdaptorMessageHandler(new PrintWriter(System.err));
  messageHandler=messageHolder;
  if (verbose)   messageHandler.dontIgnore(IMessage.INFO);
  if (Boolean.getBoolean(SHOW_WEAVE_INFO_PROPERTY))   messageHandler.dontIgnore(IMessage.WEAVEINFO);
  info("String_Node_Str" + Version.text + "String_Node_Str"+ Version.time_text);
}

Fixed version (ground truth):
protected void createMessageHandler(){
  messageHolder=new WeavingAdaptorMessageHandler(new PrintWriter(System.err));
  messageHandler=messageHolder;
  if (verbose)   messageHandler.dontIgnore(IMessage.INFO);
  if (Boolean.getBoolean(SHOW_WEAVE_INFO_PROPERTY))   messageHandler.dontIgnore(IMessage.WEAVEINFO);
  info("String_Node_Str" + Version.text + "String_Node_Str"+ Version.time_text);
}
Program: 9234
Project: 9234
Buggy source:
static WeavingAdaptor getWeaver(ClassLoader loader,IWeavingContext weavingContext){
  ExplicitlyInitializedClassLoaderWeavingAdaptor adaptor=null;
synchronized (weavingAdaptors) {
    adaptor=(ExplicitlyInitializedClassLoaderWeavingAdaptor)weavingAdaptors.get(loader);
    if (adaptor == null) {
      String loaderClassName=loader.getClass().getName();
      if (loaderClassName.equals("String_Node_Str")) {
        return null;
      }
 else {
        ClassLoaderWeavingAdaptor weavingAdaptor=new ClassLoaderWeavingAdaptor(loader,weavingContext);
        adaptor=new ExplicitlyInitializedClassLoaderWeavingAdaptor(weavingAdaptor);
        weavingAdaptors.put(loader,adaptor);
      }
    }
  }
  return adaptor.getWeavingAdaptor(loader,weavingContext);
}

Fixed version (ground truth):
static WeavingAdaptor getWeaver(ClassLoader loader,IWeavingContext weavingContext){
  ExplicitlyInitializedClassLoaderWeavingAdaptor adaptor=null;
synchronized (weavingAdaptors) {
    adaptor=(ExplicitlyInitializedClassLoaderWeavingAdaptor)weavingAdaptors.get(loader);
    if (adaptor == null) {
      String loaderClassName=loader.getClass().getName();
      if (loaderClassName.equals("String_Node_Str")) {
        return null;
      }
 else {
        ClassLoaderWeavingAdaptor weavingAdaptor=new ClassLoaderWeavingAdaptor();
        adaptor=new ExplicitlyInitializedClassLoaderWeavingAdaptor(weavingAdaptor);
        weavingAdaptors.put(loader,adaptor);
      }
    }
  }
  return adaptor.getWeavingAdaptor(loader,weavingContext);
}
Program: 9235
Project: 9235
Buggy source:
public ClassLoaderWeavingAdaptor(final ClassLoader loader,IWeavingContext wContext){
  super();
  if (trace.isTraceEnabled())   trace.enter("String_Node_Str",this);
  this.classLoader=loader;
  this.weavingContext=wContext;
  if (trace.isTraceEnabled())   trace.exit("String_Node_Str");
}

Fixed version (ground truth):
/** 
 * We don't need a reference to the class loader and using it during  construction can cause problems with recursion. It also makes sense to supply the weaving context during initialization to. 
 * @deprecated
 */
public ClassLoaderWeavingAdaptor(final ClassLoader deprecatedLoader,final IWeavingContext deprecatedContext){
  super();
  if (trace.isTraceEnabled())   trace.enter("String_Node_Str",this,new Object[]{deprecatedLoader,deprecatedContext});
  if (trace.isTraceEnabled())   trace.exit("String_Node_Str");
}
Program: 9236
Project: 9236
Buggy source:
protected void initialize(final ClassLoader deprecatedLoader,IWeavingContext deprecatedContext){
  if (initialized)   return;
  if (weavingContext == null) {
    weavingContext=new DefaultWeavingContext(classLoader);
  }
  createMessageHandler();
  this.generatedClassHandler=new GeneratedClassHandler(){
    /** 
 * Callback when we need to define a Closure in the JVM
 * @param name
 * @param bytes
 */
    public void acceptClass(    String name,    byte[] bytes){
      try {
        if (shouldDump(name.replace('/','.'),false)) {
          dump(name,bytes,false);
        }
      }
 catch (      Throwable throwable) {
        throwable.printStackTrace();
      }
      defineClass(classLoader,name,bytes);
    }
  }
;
  List definitions=parseDefinitions(classLoader);
  if (!enabled) {
    return;
  }
  bcelWorld=new LTWWorld(classLoader,getMessageHandler(),new ICrossReferenceHandler(){
    public void addCrossReference(    ISourceLocation from,    ISourceLocation to,    IRelationship.Kind kind,    boolean runtimeTest){
      ;
    }
  }
);
  weaver=new BcelWeaver(bcelWorld);
  registerDefinitions(weaver,classLoader,definitions);
  if (enabled) {
    weaver.prepareForWeave();
  }
 else {
    bcelWorld=null;
    weaver=null;
  }
  initialized=true;
}

Fixed version (ground truth):
protected void initialize(final ClassLoader classLoader,IWeavingContext context){
  if (initialized)   return;
  if (trace.isTraceEnabled())   trace.enter("String_Node_Str",this,new Object[]{classLoader,context});
  this.weavingContext=context;
  if (weavingContext == null) {
    weavingContext=new DefaultWeavingContext(classLoader);
  }
  createMessageHandler();
  this.generatedClassHandler=new GeneratedClassHandler(){
    /** 
 * Callback when we need to define a Closure in the JVM
 * @param name
 * @param bytes
 */
    public void acceptClass(    String name,    byte[] bytes){
      try {
        if (shouldDump(name.replace('/','.'),false)) {
          dump(name,bytes,false);
        }
      }
 catch (      Throwable throwable) {
        throwable.printStackTrace();
      }
      defineClass(classLoader,name,bytes);
    }
  }
;
  List definitions=parseDefinitions(classLoader);
  if (!enabled) {
    if (trace.isTraceEnabled())     trace.exit("String_Node_Str",enabled);
    return;
  }
  bcelWorld=new LTWWorld(classLoader,getMessageHandler(),new ICrossReferenceHandler(){
    public void addCrossReference(    ISourceLocation from,    ISourceLocation to,    IRelationship.Kind kind,    boolean runtimeTest){
      ;
    }
  }
);
  weaver=new BcelWeaver(bcelWorld);
  registerDefinitions(weaver,classLoader,definitions);
  if (enabled) {
    weaver.prepareForWeave();
  }
 else {
    bcelWorld=null;
    weaver=null;
  }
  initialized=true;
  if (trace.isTraceEnabled())   trace.exit("String_Node_Str",enabled);
}
Program: 9237
Project: 9237
Buggy source:
/** 
 * Override to weave class using WeavingAdaptor 
 */
protected Class defineClass(String name,byte[] b,CodeSource cs) throws IOException {
  if (!initializingAdaptor) {
    if (adaptor == null && !initializingAdaptor) {
      DefaultWeavingContext weavingContext=new DefaultWeavingContext(this){
        public String getClassLoaderName(){
          return loader.getClass().getName();
        }
      }
;
      ClassLoaderWeavingAdaptor clwAdaptor=new ClassLoaderWeavingAdaptor(this,weavingContext);
      initializingAdaptor=true;
      clwAdaptor.initialize(this,weavingContext);
      initializingAdaptor=false;
      adaptor=clwAdaptor;
    }
    b=adaptor.weaveClass(name,b);
  }
  return super.defineClass(name,b,cs);
}

Fixed version (ground truth):
/** 
 * Override to weave class using WeavingAdaptor 
 */
protected Class defineClass(String name,byte[] b,CodeSource cs) throws IOException {
  if (!initializingAdaptor) {
    if (adaptor == null && !initializingAdaptor) {
      DefaultWeavingContext weavingContext=new DefaultWeavingContext(this){
        public String getClassLoaderName(){
          return loader.getClass().getName();
        }
      }
;
      ClassLoaderWeavingAdaptor clwAdaptor=new ClassLoaderWeavingAdaptor();
      initializingAdaptor=true;
      clwAdaptor.initialize(this,weavingContext);
      initializingAdaptor=false;
      adaptor=clwAdaptor;
    }
    b=adaptor.weaveClass(name,b);
  }
  return super.defineClass(name,b,cs);
}
Program: 9238
Project: 9238
Buggy source:
public void testGetNamespace(){
  ClassLoader loader=new URLClassLoader(new URL[]{},null);
  ClassLoaderWeavingAdaptor adaptor=new ClassLoaderWeavingAdaptor(loader,null);
  String namespace=adaptor.getNamespace();
  assertEquals("String_Node_Str","String_Node_Str",namespace);
}

Fixed version (ground truth):
public void testGetNamespace(){
  ClassLoader loader=new URLClassLoader(new URL[]{},null);
  ClassLoaderWeavingAdaptor adaptor=new ClassLoaderWeavingAdaptor();
  adaptor.initialize(loader,null);
  String namespace=adaptor.getNamespace();
  assertEquals("String_Node_Str","String_Node_Str",namespace);
}
Program: 9239
Project: 9239
Buggy source:
public void testGeneratedClassesExistFor(){
  ClassLoader loader=new URLClassLoader(new URL[]{},null);
  ClassLoaderWeavingAdaptor adaptor=new ClassLoaderWeavingAdaptor(loader,null);
  boolean exist=adaptor.generatedClassesExistFor("String_Node_Str");
  assertFalse("String_Node_Str",exist);
}

Fixed version (ground truth):
public void testGeneratedClassesExistFor(){
  ClassLoader loader=new URLClassLoader(new URL[]{},null);
  ClassLoaderWeavingAdaptor adaptor=new ClassLoaderWeavingAdaptor();
  adaptor.initialize(loader,null);
  boolean exist=adaptor.generatedClassesExistFor("String_Node_Str");
  assertFalse("String_Node_Str",exist);
}
Program: 9240
Project: 9240
Buggy source:
public void testFlushGeneratedClasses(){
  ClassLoader loader=new URLClassLoader(new URL[]{},null);
  ClassLoaderWeavingAdaptor adaptor=new ClassLoaderWeavingAdaptor(loader,null);
  adaptor.flushGeneratedClasses();
  boolean exist=adaptor.generatedClassesExistFor("String_Node_Str");
  assertFalse("String_Node_Str",exist);
}

Fixed version (ground truth):
public void testFlushGeneratedClasses(){
  ClassLoader loader=new URLClassLoader(new URL[]{},null);
  ClassLoaderWeavingAdaptor adaptor=new ClassLoaderWeavingAdaptor();
  adaptor.initialize(loader,null);
  adaptor.flushGeneratedClasses();
  boolean exist=adaptor.generatedClassesExistFor("String_Node_Str");
  assertFalse("String_Node_Str",exist);
}
Program: 9241
Project: 9241
Buggy source:
public void testClassLoaderWeavingAdaptor(){
  ClassLoader loader=new URLClassLoader(new URL[]{},null);
  ClassLoaderWeavingAdaptor adaptor=new ClassLoaderWeavingAdaptor(loader,null);
}

Fixed version (ground truth):
public void testClassLoaderWeavingAdaptor(){
  ClassLoader loader=new URLClassLoader(new URL[]{},null);
  ClassLoaderWeavingAdaptor adaptor=new ClassLoaderWeavingAdaptor();
  adaptor.initialize(loader,null);
}
Program: 9242
Project: 9242
Buggy source:
public void testGetBundleIdFromURL(){
  URLClassLoader loader=new URLClassLoader(new URL[]{},null);
  IWeavingContext context=new TestWeavingContext(loader){
    public String getBundleIdFromURL(    URL url){
      throw new UnsupportedOperationException();
    }
  }
;
  ClassLoaderWeavingAdaptor adaptor=new ClassLoaderWeavingAdaptor(loader,context);
  try {
    adaptor.initialize(null,null);
  }
 catch (  UnsupportedOperationException ex) {
    fail("String_Node_Str");
  }
}

Fixed version (ground truth):
public void testGetBundleIdFromURL(){
  URLClassLoader loader=new URLClassLoader(new URL[]{},null);
  IWeavingContext context=new TestWeavingContext(loader){
    public String getBundleIdFromURL(    URL url){
      throw new UnsupportedOperationException();
    }
  }
;
  ClassLoaderWeavingAdaptor adaptor=new ClassLoaderWeavingAdaptor();
  try {
    adaptor.initialize(loader,context);
  }
 catch (  UnsupportedOperationException ex) {
    fail("String_Node_Str");
  }
}
Program: 9243
Project: 9243
Buggy source:
public void testGetClassLoaderName(){
  URLClassLoader loader=new URLClassLoader(new URL[]{},null);
  IWeavingContext context=new TestWeavingContext(loader){
    public String getClassLoaderName(){
      called=true;
      return super.getClassLoaderName();
    }
  }
;
  ClassLoaderWeavingAdaptor adaptor=new ClassLoaderWeavingAdaptor(loader,context);
  adaptor.initialize(null,null);
  assertTrue("String_Node_Str",called);
}

Fixed version (ground truth):
public void testGetClassLoaderName(){
  URLClassLoader loader=new URLClassLoader(new URL[]{},null);
  IWeavingContext context=new TestWeavingContext(loader){
    public String getClassLoaderName(){
      called=true;
      return super.getClassLoaderName();
    }
  }
;
  ClassLoaderWeavingAdaptor adaptor=new ClassLoaderWeavingAdaptor();
  adaptor.initialize(loader,context);
  assertTrue("String_Node_Str",called);
}
Program: 9244
Project: 9244
Buggy source:
public void testWeavingContext(){
  URLClassLoader loader=new URLClassLoader(new URL[]{},null);
  IWeavingContext context=new TestWeavingContext(loader);
  ClassLoaderWeavingAdaptor adaptor=new ClassLoaderWeavingAdaptor(loader,context);
}

Fixed version (ground truth):
public void testWeavingContext(){
  URLClassLoader loader=new URLClassLoader(new URL[]{},null);
  IWeavingContext context=new TestWeavingContext(loader);
  ClassLoaderWeavingAdaptor adaptor=new ClassLoaderWeavingAdaptor();
  adaptor.initialize(loader,context);
}
Program: 9245
Project: 9245
Buggy source:
public void testGetResources(){
  URLClassLoader loader=new URLClassLoader(new URL[]{},null);
  IWeavingContext context=new TestWeavingContext(loader){
    public Enumeration getResources(    String name) throws IOException {
      called=true;
      return super.getResources(name);
    }
  }
;
  ClassLoaderWeavingAdaptor adaptor=new ClassLoaderWeavingAdaptor(loader,context);
  adaptor.initialize(null,null);
  assertTrue("String_Node_Str",called);
}

Fixed version (ground truth):
public void testGetResources(){
  URLClassLoader loader=new URLClassLoader(new URL[]{},null);
  IWeavingContext context=new TestWeavingContext(loader){
    public Enumeration getResources(    String name) throws IOException {
      called=true;
      return super.getResources(name);
    }
  }
;
  ClassLoaderWeavingAdaptor adaptor=new ClassLoaderWeavingAdaptor();
  adaptor.initialize(loader,context);
  assertTrue("String_Node_Str",called);
}
Program: 9246
Project: 9246
Buggy source:
public void testGetId() throws IOException {
  File file=new File("String_Node_Str");
  URL fileURL=file.getCanonicalFile().toURL();
  URLClassLoader loader=new URLClassLoader(new URL[]{fileURL},null);
  IWeavingContext context=new TestWeavingContext(loader){
    public String getId(){
      called=true;
      return super.getId();
    }
  }
;
  ClassLoaderWeavingAdaptor adaptor=new ClassLoaderWeavingAdaptor(loader,context);
  adaptor.initialize(null,null);
  assertTrue("String_Node_Str",called);
}

Fixed version (ground truth):
public void testGetId() throws IOException {
  File file=new File("String_Node_Str");
  URL fileURL=file.getCanonicalFile().toURL();
  URLClassLoader loader=new URLClassLoader(new URL[]{fileURL},null);
  IWeavingContext context=new TestWeavingContext(loader){
    public String getId(){
      called=true;
      return super.getId();
    }
  }
;
  ClassLoaderWeavingAdaptor adaptor=new ClassLoaderWeavingAdaptor();
  adaptor.initialize(loader,context);
  assertTrue("String_Node_Str",called);
}
Program: 9247
Project: 9247
Buggy source:
public void testGetFile() throws IOException {
  File file=new File("String_Node_Str");
  URL fileURL=file.getCanonicalFile().toURL();
  URLClassLoader loader=new URLClassLoader(new URL[]{fileURL},null);
  IWeavingContext context=new TestWeavingContext(loader){
    public String getFile(    URL url){
      called=true;
      return super.getFile(url);
    }
  }
;
  ClassLoaderWeavingAdaptor adaptor=new ClassLoaderWeavingAdaptor(loader,context);
  adaptor.initialize(null,null);
  assertTrue("String_Node_Str",called);
}

Fixed version (ground truth):
public void testGetFile() throws IOException {
  File file=new File("String_Node_Str");
  URL fileURL=file.getCanonicalFile().toURL();
  URLClassLoader loader=new URLClassLoader(new URL[]{fileURL},null);
  IWeavingContext context=new TestWeavingContext(loader){
    public String getFile(    URL url){
      called=true;
      return super.getFile(url);
    }
  }
;
  ClassLoaderWeavingAdaptor adaptor=new ClassLoaderWeavingAdaptor();
  adaptor.initialize(loader,context);
  assertTrue("String_Node_Str",called);
}
Program: 9249
Project: 9249
Buggy source:
public ClassLoaderWeavingAdaptor(final ClassLoader loader,IWeavingContext wContext){
  this.weavingContext=wContext;
}

Fixed version (ground truth):
public ClassLoaderWeavingAdaptor(final ClassLoader loader,IWeavingContext wContext){
  super();
  this.classLoader=loader;
  this.weavingContext=wContext;
}
Program: 9250
Project: 9250
Buggy source:
/** 
 * Callback when we need to define a Closure in the JVM
 * @param name
 * @param bytes
 */
public void acceptClass(String name,byte[] bytes){
  try {
    if (shouldDump(name.replace('/','.'),false)) {
      dump(name,bytes,false);
    }
  }
 catch (  Throwable throwable) {
    throwable.printStackTrace();
  }
  defineClass(loader,name,bytes);
}

Fixed version (ground truth):
/** 
 * Callback when we need to define a Closure in the JVM
 * @param name
 * @param bytes
 */
public void acceptClass(String name,byte[] bytes){
  try {
    if (shouldDump(name.replace('/','.'),false)) {
      dump(name,bytes,false);
    }
  }
 catch (  Throwable throwable) {
    throwable.printStackTrace();
  }
  defineClass(classLoader,name,bytes);
}
Program: 9251
Project: 9251
Buggy source:
protected void initialize(final ClassLoader loader,IWeavingContext wContext){
  this.generatedClassHandler=new GeneratedClassHandler(){
    /** 
 * Callback when we need to define a Closure in the JVM
 * @param name
 * @param bytes
 */
    public void acceptClass(    String name,    byte[] bytes){
      try {
        if (shouldDump(name.replace('/','.'),false)) {
          dump(name,bytes,false);
        }
      }
 catch (      Throwable throwable) {
        throwable.printStackTrace();
      }
      defineClass(loader,name,bytes);
    }
  }
;
  if (wContext == null) {
    weavingContext=new DefaultWeavingContext(loader);
  }
 else {
    weavingContext=wContext;
  }
  List definitions=parseDefinitions(loader);
  if (!enabled) {
    return;
  }
  bcelWorld=new LTWWorld(loader,getMessageHandler(),new ICrossReferenceHandler(){
    public void addCrossReference(    ISourceLocation from,    ISourceLocation to,    IRelationship.Kind kind,    boolean runtimeTest){
      ;
    }
  }
);
  weaver=new BcelWeaver(bcelWorld);
  registerDefinitions(weaver,loader,definitions);
  if (enabled) {
    weaver.prepareForWeave();
  }
 else {
    bcelWorld=null;
    weaver=null;
  }
}

Fixed version (ground truth):
protected void initialize(final ClassLoader deprecatedLoader,IWeavingContext deprecatedContext){
  if (initialized)   return;
  if (weavingContext == null) {
    weavingContext=new DefaultWeavingContext(classLoader);
  }
  createMessageHandler();
  this.generatedClassHandler=new GeneratedClassHandler(){
    /** 
 * Callback when we need to define a Closure in the JVM
 * @param name
 * @param bytes
 */
    public void acceptClass(    String name,    byte[] bytes){
      try {
        if (shouldDump(name.replace('/','.'),false)) {
          dump(name,bytes,false);
        }
      }
 catch (      Throwable throwable) {
        throwable.printStackTrace();
      }
      defineClass(classLoader,name,bytes);
    }
  }
;
  List definitions=parseDefinitions(classLoader);
  if (!enabled) {
    return;
  }
  bcelWorld=new LTWWorld(classLoader,getMessageHandler(),new ICrossReferenceHandler(){
    public void addCrossReference(    ISourceLocation from,    ISourceLocation to,    IRelationship.Kind kind,    boolean runtimeTest){
      ;
    }
  }
);
  weaver=new BcelWeaver(bcelWorld);
  registerDefinitions(weaver,classLoader,definitions);
  if (enabled) {
    weaver.prepareForWeave();
  }
 else {
    bcelWorld=null;
    weaver=null;
  }
  initialized=true;
}
Program: 9252
Project: 9252
Buggy source:
/** 
 * In an OSGi environment, determin which bundle a URL originated from. In a non-OSGi environment, implementors should return <code>null<code>.
 * @param url
 * @return
 */
public String getBundleIdFromURL(URL url);

Fixed version (ground truth):
/** 
 * In an OSGi environment, determin which bundle a URL originated from. In a non-OSGi environment, implementors should return <code>null<code>.
 * @param url
 * @return
 * @deprecated use getFile() or getClassLoaderName()
 */
public String getBundleIdFromURL(URL url);
Program: 9253
Project: 9253
Buggy source:
/** 
 * In an environment with multiple class loaders allows each to be identified using something safer and than toString
 * @return name of the associated class loader
 */
public String getClassLoaderName();

Fixed version (ground truth):
/** 
 * In an environment with multiple class loaders allows each to be identified using something safer and possibly shorter than toString
 * @return name of the associated class loader
 */
public String getClassLoaderName();
Program: 9255
Project: 9255
Buggy source:
public void acceptResult(UnwovenClassFile result){
  if (wovenClass == null) {
    wovenClass=result;
    String name=result.getClassName();
    if (shouldDump(name.replace('/','.'),false)) {
      dump(name,result.getBytes(),false);
    }
  }
 else {
    String className=result.getClassName();
    System.err.println("String_Node_Str" + wovenClass.getClassName() + "String_Node_Str"+ className);
    generatedClasses.put(className,result);
    generatedClasses.put(wovenClass.getClassName(),result);
    generatedClassHandler.acceptClass(className,result.getBytes());
  }
}

Fixed version (ground truth):
public void acceptResult(UnwovenClassFile result){
  if (wovenClass == null) {
    wovenClass=result;
    String name=result.getClassName();
    if (shouldDump(name.replace('/','.'),false)) {
      dump(name,result.getBytes(),false);
    }
  }
 else {
    String className=result.getClassName();
    generatedClasses.put(className,result);
    generatedClasses.put(wovenClass.getClassName(),result);
    generatedClassHandler.acceptClass(className,result.getBytes());
  }
}
Program: 9256
Project: 9256
Buggy source:
public IWeaveRequestor getRequestor(){
  return new IWeaveRequestor(){
    public void acceptResult(    UnwovenClassFile result){
      if (wovenClass == null) {
        wovenClass=result;
        String name=result.getClassName();
        if (shouldDump(name.replace('/','.'),false)) {
          dump(name,result.getBytes(),false);
        }
      }
 else {
        String className=result.getClassName();
        System.err.println("String_Node_Str" + wovenClass.getClassName() + "String_Node_Str"+ className);
        generatedClasses.put(className,result);
        generatedClasses.put(wovenClass.getClassName(),result);
        generatedClassHandler.acceptClass(className,result.getBytes());
      }
    }
    public void processingReweavableState(){
    }
    public void addingTypeMungers(){
    }
    public void weavingAspects(){
    }
    public void weavingClasses(){
    }
    public void weaveCompleted(){
      if (delegate != null)       delegate.weavingCompleted();
      ResolvedType.resetPrimitives();
    }
  }
;
}

Fixed version (ground truth):
public IWeaveRequestor getRequestor(){
  return new IWeaveRequestor(){
    public void acceptResult(    UnwovenClassFile result){
      if (wovenClass == null) {
        wovenClass=result;
        String name=result.getClassName();
        if (shouldDump(name.replace('/','.'),false)) {
          dump(name,result.getBytes(),false);
        }
      }
 else {
        String className=result.getClassName();
        generatedClasses.put(className,result);
        generatedClasses.put(wovenClass.getClassName(),result);
        generatedClassHandler.acceptClass(className,result.getBytes());
      }
    }
    public void processingReweavableState(){
    }
    public void addingTypeMungers(){
    }
    public void weavingAspects(){
    }
    public void weavingClasses(){
    }
    public void weaveCompleted(){
      if (delegate != null)       delegate.weavingCompleted();
      ResolvedType.resetPrimitives();
    }
  }
;
}