nus-yam/ex-repair huggingface dataset:
Program: 53481
Project: 53481
Buggy source:
private void bindTraceComponent(){
  bind(TraceRootFactory.class).to(DefaultTraceRootFactory.class).in(Scopes.SINGLETON);
  bind(TraceIdFactory.class).to(DefaultTraceIdFactory.class).in(Scopes.SINGLETON);
  bind(CallStackFactory.class).toProvider(CallStackFactoryProvider.class).in(Scopes.SINGLETON);
  bind(SpanFactory.class).to(DefaultSpanFactory.class).in(Scopes.SINGLETON);
  bind(SpanPostProcessor.class).toProvider(SpanPostProcessorProvider.class).in(Scopes.SINGLETON);
  bind(SpanChunkFactory.class).toProvider(SpanChunkFactoryProvider.class).in(Scopes.SINGLETON);
  bind(RecorderFactory.class).to(DefaultRecorderFactory.class).in(Scopes.SINGLETON);
  bind(BaseTraceFactory.class).toProvider(BaseTraceFactoryProvider.class).in(Scopes.SINGLETON);
  ;
  bind(TraceFactory.class).toProvider(TraceFactoryProvider.class).in(Scopes.SINGLETON);
}

Fixed version (ground truth):
private void bindTraceComponent(){
  bind(TraceRootFactory.class).to(DefaultTraceRootFactory.class).in(Scopes.SINGLETON);
  bind(TraceIdFactory.class).to(DefaultTraceIdFactory.class).in(Scopes.SINGLETON);
  bind(CallStackFactory.class).toProvider(CallStackFactoryProvider.class).in(Scopes.SINGLETON);
  bind(SpanFactory.class).to(DefaultSpanFactory.class).in(Scopes.SINGLETON);
  bind(SpanPostProcessor.class).toProvider(SpanPostProcessorProvider.class).in(Scopes.SINGLETON);
  bind(SpanChunkFactory.class).toProvider(SpanChunkFactoryProvider.class).in(Scopes.SINGLETON);
  bind(RecorderFactory.class).to(DefaultRecorderFactory.class).in(Scopes.SINGLETON);
  bind(BaseTraceFactory.class).toProvider(BaseTraceFactoryProvider.class).in(Scopes.SINGLETON);
  bind(TraceFactory.class).toProvider(TraceFactoryProvider.class).in(Scopes.SINGLETON);
}
Program: 53482
Project: 53482
Buggy source:
public static List<String> getHostIpList(){
  List<String> result=new ArrayList<String>();
  Enumeration<NetworkInterface> interfaces=null;
  try {
    interfaces=NetworkInterface.getNetworkInterfaces();
  }
 catch (  SocketException ignore) {
  }
  if (interfaces == null) {
    return Collections.emptyList();
  }
  while (interfaces.hasMoreElements()) {
    NetworkInterface current=interfaces.nextElement();
    if (isSkipNetworkInterface(current)) {
      continue;
    }
    Enumeration<InetAddress> addresses=current.getInetAddresses();
    while (addresses.hasMoreElements()) {
      InetAddress address=addresses.nextElement();
      if (address.isLoopbackAddress()) {
        continue;
      }
      String hostAddress=address.getHostAddress();
      if (!isLoopbackAddress(hostAddress)) {
        result.add(address.getHostAddress());
      }
    }
  }
  return result;
}

Fixed version (ground truth):
public static List<String> getHostIpList(){
  Enumeration<NetworkInterface> interfaces=null;
  try {
    interfaces=NetworkInterface.getNetworkInterfaces();
  }
 catch (  SocketException ignore) {
  }
  if (interfaces == null) {
    return Collections.emptyList();
  }
  List<String> result=new ArrayList<String>();
  while (interfaces.hasMoreElements()) {
    NetworkInterface current=interfaces.nextElement();
    if (isSkipNetworkInterface(current)) {
      continue;
    }
    Enumeration<InetAddress> addresses=current.getInetAddresses();
    while (addresses.hasMoreElements()) {
      InetAddress address=addresses.nextElement();
      if (address.isLoopbackAddress()) {
        continue;
      }
      String hostAddress=address.getHostAddress();
      if (!isLoopbackAddress(hostAddress)) {
        result.add(address.getHostAddress());
      }
    }
  }
  return result;
}
Program: 53483
Project: 53483
Buggy source:
/** 
 * Returns a list of ip addresses on this machine that is accessible from a remote source. If no network interfaces can be found on this machine, returns an empty List.
 */
public static List<String> getLocalV4IpList(){
  List<String> result=new ArrayList<String>();
  Enumeration<NetworkInterface> interfaces=null;
  try {
    interfaces=NetworkInterface.getNetworkInterfaces();
  }
 catch (  SocketException ignore) {
  }
  if (interfaces == null) {
    return Collections.emptyList();
  }
  while (interfaces.hasMoreElements()) {
    NetworkInterface current=interfaces.nextElement();
    if (isSkipIp(current)) {
      continue;
    }
    Enumeration<InetAddress> addresses=current.getInetAddresses();
    while (addresses.hasMoreElements()) {
      InetAddress address=addresses.nextElement();
      if (address.isLoopbackAddress() || !(address instanceof Inet4Address)) {
        continue;
      }
      if (validationIpV4FormatAddress(address.getHostAddress())) {
        result.add(address.getHostAddress());
      }
    }
  }
  return result;
}

Fixed version (ground truth):
/** 
 * Returns a list of ip addresses on this machine that is accessible from a remote source. If no network interfaces can be found on this machine, returns an empty List.
 */
public static List<String> getLocalV4IpList(){
  Enumeration<NetworkInterface> interfaces=null;
  try {
    interfaces=NetworkInterface.getNetworkInterfaces();
  }
 catch (  SocketException ignore) {
  }
  if (interfaces == null) {
    return Collections.emptyList();
  }
  List<String> result=new ArrayList<String>();
  while (interfaces.hasMoreElements()) {
    NetworkInterface current=interfaces.nextElement();
    if (isSkipIp(current)) {
      continue;
    }
    Enumeration<InetAddress> addresses=current.getInetAddresses();
    while (addresses.hasMoreElements()) {
      InetAddress address=addresses.nextElement();
      if (address.isLoopbackAddress() || !(address instanceof Inet4Address)) {
        continue;
      }
      if (validationIpV4FormatAddress(address.getHostAddress())) {
        result.add(address.getHostAddress());
      }
    }
  }
  return result;
}
Program: 53484
Project: 53484
Buggy source:
public static boolean decisionBatchServer(String ip){
  Enumeration<NetworkInterface> interfaces;
  try {
    interfaces=NetworkInterface.getNetworkInterfaces();
  }
 catch (  SocketException e) {
    logger.error("String_Node_Str",e);
    return false;
  }
  while (interfaces.hasMoreElements()) {
    NetworkInterface network=interfaces.nextElement();
    Enumeration<InetAddress> inets=network.getInetAddresses();
    while (inets.hasMoreElements()) {
      InetAddress next=inets.nextElement();
      if (next instanceof Inet4Address) {
        if (next.getHostAddress().equals(ip)) {
          return true;
        }
      }
    }
  }
  return false;
}

Fixed version (ground truth):
public static boolean decisionBatchServer(String ip){
  Enumeration<NetworkInterface> interfaces;
  try {
    interfaces=NetworkInterface.getNetworkInterfaces();
  }
 catch (  SocketException e) {
    logger.error("String_Node_Str",e);
    return false;
  }
  if (interfaces == null) {
    return false;
  }
  while (interfaces.hasMoreElements()) {
    NetworkInterface network=interfaces.nextElement();
    Enumeration<InetAddress> inets=network.getInetAddresses();
    while (inets.hasMoreElements()) {
      InetAddress next=inets.nextElement();
      if (next instanceof Inet4Address) {
        if (next.getHostAddress().equals(ip)) {
          return true;
        }
      }
    }
  }
  return false;
}
Program: 53485
Project: 53485
Buggy source:
@Override public String toString(){
  final StringBuilder sb=new StringBuilder("String_Node_Str");
  sb.append("String_Node_Str").append(deadlockedThreadIdSet);
  sb.append('}');
  return sb.toString();
}

Fixed version (ground truth):
@Override public String toString(){
  final StringBuilder sb=new StringBuilder("String_Node_Str");
  sb.append("String_Node_Str").append(deadlockedThreadIdMap.keySet());
  sb.append('}');
  return sb.toString();
}
Program: 53486
Project: 53486
Buggy source:
@Override public Set<Long> getDeadlockedThreadIdSet(){
  Set<Long> copied=new HashSet<Long>(deadlockedThreadIdSet.size());
  copied.addAll(deadlockedThreadIdSet);
  return copied;
}

Fixed version (ground truth):
@Override public Set<Long> getDeadlockedThreadIdSet(){
  final ConcurrentMap<Long,Object> deadlockedThreadIdMap=this.deadlockedThreadIdMap;
  if (deadlockedThreadIdMap.isEmpty()) {
    return Collections.emptySet();
  }
  return new HashSet<Long>(deadlockedThreadIdMap.keySet());
}
Program: 53487
Project: 53487
Buggy source:
boolean addDeadlockedThread(long threadId){
  return deadlockedThreadIdSet.add(threadId);
}

Fixed version (ground truth):
boolean addDeadlockedThread(long threadId){
  Object oldValue=deadlockedThreadIdMap.putIfAbsent(threadId,DUMMY_VALUE);
  return oldValue == null;
}
Program: 53488
Project: 53488
Buggy source:
private void addServerInterceptor(final JettyConfiguration config){
  transformTemplate.transform("String_Node_Str",new TransformCallback(){
    @Override public byte[] doInTransform(    Instrumentor instrumentor,    ClassLoader classLoader,    String className,    Class<?> classBeingRedefined,    ProtectionDomain protectionDomain,    byte[] classfileBuffer) throws InstrumentException {
      InstrumentClass target=instrumentor.getInstrumentClass(classLoader,className,classfileBuffer);
      InstrumentMethod handleMethodEditorBuilder=target.getDeclaredMethod("String_Node_Str","String_Node_Str");
      if (handleMethodEditorBuilder != null) {
        handleMethodEditorBuilder.addInterceptor("String_Node_Str",va(config.getJettyExcludeUrlFilter()));
        return target.toBytecode();
      }
      InstrumentMethod jetty8HandleMethodEditorBuilder=target.getDeclaredMethod("String_Node_Str","String_Node_Str");
      if (jetty8HandleMethodEditorBuilder != null) {
        jetty8HandleMethodEditorBuilder.addInterceptor("String_Node_Str",va(config.getJettyExcludeUrlFilter()));
        return target.toBytecode();
      }
      return target.toBytecode();
    }
  }
);
}

Fixed version (ground truth):
private void addServerInterceptor(final JettyConfiguration config){
  transformTemplate.transform("String_Node_Str",new TransformCallback(){
    @Override public byte[] doInTransform(    Instrumentor instrumentor,    ClassLoader classLoader,    String className,    Class<?> classBeingRedefined,    ProtectionDomain protectionDomain,    byte[] classfileBuffer) throws InstrumentException {
      InstrumentClass target=instrumentor.getInstrumentClass(classLoader,className,classfileBuffer);
      InstrumentMethod handleMethodEditorBuilder=target.getDeclaredMethod("String_Node_Str","String_Node_Str");
      if (handleMethodEditorBuilder != null) {
        handleMethodEditorBuilder.addInterceptor("String_Node_Str",va(config.getJettyExcludeUrlFilter()));
        return target.toBytecode();
      }
      InstrumentMethod jetty80HandleMethodEditorBuilder=target.getDeclaredMethod("String_Node_Str","String_Node_Str");
      if (jetty80HandleMethodEditorBuilder != null) {
        jetty80HandleMethodEditorBuilder.addInterceptor("String_Node_Str",va(config.getJettyExcludeUrlFilter()));
        return target.toBytecode();
      }
      InstrumentMethod jetty82HandleMethodEditorBuilder=target.getDeclaredMethod("String_Node_Str","String_Node_Str");
      if (jetty82HandleMethodEditorBuilder != null) {
        jetty82HandleMethodEditorBuilder.addInterceptor("String_Node_Str",va(config.getJettyExcludeUrlFilter()));
        return target.toBytecode();
      }
      return target.toBytecode();
    }
  }
);
}
Program: 53489
Project: 53489
Buggy source:
@Override public byte[] doInTransform(Instrumentor instrumentor,ClassLoader classLoader,String className,Class<?> classBeingRedefined,ProtectionDomain protectionDomain,byte[] classfileBuffer) throws InstrumentException {
  InstrumentClass target=instrumentor.getInstrumentClass(classLoader,className,classfileBuffer);
  InstrumentMethod handleMethodEditorBuilder=target.getDeclaredMethod("String_Node_Str","String_Node_Str");
  if (handleMethodEditorBuilder != null) {
    handleMethodEditorBuilder.addInterceptor("String_Node_Str",va(config.getJettyExcludeUrlFilter()));
    return target.toBytecode();
  }
  InstrumentMethod jetty8HandleMethodEditorBuilder=target.getDeclaredMethod("String_Node_Str","String_Node_Str");
  if (jetty8HandleMethodEditorBuilder != null) {
    jetty8HandleMethodEditorBuilder.addInterceptor("String_Node_Str",va(config.getJettyExcludeUrlFilter()));
    return target.toBytecode();
  }
  return target.toBytecode();
}

Fixed version (ground truth):
@Override public byte[] doInTransform(Instrumentor instrumentor,ClassLoader classLoader,String className,Class<?> classBeingRedefined,ProtectionDomain protectionDomain,byte[] classfileBuffer) throws InstrumentException {
  InstrumentClass target=instrumentor.getInstrumentClass(classLoader,className,classfileBuffer);
  InstrumentMethod handleMethodEditorBuilder=target.getDeclaredMethod("String_Node_Str","String_Node_Str");
  if (handleMethodEditorBuilder != null) {
    handleMethodEditorBuilder.addInterceptor("String_Node_Str",va(config.getJettyExcludeUrlFilter()));
    return target.toBytecode();
  }
  InstrumentMethod jetty80HandleMethodEditorBuilder=target.getDeclaredMethod("String_Node_Str","String_Node_Str");
  if (jetty80HandleMethodEditorBuilder != null) {
    jetty80HandleMethodEditorBuilder.addInterceptor("String_Node_Str",va(config.getJettyExcludeUrlFilter()));
    return target.toBytecode();
  }
  InstrumentMethod jetty82HandleMethodEditorBuilder=target.getDeclaredMethod("String_Node_Str","String_Node_Str");
  if (jetty82HandleMethodEditorBuilder != null) {
    jetty82HandleMethodEditorBuilder.addInterceptor("String_Node_Str",va(config.getJettyExcludeUrlFilter()));
    return target.toBytecode();
  }
  return target.toBytecode();
}
Program: 53490
Project: 53490
Buggy source:
private AgentStatPoint<Integer> createPoint(long timestamp,List<Integer> values){
  if (values.isEmpty()) {
    return SampledDataSource.UNCOLLECTED_POINT_CREATER.createUnCollectedPoint(timestamp);
  }
 else {
    return new AgentStatPoint<>(timestamp,INTEGER_DOWN_SAMPLER.sampleMin(values),INTEGER_DOWN_SAMPLER.sampleMax(values),INTEGER_DOWN_SAMPLER.sampleAvg(values,3),INTEGER_DOWN_SAMPLER.sampleSum(values));
  }
}

Fixed version (ground truth):
private AgentStatPoint<Integer> createPoint(long timestamp,List<Integer> values){
  if (values.isEmpty()) {
    return SampledDataSource.UNCOLLECTED_POINT_CREATOR.createUnCollectedPoint(timestamp);
  }
 else {
    return new AgentStatPoint<>(timestamp,INTEGER_DOWN_SAMPLER.sampleMin(values),INTEGER_DOWN_SAMPLER.sampleMax(values),INTEGER_DOWN_SAMPLER.sampleAvg(values,3),INTEGER_DOWN_SAMPLER.sampleSum(values));
  }
}
Program: 53491
Project: 53491
Buggy source:
private List<P> createInitialPoints(){
  int numTimeslots=(int)this.timeWindow.getWindowRangeCount();
  List<P> points=new ArrayList<>(numTimeslots);
  for (  long timestamp : this.timeWindow) {
    points.add(uncollectedPointCreater.createUnCollectedPoint(timestamp));
  }
  return points;
}

Fixed version (ground truth):
private List<P> createInitialPoints(){
  int numTimeslots=(int)this.timeWindow.getWindowRangeCount();
  List<P> points=new ArrayList<>(numTimeslots);
  for (  long timestamp : this.timeWindow) {
    points.add(uncollectedPointCreator.createUnCollectedPoint(timestamp));
  }
  return points;
}
Program: 53492
Project: 53492
Buggy source:
public TimeSeriesChartBuilder(TimeWindow timeWindow,Point.UncollectedPointCreater<P> uncollectedPointCreator){
  if (timeWindow.getWindowRangeCount() > Integer.MAX_VALUE) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  if (uncollectedPointCreator == null) {
    throw new NullPointerException("String_Node_Str");
  }
  this.timeWindow=timeWindow;
  this.uncollectedPointCreater=uncollectedPointCreator;
}

Fixed version (ground truth):
public TimeSeriesChartBuilder(TimeWindow timeWindow,Point.UncollectedPointCreator<P> uncollectedPointCreator){
  if (timeWindow.getWindowRangeCount() > Integer.MAX_VALUE) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  if (uncollectedPointCreator == null) {
    throw new NullPointerException("String_Node_Str");
  }
  this.timeWindow=timeWindow;
  this.uncollectedPointCreator=uncollectedPointCreator;
}
Program: 53493
Project: 53493
Buggy source:
private Chart<AgentStatPoint<Integer>> buildChart(TimeWindow timeWindow,List<AgentStatPoint<Integer>> activeConnectionSizes){
  TimeSeriesChartBuilder<AgentStatPoint<Integer>> builder=new TimeSeriesChartBuilder<>(timeWindow,SampledDataSource.UNCOLLECTED_POINT_CREATER);
  Chart<AgentStatPoint<Integer>> chart=builder.build(activeConnectionSizes);
  return chart;
}

Fixed version (ground truth):
private Chart<AgentStatPoint<Integer>> buildChart(TimeWindow timeWindow,List<AgentStatPoint<Integer>> activeConnectionSizes){
  TimeSeriesChartBuilder<AgentStatPoint<Integer>> builder=new TimeSeriesChartBuilder<>(timeWindow,SampledDataSource.UNCOLLECTED_POINT_CREATOR);
  Chart<AgentStatPoint<Integer>> chart=builder.build(activeConnectionSizes);
  return chart;
}
Program: 53494
Project: 53494
Buggy source:
public DatabaseInfo parse(String url){
  if (url == null) {
    return UnKnownDatabaseInfo.INSTANCE;
  }
  final DatabaseInfo hit=cache.get(url);
  if (hit != null) {
    logger.debug("String_Node_Str",url,hit);
    return hit;
  }
  DatabaseInfo databaseInfo=null;
  try {
    databaseInfo=doParse(url);
  }
 catch (  Exception e) {
    logger.error("String_Node_Str",url);
    databaseInfo=UnKnownDatabaseInfo.INSTANCE;
  }
  final DatabaseInfo old=cache.putIfAbsent(url,databaseInfo);
  if (old != null) {
    return old;
  }
  return databaseInfo;
}

Fixed version (ground truth):
public DatabaseInfo parse(String url){
  if (url == null) {
    return UnKnownDatabaseInfo.INSTANCE;
  }
  final DatabaseInfo hit=cache.get(url);
  if (hit != null) {
    logger.debug("String_Node_Str",url,hit);
    return hit;
  }
  final DatabaseInfo databaseInfo=getDatabaseInfo(url);
  final DatabaseInfo old=cache.putIfAbsent(url,databaseInfo);
  if (old != null) {
    return old;
  }
  return databaseInfo;
}
Program: 53495
Project: 53495
Buggy source:
private final long getTransactionCount(){
  final long transactionCount=longCounter.getCount();
  if (transactionCount < 0) {
    return UNCOLLECTED;
  }
  if (this.prevTransactionCount == UNINITIALIZED) {
    this.prevTransactionCount=transactionCount;
    return 0L;
  }
  final long transactionCountDelta=transactionCount - this.prevTransactionCount;
  this.prevTransactionCount=transactionCount;
  return transactionCountDelta;
}

Fixed version (ground truth):
private long getTransactionCount(){
  final long transactionCount=longCounter.getCount();
  if (transactionCount < 0) {
    return UNCOLLECTED;
  }
  if (this.prevTransactionCount == UNINITIALIZED) {
    this.prevTransactionCount=transactionCount;
    return 0L;
  }
  final long transactionCountDelta=transactionCount - this.prevTransactionCount;
  this.prevTransactionCount=transactionCount;
  return transactionCountDelta;
}
Program: 53496
Project: 53496
Buggy source:
@Override public boolean equals(Object o){
  if (this == o)   return true;
  if (o == null || getClass() != o.getClass())   return false;
  Application that=(Application)o;
  if (serviceType != that.serviceType)   return false;
  if (!name.equals(that.name))   return false;
  return true;
}

Fixed version (ground truth):
@Override public boolean equals(Object o){
  if (this == o)   return true;
  if (o == null || getClass() != o.getClass())   return false;
  Application that=(Application)o;
  if (!name.equals(that.name))   return false;
  return serviceType.equals(that.serviceType);
}
Program: 53497
Project: 53497
Buggy source:
@Override public ServiceType getServiceType(){
  if (this.serviceType != null) {
    return this.serviceType;
  }
  DataSourceMonitor dataSourceMonitor=getInstance();
  if (dataSourceMonitor != null) {
    ServiceType serviceType=dataSourceMonitor.getServiceType();
    if (serviceType != null) {
      this.serviceType=serviceType;
    }
    return serviceType;
  }
  return ServiceType.UNKNOWN;
}

Fixed version (ground truth):
@Override public ServiceType getServiceType(){
  final ServiceType copy=this.serviceType;
  if (copy != null) {
    return copy;
  }
  final DataSourceMonitor dataSourceMonitor=getInstance();
  if (dataSourceMonitor != null) {
    this.serviceType=getServiceType0(dataSourceMonitor);
    return serviceType;
  }
  return ServiceType.UNKNOWN;
}
Program: 53498
Project: 53498
Buggy source:
private MatcherOperand joinOr(){
  MatcherOperand operand=null;
  for (  String baseClassName : this.baseClassNames) {
    if (operand == null) {
      operand=new ClassInternalNameMatcherOperand(baseClassName);
    }
 else {
      final MatcherOperand classMatcherOperand=new ClassInternalNameMatcherOperand(baseClassName);
      operand=operand.or(classMatcherOperand);
    }
  }
  return operand;
}

Fixed version (ground truth):
private MatcherOperand joinOr(List<String> baseClassNames){
  MatcherOperand operand=null;
  for (  String baseClassName : baseClassNames) {
    if (operand == null) {
      operand=new ClassInternalNameMatcherOperand(baseClassName);
    }
 else {
      final MatcherOperand classMatcherOperand=new ClassInternalNameMatcherOperand(baseClassName);
      operand=operand.or(classMatcherOperand);
    }
  }
  return operand;
}
Program: 53499
Project: 53499
Buggy source:
DefaultMultiClassBasedMatcher(final List<String> baseClassNames,final MatcherOperand additional){
  if (CollectionUtils.isEmpty(baseClassNames)) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  this.baseClassNames=baseClassNames;
  this.matcherOperand=getMatcherOperand(additional);
}

Fixed version (ground truth):
DefaultMultiClassBasedMatcher(final List<String> baseClassNames,final MatcherOperand additional){
  if (CollectionUtils.isEmpty(baseClassNames)) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  this.baseClassNames=baseClassNames;
  this.matcherOperand=getMatcherOperand(baseClassNames,additional);
}
Program: 53500
Project: 53500
Buggy source:
private MatcherOperand joinOr(List<String> basePackageNames){
  if (basePackageNames.isEmpty()) {
    throw new IllegalArgumentException("String_Node_Str" + basePackageNames);
  }
  MatcherOperand operandGroup=null;
  for (  String basePackageName : basePackageNames) {
    if (operandGroup == null) {
      operandGroup=new PackageInternalNameMatcherOperand(basePackageName);
    }
 else {
      final MatcherOperand packageMatcherOperand=new PackageInternalNameMatcherOperand(basePackageName);
      operandGroup=operandGroup.or(packageMatcherOperand);
    }
  }
  return operandGroup;
}

Fixed version (ground truth):
private MatcherOperand joinOr(List<String> basePackageNames){
  if (basePackageNames.isEmpty()) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  MatcherOperand operandGroup=null;
  for (  String basePackageName : basePackageNames) {
    if (operandGroup == null) {
      operandGroup=new PackageInternalNameMatcherOperand(basePackageName);
    }
 else {
      final MatcherOperand packageMatcherOperand=new PackageInternalNameMatcherOperand(basePackageName);
      operandGroup=operandGroup.or(packageMatcherOperand);
    }
  }
  return operandGroup;
}
Program: 53501
Project: 53501
Buggy source:
DefaultMultiPackageBasedMatcher(final List<String> basePackageNames,final MatcherOperand additional){
  if (CollectionUtils.isEmpty(basePackageNames)) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  final List<String> buildBasePackageName=buildBasePackageNameList(basePackageNames);
  final MatcherOperand operand=joinOr(buildBasePackageName);
  this.matcherOperand=addOr(operand,additional);
  this.basePackageNames=Collections.unmodifiableList(buildBasePackageName);
}

Fixed version (ground truth):
DefaultMultiPackageBasedMatcher(final List<String> basePackageNames,final MatcherOperand additional){
  if (CollectionUtils.isEmpty(basePackageNames)) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  final List<String> buildBasePackageName=buildBasePackageNameList(basePackageNames);
  final MatcherOperand operand=joinOr(buildBasePackageName);
  if (operand == null) {
    throw new IllegalStateException("String_Node_Str");
  }
  this.matcherOperand=addOr(operand,additional);
  this.basePackageNames=Collections.unmodifiableList(buildBasePackageName);
}
Program: 53502
Project: 53502
Buggy source:
@Override public void afterPropertiesSet() throws Exception {
  Assert.notNull(properties);
  readPropertyValues(this.properties);
}

Fixed version (ground truth):
@Override public void afterPropertiesSet() throws Exception {
  final Properties properties=Objects.requireNonNull(this.properties,"String_Node_Str");
  readPropertyValues(properties);
}
Program: 53503
Project: 53503
Buggy source:
private Socket createSocket(InetSocketAddress socketAddress) throws IOException {
  final Socket socket=new Socket();
  boolean success=false;
  try {
    socket.setSoTimeout(3000);
    socket.connect(socketAddress);
    success=true;
  }
  finally {
    if (!success) {
      IOUtils.closeQuietly(socket);
    }
  }
  return socket;
}

Fixed version (ground truth):
private Socket createSocket(InetSocketAddress socketAddress) throws IOException {
  Socket socket=null;
  boolean success=false;
  try {
    socket=new Socket();
    socket.setSoTimeout(3000);
    socket.connect(socketAddress);
    success=true;
  }
  finally {
    if (!success) {
      IOUtils.closeQuietly(socket);
    }
  }
  return socket;
}
Program: 53504
Project: 53504
Buggy source:
public StringUtils(){
  throw new AssertionError();
}

Fixed version (ground truth):
private StringUtils(){
}
Program: 53505
Project: 53505
Buggy source:
private Socket createSocket(InetSocketAddress socketAddress) throws IOException {
  Socket socket=new Socket();
  socket.connect(socketAddress);
  socket.setSoTimeout(3000);
  return socket;
}

Fixed version (ground truth):
private Socket createSocket(InetSocketAddress socketAddress) throws IOException {
  final Socket socket=new Socket();
  boolean success=false;
  try {
    socket.setSoTimeout(3000);
    socket.connect(socketAddress);
    success=true;
  }
  finally {
    if (!success) {
      IOUtils.closeQuietly(socket);
    }
  }
  return socket;
}
Program: 53506
Project: 53506
Buggy source:
private byte[] read(Socket socket,int readSize) throws IOException {
  byte[] buf=new byte[readSize];
  InputStream inputStream=socket.getInputStream();
  inputStream.read(buf);
  return buf;
}

Fixed version (ground truth):
private byte[] read(Socket socket,int readSize) throws IOException {
  byte[] buf=new byte[readSize];
  InputStream inputStream=socket.getInputStream();
  int read=inputStream.read(buf);
  if (read == IOUtils.EOF) {
    return IOUtils.EMPTY_BYTES;
  }
  return Arrays.copyOf(buf,read);
}
Program: 53507
Project: 53507
Buggy source:
@Override protected boolean check(InetSocketAddress address,byte[] requestData,byte[] expectedResponseData) throws IOException {
  Socket socket=null;
  try {
    socket=createSocket(address);
    write(socket,requestData);
    byte[] responseData=read(socket,100);
    return Arrays.equals(expectedResponseData,responseData);
  }
 catch (  IOException e) {
    e.printStackTrace();
  }
 finally {
    if (socket != null) {
      socket.close();
    }
  }
  return false;
}

Fixed version (ground truth):
@Override protected boolean check(InetSocketAddress address,byte[] requestData,byte[] expectedResponseData) throws IOException {
  Socket socket=null;
  try {
    socket=createSocket(address);
    write(socket,requestData);
    byte[] responseData=read(socket,100);
    return Arrays.equals(expectedResponseData,responseData);
  }
 catch (  IOException e) {
    e.printStackTrace();
  }
 finally {
    IOUtils.closeQuietly(socket);
  }
  return false;
}
Program: 53508
Project: 53508
Buggy source:
private DatagramSocket createSocket(InetSocketAddress socketAddress) throws IOException {
  DatagramSocket socket=new DatagramSocket();
  socket.connect(socketAddress);
  socket.setSoTimeout(3000);
  return socket;
}

Fixed version (ground truth):
private DatagramSocket createSocket(InetSocketAddress socketAddress) throws IOException {
  final DatagramSocket socket=new DatagramSocket();
  boolean success=false;
  try {
    socket.setSoTimeout(3000);
    socket.connect(socketAddress);
    success=true;
  }
  finally {
    if (!success) {
      IOUtils.closeQuietly(socket);
    }
  }
  return socket;
}
Program: 53509
Project: 53509
Buggy source:
private byte[] read(DatagramSocket socket,int readSize) throws IOException {
  byte[] buf=new byte[readSize];
  DatagramPacket datagramPacket=new DatagramPacket(buf,buf.length);
  socket.receive(datagramPacket);
  return buf;
}

Fixed version (ground truth):
private byte[] read(DatagramSocket socket,int readSize) throws IOException {
  byte[] buf=new byte[readSize];
  DatagramPacket datagramPacket=new DatagramPacket(buf,buf.length);
  socket.receive(datagramPacket);
  int length=datagramPacket.getLength();
  if (length == 0) {
    return IOUtils.EMPTY_BYTES;
  }
  return Arrays.copyOf(buf,length);
}
Program: 53510
Project: 53510
Buggy source:
@Override protected boolean check(InetSocketAddress address,byte[] requestData,byte[] expectedResponseData){
  DatagramSocket socket=null;
  try {
    socket=createSocket();
    write(socket,requestData,address);
    byte[] responseData=read(socket,expectedResponseData.length);
    return Arrays.equals(expectedResponseData,responseData);
  }
 catch (  IOException e) {
    e.printStackTrace();
  }
 finally {
    if (socket != null) {
      socket.close();
    }
  }
  return false;
}

Fixed version (ground truth):
@Override protected boolean check(InetSocketAddress address,byte[] requestData,byte[] expectedResponseData){
  DatagramSocket socket=null;
  try {
    socket=createSocket();
    write(socket,requestData,address);
    byte[] responseData=read(socket,expectedResponseData.length);
    return Arrays.equals(expectedResponseData,responseData);
  }
 catch (  IOException e) {
    e.printStackTrace();
  }
 finally {
    IOUtils.closeQuietly(socket);
  }
  return false;
}
Program: 53511
Project: 53511
Buggy source:
@Override public void doInAfterTrace(SpanEventRecorder recorder,Object target,Object[] args,Object result,Throwable throwable){
  recorder.recordApi(methodDescriptor);
  recorder.recordServiceType(VertxConstants.VERTX_HTTP_SERVER_INTERNAL);
  recorder.recordException(throwable);
  if (target instanceof ResponseGetter) {
    final HttpResponse response=((ResponseGetter)target)._$PINPOINT$_getResponse();
    final SpanRecorder spanRecorder=getAsyncContext(target).currentAsyncTraceObject().getSpanRecorder();
    this.httpStatusCodeRecorder.record(spanRecorder,response.status().code());
  }
}

Fixed version (ground truth):
@Override public void doInAfterTrace(SpanEventRecorder recorder,Object target,Object[] args,Object result,Throwable throwable){
  recorder.recordApi(methodDescriptor);
  recorder.recordServiceType(VertxConstants.VERTX_HTTP_SERVER_INTERNAL);
  recorder.recordException(throwable);
  if (target instanceof ResponseGetter) {
    final HttpResponse response=((ResponseGetter)target)._$PINPOINT$_getResponse();
    final AsyncContext asyncContext=getAsyncContext(target);
    if (asyncContext != null) {
      final Trace trace=asyncContext.currentAsyncTraceObject();
      if (trace != null) {
        final SpanRecorder spanRecorder=trace.getSpanRecorder();
        this.httpStatusCodeRecorder.record(spanRecorder,response.status().code());
      }
    }
  }
}
Program: 53512
Project: 53512
Buggy source:
@Override public void setup(ProfilerPluginSetupContext context){
  NettyConfig config=new NettyConfig(context.getConfig());
  this.config=config;
  if (!config.isPluginEnable()) {
    logger.info("String_Node_Str");
    return;
  }
  transformTemplate.transform("String_Node_Str",new BootstrapTransformer());
  transformTemplate.transform("String_Node_Str",new ChannelPipelineTransformer());
  transformTemplate.transform("String_Node_Str",new PromiseTransformer());
  transformTemplate.transform("String_Node_Str",new ChannelPromiseTransformer());
  if (config.isHttpCodecEnable()) {
    transformTemplate.transform("String_Node_Str",new HttpRequestTransformer());
    transformTemplate.transform("String_Node_Str",new HttpEncoderTransformer());
  }
}

Fixed version (ground truth):
@Override public void setup(ProfilerPluginSetupContext context){
  NettyConfig config=new NettyConfig(context.getConfig());
  if (!config.isPluginEnable()) {
    logger.info("String_Node_Str");
    return;
  }
  transformTemplate.transform("String_Node_Str",new BootstrapTransformer());
  transformTemplate.transform("String_Node_Str",new ChannelPipelineTransformer());
  transformTemplate.transform("String_Node_Str",new PromiseTransformer());
  transformTemplate.transform("String_Node_Str",new ChannelPromiseTransformer());
  if (config.isHttpCodecEnable()) {
    transformTemplate.transform("String_Node_Str",new HttpRequestTransformer());
    transformTemplate.transform("String_Node_Str",new HttpEncoderTransformer());
  }
}
Program: 53513
Project: 53513
Buggy source:
DefaultClassBasedMatcher(final String baseClassName,final MatcherOperand additional){
  Assert.requireNonNull(baseClassName,"String_Node_Str");
  this.baseClassName=baseClassName;
  MatcherOperand operand=new ClassInternalNameMatcherOperand(baseClassName);
  if (additional != null) {
    operand=operand.and(additional);
  }
  this.matcherOperand=operand;
}

Fixed version (ground truth):
DefaultClassBasedMatcher(final String baseClassName,final MatcherOperand additional){
  this.baseClassName=Assert.requireNonNull(baseClassName,"String_Node_Str");
  this.matcherOperand=getMatcherOperand(baseClassName,additional);
}
Program: 53514
Project: 53514
Buggy source:
DefaultMultiClassBasedMatcher(final List<String> baseClassNames,final MatcherOperand additional){
  Assert.requireNonNull(baseClassNames,"String_Node_Str");
  this.baseClassNames=Collections.unmodifiableList(baseClassNames);
  MatcherOperand operand=null;
  for (  String baseClassName : this.baseClassNames) {
    final MatcherOperand classMatcherOperand=new ClassInternalNameMatcherOperand(baseClassName);
    if (operand == null) {
      operand=classMatcherOperand;
    }
 else {
      operand=operand.or(classMatcherOperand);
    }
  }
  if (additional != null) {
    operand=operand.and(additional);
  }
  this.matcherOperand=operand;
}

Fixed version (ground truth):
DefaultMultiClassBasedMatcher(final List<String> baseClassNames,final MatcherOperand additional){
  if (CollectionUtils.isEmpty(baseClassNames)) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  this.baseClassNames=baseClassNames;
  this.matcherOperand=getMatcherOperand(additional);
}
Program: 53515
Project: 53515
Buggy source:
DefaultMultiPackageBasedMatcher(final List<String> basePackageNames,final MatcherOperand additional){
  Assert.requireNonNull(basePackageNames,"String_Node_Str");
  final List<String> list=new ArrayList<String>();
  for (  String basePackageName : basePackageNames) {
    if (basePackageName != null && !basePackageName.isEmpty()) {
      list.add(basePackageName);
    }
  }
  if (list.isEmpty()) {
    throw new IllegalArgumentException("String_Node_Str" + basePackageNames);
  }
  this.basePackageNames=Collections.unmodifiableList(list);
  MatcherOperand operand=null;
  for (  String basePackageName : this.basePackageNames) {
    final MatcherOperand packageMatcherOperand=new PackageInternalNameMatcherOperand(basePackageName);
    if (operand == null) {
      operand=packageMatcherOperand;
    }
 else {
      operand=operand.or(packageMatcherOperand);
    }
  }
  if (additional != null) {
    operand=operand.and(additional);
  }
  this.matcherOperand=operand;
}

Fixed version (ground truth):
DefaultMultiPackageBasedMatcher(final List<String> basePackageNames,final MatcherOperand additional){
  if (CollectionUtils.isEmpty(basePackageNames)) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  final List<String> buildBasePackageName=buildBasePackageNameList(basePackageNames);
  final MatcherOperand operand=joinOr(buildBasePackageName);
  this.matcherOperand=addOr(operand,additional);
  this.basePackageNames=Collections.unmodifiableList(buildBasePackageName);
}
Program: 53516
Project: 53516
Buggy source:
DefaultPackageBasedMatcher(final String basePackageName,final MatcherOperand additional){
  Assert.requireNonNull(basePackageName,"String_Node_Str");
  if (basePackageName.isEmpty()) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  this.basePackageName=basePackageName;
  MatcherOperand operand=new PackageInternalNameMatcherOperand(basePackageName);
  if (additional != null) {
    operand=operand.and(additional);
  }
  this.matcherOperand=operand;
}

Fixed version (ground truth):
DefaultPackageBasedMatcher(final String basePackageName,final MatcherOperand additional){
  Assert.requireNonNull(basePackageName,"String_Node_Str");
  if (!StringUtils.hasText(basePackageName)) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  this.basePackageName=basePackageName;
  MatcherOperand operand=new PackageInternalNameMatcherOperand(basePackageName);
  if (additional != null) {
    operand=operand.and(additional);
  }
  this.matcherOperand=operand;
}
Program: 53517
Project: 53517
Buggy source:
public boolean match(final String annotationInternalName){
  if (annotationInternalName != null) {
    return this.annotationInternalName.equals(annotationInternalName);
  }
  return false;
}

Fixed version (ground truth):
public boolean match(final String annotationInternalName){
  if (annotationInternalName == null) {
    return false;
  }
  return this.annotationInternalName.equals(annotationInternalName);
}
Program: 53518
Project: 53518
Buggy source:
public boolean match(final String classInternalName){
  if (classInternalName != null) {
    return this.classInternalName.equals(classInternalName);
  }
  return false;
}

Fixed version (ground truth):
public boolean match(final String classInternalName){
  if (classInternalName == null) {
    return false;
  }
  return this.classInternalName.equals(classInternalName);
}
Program: 53519
Project: 53519
Buggy source:
public boolean match(final String interfaceInternalName){
  if (interfaceInternalName != null) {
    return this.interfaceInternalName.equals(interfaceInternalName);
  }
  return false;
}

Fixed version (ground truth):
public boolean match(final String interfaceInternalName){
  if (interfaceInternalName == null) {
    return false;
  }
  return this.interfaceInternalName.equals(interfaceInternalName);
}
Program: 53520
Project: 53520
Buggy source:
public boolean match(final String packageInternalName){
  if (packageInternalName != null) {
    return packageInternalName.startsWith(this.packageInternalName);
  }
  return false;
}

Fixed version (ground truth):
public boolean match(final String packageInternalName){
  if (packageInternalName == null) {
    return false;
  }
  return packageInternalName.startsWith(this.packageInternalName);
}
Program: 53521
Project: 53521
Buggy source:
public boolean match(final String superClassInternalName){
  if (superClassInternalName != null) {
    return this.superClassInternalName.equals(superClassInternalName);
  }
  return false;
}

Fixed version (ground truth):
public boolean match(final String superClassInternalName){
  if (superClassInternalName == null) {
    return false;
  }
  return this.superClassInternalName.equals(superClassInternalName);
}
Program: 53522
Project: 53522
Buggy source:
public AndMatcherOperator(final MatcherOperand leftOperand,final MatcherOperand rightOperand){
  Assert.requireNonNull(leftOperand,"String_Node_Str");
  this.leftOperand=leftOperand;
  Assert.requireNonNull(rightOperand,"String_Node_Str");
  this.rightOperand=rightOperand;
}

Fixed version (ground truth):
public AndMatcherOperator(final MatcherOperand leftOperand,final MatcherOperand rightOperand){
  this.leftOperand=Assert.requireNonNull(leftOperand,"String_Node_Str");
  this.rightOperand=Assert.requireNonNull(rightOperand,"String_Node_Str");
}
Program: 53523
Project: 53523
Buggy source:
public NotMatcherOperator(final MatcherOperand rightOperand){
  Assert.requireNonNull(rightOperand,"String_Node_Str");
  this.rightOperand=rightOperand;
}

Fixed version (ground truth):
public NotMatcherOperator(final MatcherOperand rightOperand){
  this.rightOperand=Assert.requireNonNull(rightOperand,"String_Node_Str");
}
Program: 53524
Project: 53524
Buggy source:
public OrMatcherOperator(final MatcherOperand leftOperand,final MatcherOperand rightOperand){
  Assert.requireNonNull(leftOperand,"String_Node_Str");
  this.leftOperand=leftOperand;
  Assert.requireNonNull(rightOperand,"String_Node_Str");
  this.rightOperand=rightOperand;
}

Fixed version (ground truth):
public OrMatcherOperator(final MatcherOperand leftOperand,final MatcherOperand rightOperand){
  this.leftOperand=Assert.requireNonNull(leftOperand,"String_Node_Str");
  this.rightOperand=Assert.requireNonNull(rightOperand,"String_Node_Str");
}
Program: 53525
Project: 53525
Buggy source:
@Override public Span postProcess(Span span,List<SpanEvent> spanEventList){
  span.finish();
  final long spanStartTime=span.getStartTime();
  spanEventCompressor.compress(spanEventList,spanStartTime);
  span.setSpanEventList((List)spanEventList);
  return span;
}

Fixed version (ground truth):
@Override public Span postProcess(Span span,List<SpanEvent> spanEventList){
  span.finish();
  if (CollectionUtils.hasLength(spanEventList)) {
    final long spanStartTime=span.getStartTime();
    spanEventCompressor.compress(spanEventList,spanStartTime);
    span.setSpanEventList((List)spanEventList);
  }
  return span;
}
Program: 53526
Project: 53526
Buggy source:
@Override public Span postProcess(Span span,List<SpanEvent> spanEventList){
  span.setVersion(V2.getVersion());
  span.finish();
  long spanStartTime=span.getStartTime();
  spanEventCompressor.compress(spanEventList,spanStartTime);
  span.setSpanEventList((List)spanEventList);
  return span;
}

Fixed version (ground truth):
@Override public Span postProcess(Span span,List<SpanEvent> spanEventList){
  span.setVersion(V2.getVersion());
  span.finish();
  if (CollectionUtils.hasLength(spanEventList)) {
    long spanStartTime=span.getStartTime();
    spanEventCompressor.compress(spanEventList,spanStartTime);
    span.setSpanEventList((List)spanEventList);
  }
  return span;
}
Program: 53527
Project: 53527
Buggy source:
@Override public void store(Span span){
  final List<SpanEvent> storage=clearBuffer();
  if (CollectionUtils.hasLength(storage)) {
    span=spanPostProcessor.postProcess(span,storage);
  }
  dataSender.send(span);
  if (isDebug) {
    logger.debug("String_Node_Str",span);
  }
}

Fixed version (ground truth):
@Override public void store(Span span){
  final List<SpanEvent> storage=clearBuffer();
  span=spanPostProcessor.postProcess(span,storage);
  dataSender.send(span);
  if (isDebug) {
    logger.debug("String_Node_Str",span);
  }
}
Program: 53528
Project: 53528
Buggy source:
@Override public byte[] doInTransform(Instrumentor instrumentor,ClassLoader loader,String className,Class<?> classBeingRedefined,ProtectionDomain protectionDomain,byte[] classfileBuffer) throws InstrumentException {
  InstrumentClass target=instrumentor.getInstrumentClass(loader,className,classfileBuffer);
  final InstrumentMethod addListenerMethod1=InstrumentUtils.findMethod(target,"String_Node_Str","String_Node_Str");
  if (addListenerMethod1 != null) {
    addListenerMethod1.addScopedInterceptor(NettyConstants.INTERCEPTOR_CHANNEL_PROMISE_ADD_LISTENER,NettyConstants.SCOPE,ExecutionPolicy.BOUNDARY);
  }
  final InstrumentMethod addListenerMethod2=InstrumentUtils.findMethod(target,"String_Node_Str","String_Node_Str");
  if (addListenerMethod2 != null) {
    addListenerMethod1.addScopedInterceptor(NettyConstants.INTERCEPTOR_CHANNEL_PROMISE_ADD_LISTENER,NettyConstants.SCOPE,ExecutionPolicy.BOUNDARY);
  }
  return target.toBytecode();
}

Fixed version (ground truth):
@Override public byte[] doInTransform(Instrumentor instrumentor,ClassLoader loader,String className,Class<?> classBeingRedefined,ProtectionDomain protectionDomain,byte[] classfileBuffer) throws InstrumentException {
  InstrumentClass target=instrumentor.getInstrumentClass(loader,className,classfileBuffer);
  final InstrumentMethod addListenerMethod1=InstrumentUtils.findMethod(target,"String_Node_Str","String_Node_Str");
  if (addListenerMethod1 != null) {
    addListenerMethod1.addScopedInterceptor(NettyConstants.INTERCEPTOR_CHANNEL_PROMISE_ADD_LISTENER,NettyConstants.SCOPE,ExecutionPolicy.BOUNDARY);
  }
  final InstrumentMethod addListenerMethod2=InstrumentUtils.findMethod(target,"String_Node_Str","String_Node_Str");
  if (addListenerMethod2 != null) {
    addListenerMethod2.addScopedInterceptor(NettyConstants.INTERCEPTOR_CHANNEL_PROMISE_ADD_LISTENER,NettyConstants.SCOPE,ExecutionPolicy.BOUNDARY);
  }
  return target.toBytecode();
}
Program: 53529
Project: 53529
Buggy source:
@Override public void before(Object target,Object[] args){
  if ((target instanceof DataSourceMonitorAccessor)) {
    DbcpDataSourceMonitor dataSourceMonitor=((DataSourceMonitorAccessor)target)._$PINPOINT$_getDataSourceMonitor();
    if (dataSourceMonitor != null) {
      ((DataSourceMonitorAccessor)target)._$PINPOINT$_setDataSourceMonitor(null);
      dataSourceMonitor.close();
      dataSourceMonitorRegistry.unregister(dataSourceMonitor);
    }
  }
}

Fixed version (ground truth):
@Override public void before(Object target,Object[] args){
  if (target instanceof DataSourceMonitorAccessor) {
    final DataSourceMonitorAccessor dataSourceMonitorAccessor=(DataSourceMonitorAccessor)target;
    final DbcpDataSourceMonitor dataSourceMonitor=dataSourceMonitorAccessor._$PINPOINT$_getDataSourceMonitor();
    if (dataSourceMonitor != null) {
      dataSourceMonitorAccessor._$PINPOINT$_setDataSourceMonitor(null);
      dataSourceMonitor.close();
      dataSourceMonitorRegistry.unregister(dataSourceMonitor);
    }
  }
}
Program: 53530
Project: 53530
Buggy source:
public DataSourceCloseInterceptor(TraceContext traceContext,DataSourceMonitorRegistry dataSourceMonitorRegistry,MethodDescriptor methodDescriptor){
  this.traceContext=traceContext;
  this.dataSourceMonitorRegistry=dataSourceMonitorRegistry;
  this.methodDescriptor=methodDescriptor;
}

Fixed version (ground truth):
public DataSourceCloseInterceptor(DataSourceMonitorRegistry dataSourceMonitorRegistry){
  this.dataSourceMonitorRegistry=dataSourceMonitorRegistry;
}
Program: 53531
Project: 53531
Buggy source:
@Override public void after(Object target,Object[] args,Object result,Throwable throwable){
  if (!InterceptorUtils.isSuccess(throwable)) {
    return;
  }
  if ((target instanceof DataSourceMonitorAccessor) && (target instanceof BasicDataSource)) {
    DbcpDataSourceMonitor dataSourceMonitor=new DbcpDataSourceMonitor((BasicDataSource)target);
    dataSourceMonitorRegistry.register(dataSourceMonitor);
    ((DataSourceMonitorAccessor)target)._$PINPOINT$_setDataSourceMonitor(dataSourceMonitor);
  }
}

Fixed version (ground truth):
@Override public void after(Object target,Object[] args,Object result,Throwable throwable){
  if (!InterceptorUtils.isSuccess(throwable)) {
    return;
  }
  final BasicDataSource basicDataSource=getBasicDatasource(target);
  if (basicDataSource instanceof DataSourceMonitorAccessor) {
    DbcpDataSourceMonitor dataSourceMonitor=new DbcpDataSourceMonitor(basicDataSource);
    dataSourceMonitorRegistry.register(dataSourceMonitor);
    ((DataSourceMonitorAccessor)basicDataSource)._$PINPOINT$_setDataSourceMonitor(dataSourceMonitor);
  }
}