nus-yam/ex-repair huggingface dataset:
Program: 54374
Project: 54374
Buggy source:
public ReplCommandsBuilder(BundleConfig generalConfig){
  Injector replCommandsInjector=generalConfig.getEssentialInjector().createChildInjector(new ReplCommandsGuiceModule(),new ExtraModule(generalConfig));
  replCommandsLibrary=replCommandsInjector.getInstance(ReplCommandLibrary.class);
  replCommandsExecutor=replCommandsInjector.getInstance(ReplCommandsExecutor.class);
}

Fixed version (ground truth):
public ReplCommandsBuilder(BundleConfig generalConfig){
  Injector replCommandsInjector=generalConfig.getEssentialInjector().createChildInjector(new ReplCommandsGuiceModule(),new ExtraModule(generalConfig));
  replCommandsLibrary=replCommandsInjector.getInstance(ReplCommandLibrary.class);
  replCommandsExecutor=replCommandsInjector.getInstance(ReplCommandExecutor.class);
}
Program: 54375
Project: 54375
Buggy source:
public ReplCommandsExecutor getReplCommandsExecutor(){
  return replCommandsExecutor;
}

Fixed version (ground truth):
public ReplCommandExecutor getReplCommandsExecutor(){
  return replCommandsExecutor;
}
Program: 54376
Project: 54376
Buggy source:
@Override protected void configure(){
  requireBinding(Key.get(Supervisor.class,MongoDbRepl.class));
  requireBinding(ReplicationFilters.class);
  expose(ReplCommandLibrary.class);
  expose(ReplCommandsExecutor.class);
  bind(ReplCommandLibrary.class).in(Singleton.class);
  bind(ReplCommandsExecutor.class).in(Singleton.class);
  bindImplementations();
}

Fixed version (ground truth):
@Override protected void configure(){
  requireBinding(Key.get(Supervisor.class,MongoDbRepl.class));
  requireBinding(ReplicationFilters.class);
  expose(ReplCommandLibrary.class);
  expose(ReplCommandExecutor.class);
  bind(ReplCommandLibrary.class).in(Singleton.class);
  bind(ReplCommandExecutor.class).in(Singleton.class);
  bindImplementations();
}
Program: 54377
Project: 54377
Buggy source:
public ReplCommandsExecutor getReplCommandsExecutor(){
  return replCommandsExecutor;
}

Fixed version (ground truth):
public ReplCommandExecutor getReplCommandsExecutor(){
  return replCommandsExecutor;
}
Program: 54378
Project: 54378
Buggy source:
public DefaultOplogApplierBundleConfig(ReplCoreBundle replCoreBundle,MongoDbCoreBundle mongoDbCorebundle,ReplCommandLibrary replCommandsLibrary,ReplCommandsExecutor replCommandsExecutor,BundleConfig delegate){
  this.replCoreBundle=replCoreBundle;
  this.mongoDbCorebundle=mongoDbCorebundle;
  this.replCommandsLibrary=replCommandsLibrary;
  this.replCommandsExecutor=replCommandsExecutor;
  this.delegate=delegate;
}

Fixed version (ground truth):
public DefaultOplogApplierBundleConfig(ReplCoreBundle replCoreBundle,MongoDbCoreBundle mongoDbCorebundle,ReplCommandLibrary replCommandsLibrary,ReplCommandExecutor replCommandsExecutor,BundleConfig delegate){
  this.replCoreBundle=replCoreBundle;
  this.mongoDbCorebundle=mongoDbCorebundle;
  this.replCommandsLibrary=replCommandsLibrary;
  this.replCommandsExecutor=replCommandsExecutor;
  this.delegate=delegate;
}
Program: 54379
Project: 54379
Buggy source:
private void bindConfig(){
  bind(ReplCommandLibrary.class).toInstance(config.getReplCommandsLibrary());
  bind(ReplCommandsExecutor.class).toInstance(config.getReplCommandsExecutor());
  bind(OplogManager.class).toInstance(config.getReplCoreBundle().getExternalInterface().getOplogManager());
  bind(MongodServer.class).toInstance(config.getMongoDbCoreBundle().getExternalInterface().getMongodServer());
}

Fixed version (ground truth):
private void bindConfig(){
  bind(ReplCommandLibrary.class).toInstance(config.getReplCommandsLibrary());
  bind(ReplCommandExecutor.class).toInstance(config.getReplCommandsExecutor());
  bind(OplogManager.class).toInstance(config.getReplCoreBundle().getExternalInterface().getOplogManager());
  bind(MongodServer.class).toInstance(config.getMongoDbCoreBundle().getExternalInterface().getMongodServer());
}
Program: 54380
Project: 54380
Buggy source:
@Inject public OplogOperationApplier(ReplCommandLibrary library,ReplCommandsExecutor executor){
  this.library=library;
  this.executor=executor;
}

Fixed version (ground truth):
@Inject public OplogOperationApplier(ReplCommandLibrary library,ReplCommandExecutor executor){
  this.library=library;
  this.executor=executor;
}
Program: 54381
Project: 54381
Buggy source:
protected Injector createFinalInjector(BackendBundle backendBundle){
  ToroDbRuntimeModule runtimeModule=new ToroDbRuntimeModule(backendBundle,this);
  return bootstrapInjector.createChildInjector(runtimeModule,new MongoDbWpModule(27018));
}

Fixed version (ground truth):
protected Injector createFinalInjector(BackendBundle backendBundle){
  int port=bootstrapInjector.getInstance(Config.class).getProtocol().getMongo().getNet().getPort();
  ToroDbRuntimeModule runtimeModule=new ToroDbRuntimeModule(backendBundle,this);
  return bootstrapInjector.createChildInjector(runtimeModule,new MongoDbWpModule(port));
}
Program: 54382
Project: 54382
Buggy source:
@Override protected void configure(){
  bind(NettyMongoServer.class).in(Singleton.class);
  expose(NettyMongoServer.class);
  bind(MongoServerConfig.class).toInstance((MongoServerConfig)() -> port);
  expose(MongoServerConfig.class);
  bind(NettyStringReader.class).to(PooledNettyStringReader.class).in(Singleton.class);
  configureStringPool();
  bind(RequestIdGenerator.class).to(DefaultRequestIdGenerator.class);
  bind(ErrorHandler.class).to(ToroErrorHandler.class).in(Singleton.class);
  bind(RequestMessageByteHandler.class).in(Singleton.class);
  bindMessageDecoder();
  bind(DefaultNettyBsonLowLevelReader.class).in(Singleton.class);
  bind(NettyBsonDocumentReader.class).in(Singleton.class);
  bind(OffHeapNettyBsonLowLevelReader.class).in(Singleton.class);
  bind(OffHeapValuesNettyBsonLowLevelReader.class).to(OffHeapNettyBsonLowLevelReader.class);
  bind(RequestMessageObjectHandler.class).in(Singleton.class);
  bind(ReplyMessageObjectHandler.class).in(Singleton.class);
  bind(TorodbSafeRequestProcessor.class).in(Singleton.class);
  bind(ReplyMessageEncoder.class).in(Singleton.class);
  bind(MongodMetrics.class).in(Singleton.class);
  bind(NettyBsonDocumentWriter.class).in(Singleton.class);
}

Fixed version (ground truth):
@Override protected void configure(){
  bind(NettyMongoServer.class).in(Singleton.class);
  expose(NettyMongoServer.class);
  bind(MongoServerConfig.class).toInstance((MongoServerConfig)() -> port);
  expose(MongoServerConfig.class);
  bind(NettyStringReader.class).to(PooledNettyStringReader.class).in(Singleton.class);
  configureStringPool();
  bind(RequestIdGenerator.class).to(DefaultRequestIdGenerator.class);
  bind(ErrorHandler.class).to(ToroErrorHandler.class).in(Singleton.class);
  bind(RequestMessageByteHandler.class);
  bindMessageDecoder();
  bind(DefaultNettyBsonLowLevelReader.class).in(Singleton.class);
  bind(NettyBsonDocumentReader.class).in(Singleton.class);
  bind(OffHeapNettyBsonLowLevelReader.class).in(Singleton.class);
  bind(OffHeapValuesNettyBsonLowLevelReader.class).to(OffHeapNettyBsonLowLevelReader.class);
  bind(RequestMessageObjectHandler.class).in(Singleton.class);
  bind(ReplyMessageObjectHandler.class);
  bind(TorodbSafeRequestProcessor.class).in(Singleton.class);
  bind(ReplyMessageEncoder.class).in(Singleton.class);
  bind(MongodMetrics.class).in(Singleton.class);
  bind(NettyBsonDocumentWriter.class).in(Singleton.class);
}
Program: 54383
Project: 54383
Buggy source:
public void setUpValues(@Nonnull Instant now,@Nonnull HostAndPort host,@Nonnull ReplSetHeartbeatReply hbResponse){
  health=Health.UP;
  if (upSince.equals(Instant.EPOCH)) {
    upSince=now;
  }
  authIssue=false;
  lastHeartbeat=now;
  ReplSetHeartbeatReplyBuilder lastResponseBuilder=new ReplSetHeartbeatReplyBuilder(hbResponse);
  if (!hbResponse.getState().isPresent()) {
    lastResponseBuilder.setState(MemberState.RS_UNKNOWN);
  }
  lastResponseBuilder.setElectionTime(lastResponse.getElectionTime());
  lastResponseBuilder.setAppliedOpTime(lastResponse.getAppliedOpTime());
  if (!lastResponse.getState().get().equals(hbResponse.getState().get())) {
    LOGGER.info("String_Node_Str",host,hbResponse.getState().get());
  }
  lastResponse=lastResponseBuilder.build();
}

Fixed version (ground truth):
public void setUpValues(@Nonnull Instant now,@Nonnull HostAndPort host,@Nonnull ReplSetHeartbeatReply hbResponse){
  health=Health.UP;
  if (upSince.equals(Instant.EPOCH)) {
    upSince=now;
  }
  authIssue=false;
  lastHeartbeat=now;
  ReplSetHeartbeatReplyBuilder lastResponseBuilder=new ReplSetHeartbeatReplyBuilder(hbResponse,lastResponse);
  if (!lastResponse.getState().get().equals(hbResponse.getState().get())) {
    LOGGER.info("String_Node_Str",host,hbResponse.getState().get());
  }
  lastResponse=lastResponseBuilder.build();
}
Program: 54384
Project: 54384
Buggy source:
@Override public Optional<Duration> getTime(){
  return time;
}

Fixed version (ground truth):
@Override public Optional<Duration> getTime(){
  return Optional.ofNullable(time);
}
Program: 54385
Project: 54385
Buggy source:
@Override public Optional<Boolean> getIsReplSet(){
  return isReplSet;
}

Fixed version (ground truth):
@Override public Optional<Boolean> getIsReplSet(){
  return Optional.ofNullable(isReplSet);
}
Program: 54386
Project: 54386
Buggy source:
@Override public Optional<OpTime> getAppliedOpTime(){
  return appliedOptime;
}

Fixed version (ground truth):
@Override public Optional<OpTime> getAppliedOpTime(){
  return Optional.ofNullable(appliedOptime);
}
Program: 54387
Project: 54387
Buggy source:
@Override public Optional<String> getSetName(){
  return setName;
}

Fixed version (ground truth):
@Override public Optional<String> getSetName(){
  return Optional.ofNullable(setName);
}
Program: 54388
Project: 54388
Buggy source:
@Override public Optional<ReplicaSetConfig> getConfig(){
  return config;
}

Fixed version (ground truth):
@Override public Optional<ReplicaSetConfig> getConfig(){
  return Optional.ofNullable(config);
}
Program: 54389
Project: 54389
Buggy source:
@Override public Optional<Boolean> getElectable(){
  return electable;
}

Fixed version (ground truth):
@Override public Optional<Boolean> getElectable(){
  return Optional.ofNullable(electable);
}
Program: 54390
Project: 54390
Buggy source:
@Override public Optional<OpTime> getDurableOptime(){
  return durableOptime;
}

Fixed version (ground truth):
@Override public Optional<OpTime> getDurableOptime(){
  return Optional.ofNullable(durableOptime);
}
Program: 54391
Project: 54391
Buggy source:
@Override public Optional<MemberState> getState(){
  return state;
}

Fixed version (ground truth):
@Override public Optional<MemberState> getState(){
  return Optional.ofNullable(state);
}
Program: 54392
Project: 54392
Buggy source:
@Override public Optional<BsonTimestamp> getElectionTime(){
  return electionTime;
}

Fixed version (ground truth):
@Override public Optional<BsonTimestamp> getElectionTime(){
  return Optional.ofNullable(electionTime);
}
Program: 54393
Project: 54393
Buggy source:
public CorrectReplSetHeartbeatReply(Optional<BsonTimestamp> electionTime,Optional<Duration> time,Optional<OpTime> appliedOptime,Optional<OpTime> durableOptime,Optional<Boolean> electable,Optional<Boolean> hasData,boolean mismatch,Optional<Boolean> isReplSet,boolean stateDisagreement,Optional<MemberState> state,long configVersion,Optional<String> setName,String hbmsg,Optional<HostAndPort> syncingTo,Optional<ReplicaSetConfig> config,OptionalInt primaryId,long term){
  this.electionTime=electionTime;
  this.time=time;
  this.appliedOptime=appliedOptime;
  this.durableOptime=durableOptime;
  this.electable=electable;
  this.hasData=hasData;
  this.mismatch=mismatch;
  this.isReplSet=isReplSet;
  this.stateDisagreement=stateDisagreement;
  this.state=state;
  this.configVersion=configVersion;
  this.setName=setName;
  this.hbmsg=hbmsg;
  this.syncingTo=syncingTo;
  this.config=config;
  this.primaryId=primaryId;
  this.term=term;
}

Fixed version (ground truth):
public CorrectReplSetHeartbeatReply(BsonTimestamp electionTime,Duration time,OpTime appliedOptime,OpTime durableOptime,Boolean electable,Boolean hasData,boolean mismatch,Boolean isReplSet,boolean stateDisagreement,MemberState state,long configVersion,String setName,String hbmsg,HostAndPort syncingTo,ReplicaSetConfig config,OptionalInt primaryId,long term){
  this.electionTime=electionTime;
  this.time=time;
  this.appliedOptime=appliedOptime;
  this.durableOptime=durableOptime;
  this.electable=electable;
  this.hasData=hasData;
  this.mismatch=mismatch;
  this.isReplSet=isReplSet;
  this.stateDisagreement=stateDisagreement;
  this.state=state;
  this.configVersion=configVersion;
  this.setName=setName;
  this.hbmsg=hbmsg;
  this.syncingTo=syncingTo;
  this.config=config;
  this.primaryId=primaryId;
  this.term=term;
}
Program: 54394
Project: 54394
Buggy source:
@Override public Optional<HostAndPort> getSyncingTo(){
  return syncingTo;
}

Fixed version (ground truth):
@Override public Optional<HostAndPort> getSyncingTo(){
  return Optional.ofNullable(syncingTo);
}
Program: 54395
Project: 54395
Buggy source:
@Override public Optional<Boolean> getHasData(){
  return hasData;
}

Fixed version (ground truth):
@Override public Optional<Boolean> getHasData(){
  return Optional.ofNullable(hasData);
}
Program: 54396
Project: 54396
Buggy source:
public ReplSetHeartbeatReplyBuilder setHasData(@Nullable Boolean hasData){
  this.hasData=Optional.ofNullable(hasData);
  return this;
}

Fixed version (ground truth):
public ReplSetHeartbeatReplyBuilder setHasData(@Nullable Boolean hasData){
  this.hasData=hasData;
  return this;
}
Program: 54397
Project: 54397
Buggy source:
public ReplSetHeartbeatReplyBuilder setSyncingTo(@Nullable HostAndPort syncingTo){
  this.syncingTo=Optional.ofNullable(syncingTo);
  return this;
}

Fixed version (ground truth):
public ReplSetHeartbeatReplyBuilder setSyncingTo(@Nullable HostAndPort syncingTo){
  this.syncingTo=syncingTo;
  return this;
}
Program: 54398
Project: 54398
Buggy source:
public ReplSetHeartbeatReplyBuilder setSetName(Optional<String> setName){
  this.setName=setName;
  return this;
}

Fixed version (ground truth):
public ReplSetHeartbeatReplyBuilder setSetName(Optional<String> setName){
  this.setName=setName.orElse(null);
  return this;
}
Program: 54399
Project: 54399
Buggy source:
public ReplSetHeartbeatReplyBuilder setIsReplSet(boolean isReplSet){
  this.isReplSet=Optional.of(isReplSet);
  return this;
}

Fixed version (ground truth):
public ReplSetHeartbeatReplyBuilder setIsReplSet(boolean isReplSet){
  this.isReplSet=isReplSet;
  return this;
}
Program: 54400
Project: 54400
Buggy source:
Optional<OpTime> getAppliedOpTime(){
  return appliedOpTime;
}

Fixed version (ground truth):
Optional<OpTime> getAppliedOpTime(){
  return Optional.ofNullable(appliedOpTime);
}
Program: 54401
Project: 54401
Buggy source:
public ReplSetHeartbeatReplyBuilder setDurableOpTime(@Nullable OpTime durableOpTime){
  this.durableOpTime=Optional.ofNullable(durableOpTime);
  return this;
}

Fixed version (ground truth):
public ReplSetHeartbeatReplyBuilder setDurableOpTime(@Nullable OpTime durableOpTime){
  this.durableOpTime=durableOpTime;
  return this;
}
Program: 54402
Project: 54402
Buggy source:
public ReplSetHeartbeatReplyBuilder setConfig(@Nullable ReplicaSetConfig config){
  this.config=Optional.ofNullable(config);
  return this;
}

Fixed version (ground truth):
public ReplSetHeartbeatReplyBuilder setConfig(@Nullable ReplicaSetConfig config){
  this.config=config;
  return this;
}
Program: 54403
Project: 54403
Buggy source:
public ReplSetHeartbeatReplyBuilder setElectable(boolean electable){
  this.electable=Optional.of(electable);
  return this;
}

Fixed version (ground truth):
public ReplSetHeartbeatReplyBuilder setElectable(boolean electable){
  this.electable=electable;
  return this;
}
Program: 54404
Project: 54404
Buggy source:
public ReplSetHeartbeatReplyBuilder(ReplSetHeartbeatReply other){
  this.electionTime=other.getElectionTime();
  this.time=other.getTime();
  this.appliedOpTime=other.getAppliedOpTime();
  this.electable=other.getElectable();
  this.hasData=other.getHasData();
  this.mismatch=other.isMismatch();
  this.isReplSet=other.getIsReplSet();
  this.stateDisagreement=other.isStateDisagreement();
  this.state=other.getState();
  this.configVersion=other.getConfigVersion();
  this.setName=other.getSetName();
  this.hbmsg=other.getHbmsg();
  this.syncingTo=other.getSyncingTo();
  this.config=other.getConfig();
  this.primaryId=other.getPrimaryId();
  this.term=other.getTerm();
}

Fixed version (ground truth):
public ReplSetHeartbeatReplyBuilder(ReplSetHeartbeatReply other,ReplSetHeartbeatReply lastResponse){
  this.electionTime=other.getElectionTime().orElseGet(() -> lastResponse.getElectionTime().orElse(null));
  this.time=other.getTime().orElse(null);
  this.appliedOpTime=other.getAppliedOpTime().orElseGet(() -> lastResponse.getAppliedOpTime().orElse(null));
  this.electable=other.getElectable().orElse(null);
  this.hasData=other.getHasData().orElse(null);
  this.mismatch=other.isMismatch();
  this.isReplSet=other.getIsReplSet().orElse(null);
  this.stateDisagreement=other.isStateDisagreement();
  this.state=other.getState().orElseGet(() -> lastResponse.getState().orElse(null));
  this.configVersion=other.getConfigVersion();
  this.setName=other.getSetName().orElse(null);
  this.hbmsg=other.getHbmsg();
  this.syncingTo=other.getSyncingTo().orElse(null);
  this.config=other.getConfig().orElse(null);
  this.primaryId=other.getPrimaryId();
  this.term=other.getTerm();
}
Program: 54405
Project: 54405
Buggy source:
public ReplSetHeartbeatReplyBuilder setState(@Nullable MemberState state){
  this.state=Optional.ofNullable(state);
  return this;
}

Fixed version (ground truth):
public ReplSetHeartbeatReplyBuilder setState(@Nullable MemberState state){
  this.state=state;
  return this;
}
Program: 54406
Project: 54406
Buggy source:
public ReplSetHeartbeatReplyBuilder setElectionTime(Optional<BsonTimestamp> electionTime){
  this.electionTime=electionTime;
  return this;
}

Fixed version (ground truth):
public ReplSetHeartbeatReplyBuilder setElectionTime(Optional<BsonTimestamp> electionTime){
  this.electionTime=electionTime.orElse(null);
  return this;
}
Program: 54407
Project: 54407
Buggy source:
public ReplSetHeartbeatReplyBuilder setTime(@Nullable Duration time){
  this.time=Optional.ofNullable(time);
  return this;
}

Fixed version (ground truth):
public ReplSetHeartbeatReplyBuilder setTime(@Nullable Duration time){
  this.time=time;
  return this;
}
Program: 54408
Project: 54408
Buggy source:
public ReplSetHeartbeatReplyBuilder setAppliedOpTime(Optional<OpTime> appliedOpTime){
  this.appliedOpTime=appliedOpTime;
  return this;
}

Fixed version (ground truth):
public ReplSetHeartbeatReplyBuilder setAppliedOpTime(Optional<OpTime> appliedOpTime){
  this.appliedOpTime=appliedOpTime.orElse(null);
  return this;
}
Program: 54409
Project: 54409
Buggy source:
@Override public boolean reciveHeartbeatError(Throwable t){
  SupervisorDecision decision=replSupervisor.onError(this,t);
  return decision == SupervisorDecision.IGNORE;
}

Fixed version (ground truth):
@Override public boolean reciveHeartbeatError(Throwable t){
  return true;
}
Program: 54410
Project: 54410
Buggy source:
@Override public boolean sendHeartbeatError(Throwable t){
  SupervisorDecision decision=replSupervisor.onError(this,t);
  return decision == SupervisorDecision.IGNORE;
}

Fixed version (ground truth):
@Override public boolean sendHeartbeatError(Throwable t){
  return true;
}
Program: 54411
Project: 54411
Buggy source:
@Inject public MongoClientHeartbeatNetworkHandler(MongoClientFactory mongoClientFactory,ConcurrentToolsFactory concurrentToolsFactory){
  this.mongoClientFactory=mongoClientFactory;
  executorService=concurrentToolsFactory.createExecutorServiceWithMaxThreads("String_Node_Str",1);
}

Fixed version (ground truth):
@Inject public MongoClientHeartbeatNetworkHandler(MongoClientFactory mongoClientFactory,ConcurrentToolsFactory concurrentToolsFactory){
  this.mongoClientFactory=mongoClientFactory;
  executorService=concurrentToolsFactory.createExecutorService("String_Node_Str",true);
}
Program: 54412
Project: 54412
Buggy source:
@GuardedBy("String_Node_Str") private void doHeartbeat(final TopologyCoordinator coord,final HostAndPort target){
  if (stopped) {
    LOGGER.trace("String_Node_Str" + "String_Node_Str",target);
    return;
  }
  RemoteCommandRequest<ReplSetHeartbeatArgument> request=coord.prepareHeartbeatRequest(clock.instant(),replSetName,target);
  CompletableFuture<RemoteCommandResponse<ReplSetHeartbeatReply>> hbHandle=networkHandler.sendHeartbeat(request).whenComplete((response,t) -> {
    if (t != null) {
      onRequestError(t,target);
    }
  }
);
  CompletableFuture<?> executeResponseFuture=executor.onCurrentVersion().andThenAcceptAsync(hbHandle,(coord2,response) -> handleHeartbeatResponse(coord2,target,request.getCmdObj(),response));
  executeResponseFuture.exceptionally(t -> {
    Throwable cause=CompletionExceptions.getFirstNonCompletionException(t);
    if (cause instanceof CancellationException) {
      LOGGER.trace("String_Node_Str" + "String_Node_Str",target,cause.getMessage());
    }
 else {
      LOGGER.debug("String_Node_Str" + target,t);
      if (errorHandler.reciveHeartbeatError(t)) {
        LOGGER.trace("String_Node_Str",target,POST_ERROR_HB_DELAY);
        scheduleHeartbeatToTarget(target,POST_ERROR_HB_DELAY);
      }
 else {
        stopAsync();
      }
    }
    return null;
  }
);
}

Fixed version (ground truth):
@GuardedBy("String_Node_Str") private void doHeartbeat(final TopologyCoordinator coord,final HostAndPort target){
  if (stopped) {
    LOGGER.trace("String_Node_Str" + "String_Node_Str",target);
    return;
  }
  RemoteCommandRequest<ReplSetHeartbeatArgument> request=coord.prepareHeartbeatRequest(clock.instant(),replSetName,target);
  CompletableFuture<RemoteCommandResponse<ReplSetHeartbeatReply>> hbHandle=networkHandler.sendHeartbeat(request);
  CompletableFuture<?> executeResponseFuture=executor.onCurrentVersion().andThenAcceptAsync(hbHandle,(coord2,response) -> handleHeartbeatResponse(coord2,target,request.getCmdObj(),response));
  executeResponseFuture.exceptionally(t -> {
    onNetworkError(t,target);
    return null;
  }
);
}
Program: 54413
Project: 54413
Buggy source:
private boolean checkHeartbeatStarted(Status<?> status,Throwable t){
  if (t == null) {
    if (status.isOk()) {
      LOGGER.trace("String_Node_Str");
      return true;
    }
 else {
      LOGGER.debug("String_Node_Str",status);
switch (status.getErrorCode()) {
case NO_REPLICATION_ENABLED:
        LOGGER.warn("String_Node_Str" + "String_Node_Str",seed);
      break;
case INCONSISTENT_REPLICA_SET_NAMES:
default :
    LOGGER.warn(status.getErrorMsg());
  break;
}
return false;
}
}
 else {
Throwable usefulThrowable=CompletionExceptions.getFirstNonCompletionException(t);
if (usefulThrowable instanceof UncheckedException) {
usefulThrowable=usefulThrowable.getCause() != null ? usefulThrowable.getCause() : usefulThrowable;
}
LOGGER.warn("String_Node_Str" + seed + "String_Node_Str"+ usefulThrowable.getLocalizedMessage(),usefulThrowable);
return false;
}
}

Fixed version (ground truth):
@GuardedBy("String_Node_Str") private boolean checkHeartbeatStarted(Status<?> status,Throwable t){
  if (t == null) {
    if (status.isOk()) {
      LOGGER.trace("String_Node_Str");
      return true;
    }
 else {
      LOGGER.debug("String_Node_Str",status);
switch (status.getErrorCode()) {
case NO_REPLICATION_ENABLED:
        LOGGER.warn("String_Node_Str" + "String_Node_Str",seed);
      break;
case INCONSISTENT_REPLICA_SET_NAMES:
default :
    LOGGER.warn(status.getErrorMsg());
  break;
}
return false;
}
}
 else {
Throwable usefulThrowable=CompletionExceptions.getFirstNonCompletionException(t);
if (usefulThrowable instanceof UncheckedException) {
usefulThrowable=usefulThrowable.getCause() != null ? usefulThrowable.getCause() : usefulThrowable;
}
LOGGER.warn("String_Node_Str" + seed + "String_Node_Str"+ usefulThrowable.getLocalizedMessage(),usefulThrowable);
return false;
}
}
Program: 54414
Project: 54414
Buggy source:
private CompletableFuture<?> scheduleHeartbeatToTarget(final HostAndPort target,Duration delay){
  LOGGER.trace("String_Node_Str",target,delay);
  return executor.onCurrentVersion().scheduleOnce((coord) -> doHeartbeat(coord,target),delay);
}

Fixed version (ground truth):
@GuardedBy("String_Node_Str") private CompletableFuture<?> scheduleHeartbeatToTarget(final HostAndPort target,Duration delay){
  LOGGER.trace("String_Node_Str",target,delay);
  return executor.onCurrentVersion().scheduleOnce((coord) -> doHeartbeat(coord,target),delay);
}
Program: 54415
Project: 54415
Buggy source:
private void updateConfig(TopologyCoordinator coord,ReplicaSetConfig config){
  validateConfig(coord,config);
  coord.updateConfig(config,clock.instant());
}

Fixed version (ground truth):
@GuardedBy("String_Node_Str") private void updateConfig(TopologyCoordinator coord,ReplicaSetConfig config){
  validateConfig(coord,config);
  coord.updateConfig(config,clock.instant());
}
Program: 54416
Project: 54416
Buggy source:
@Setup(Level.Trial) public void startup(){
  if (torod == null) {
    Config config=new Config();
    config.getBackend().as(Postgres.class).setPassword("String_Node_Str");
    TestService testService=ToroDbStandaloneTestUtil.createInjectors(config,Clock.systemDefaultZone());
    torod=testService.getInjector().getInstance(TorodServer.class);
    torod.startAsync();
    torod.awaitRunning();
  }
}

Fixed version (ground truth):
@Setup(Level.Trial) public void startup(){
  if (torod == null) {
    Config config=new Config();
    config.getBackend().as(AbstractPostgres.class).setPassword("String_Node_Str");
    TestService testService=ToroDbStandaloneTestUtil.createInjectors(config,Clock.systemDefaultZone());
    torod=testService.getInjector().getInstance(TorodServer.class);
    torod.startAsync();
    torod.awaitRunning();
  }
}
Program: 54417
Project: 54417
Buggy source:
@Override public boolean isValid(Derby value,ConstraintValidatorContext context){
  if (value != null && value.getInMemory() != null && value.getEmbedded() != null) {
    return !value.getInMemory() || value.getEmbedded();
  }
  return true;
}

Fixed version (ground truth):
@Override public boolean isValid(AbstractDerby value,ConstraintValidatorContext context){
  if (value != null && value.getInMemory() != null && value.getEmbedded() != null) {
    return !value.getInMemory() || value.getEmbedded();
  }
  return true;
}
Program: 54418
Project: 54418
Buggy source:
@Override public boolean isValid(List<Replication> value,ConstraintValidatorContext context){
  if (value != null) {
    Set<String> replNameSet=new HashSet<>();
    for (    Replication replication : value) {
      if (!replNameSet.add(replication.getReplSetName())) {
        return false;
      }
    }
  }
  return true;
}

Fixed version (ground truth):
@Override public boolean isValid(List<AbstractReplication> value,ConstraintValidatorContext context){
  if (value != null) {
    Set<String> replNameSet=new HashSet<>();
    for (    AbstractReplication replication : value) {
      if (!replNameSet.add(replication.getReplSetName())) {
        return false;
      }
    }
  }
  return true;
}
Program: 54419
Project: 54419
Buggy source:
@Override public boolean isValid(List<Replication> value,ConstraintValidatorContext context){
  if (value != null) {
    for (    Replication replication : value) {
      if (replication.getAuth().getMode() == AuthMode.x509) {
        SSL ssl=replication.getSsl();
        if (!ssl.getEnabled() || ssl.getKeyStoreFile() == null || ssl.getKeyPassword() == null) {
          return false;
        }
      }
    }
  }
  return true;
}

Fixed version (ground truth):
@Override public boolean isValid(List<AbstractReplication> value,ConstraintValidatorContext context){
  if (value != null) {
    for (    AbstractReplication replication : value) {
      if (replication.getAuth().getMode() == AuthMode.x509) {
        SSL ssl=replication.getSsl();
        if (!ssl.getEnabled() || ssl.getKeyStoreFile() == null || ssl.getKeyPassword() == null) {
          return false;
        }
      }
    }
  }
  return true;
}
Program: 54420
Project: 54420
Buggy source:
public void visit(Derby value);

Fixed version (ground truth):
public void visit(AbstractDerby value);
Program: 54421
Project: 54421
Buggy source:
@Inject public DerbyBackendConfigurationMapper(CursorConfig cursorConfig,ConnectionPoolConfig connectionPoolConfig,Derby derby){
  super(cursorConfig.getCursorTimeout(),connectionPoolConfig.getConnectionPoolTimeout(),connectionPoolConfig.getConnectionPoolSize(),connectionPoolConfig.getReservedReadPoolSize(),derby.getHost(),derby.getPort(),derby.getDatabase(),derby.getUser(),derby.getPassword(),derby.getIncludeForeignKeys());
  this.embedded=derby.getEmbedded();
  this.inMemory=derby.getInMemory();
}

Fixed version (ground truth):
@Inject public DerbyBackendConfigurationMapper(CursorConfig cursorConfig,ConnectionPoolConfig connectionPoolConfig,AbstractDerby derby){
  super(cursorConfig.getCursorTimeout(),connectionPoolConfig.getConnectionPoolTimeout(),connectionPoolConfig.getConnectionPoolSize(),connectionPoolConfig.getReservedReadPoolSize(),derby.getHost(),derby.getPort(),derby.getDatabase(),derby.getUser(),derby.getPassword(),derby.getIncludeForeignKeys());
  this.embedded=derby.getEmbedded();
  this.inMemory=derby.getInMemory();
}
Program: 54422
Project: 54422
Buggy source:
public BackendDerbyImplementationModule(){
  super(Derby.class,DerbyDbBackendConfiguration.class,DerbyBackendConfigurationMapper.class,() -> new DerbyBackendModule());
}

Fixed version (ground truth):
public BackendDerbyImplementationModule(){
  super(AbstractDerby.class,DerbyDbBackendConfiguration.class,DerbyBackendConfigurationMapper.class,() -> new DerbyBackendModule());
}
Program: 54423
Project: 54423
Buggy source:
public BackendPostgresImplementationModule(){
  super(Postgres.class,PostgreSQLBackendConfiguration.class,PostgresSQLDbBackendConfigurationMapper.class,() -> new PostgreSQLBackendModule());
}

Fixed version (ground truth):
public BackendPostgresImplementationModule(){
  super(AbstractPostgres.class,PostgreSQLBackendConfiguration.class,PostgresSQLDbBackendConfigurationMapper.class,() -> new PostgreSQLBackendModule());
}
Program: 54424
Project: 54424
Buggy source:
@Inject public PostgresSQLDbBackendConfigurationMapper(CursorConfig cursorConfig,ConnectionPoolConfig connectionPoolConfig,Postgres postgres){
  super(cursorConfig.getCursorTimeout(),connectionPoolConfig.getConnectionPoolTimeout(),connectionPoolConfig.getConnectionPoolSize(),connectionPoolConfig.getReservedReadPoolSize(),postgres.getHost(),postgres.getPort(),postgres.getDatabase(),postgres.getUser(),postgres.getPassword(),postgres.getIncludeForeignKeys());
}

Fixed version (ground truth):
@Inject public PostgresSQLDbBackendConfigurationMapper(CursorConfig cursorConfig,ConnectionPoolConfig connectionPoolConfig,AbstractPostgres postgres){
  super(cursorConfig.getCursorTimeout(),connectionPoolConfig.getConnectionPoolTimeout(),connectionPoolConfig.getConnectionPoolSize(),connectionPoolConfig.getReservedReadPoolSize(),postgres.getHost(),postgres.getPort(),postgres.getDatabase(),postgres.getUser(),postgres.getPassword(),postgres.getIncludeForeignKeys());
}
Program: 54426
Project: 54426
Buggy source:
public static ReplicationFilters getReplicationFilters(Replication replication){
  ReplicationFilters replicationFilters=new ReplicationFilters(convertFilterList(replication.getInclude()),convertFilterList(replication.getExclude()));
  return replicationFilters;
}

Fixed version (ground truth):
public static ReplicationFilters getReplicationFilters(AbstractReplication replication){
  ReplicationFilters replicationFilters=new ReplicationFilters(convertFilterList(replication.getInclude()),convertFilterList(replication.getExclude()));
  return replicationFilters;
}
Program: 54427
Project: 54427
Buggy source:
@Override protected void doStop(){
}

Fixed version (ground truth):
@Override protected void doStop(){
  notifyStopped();
}
Program: 54428
Project: 54428
Buggy source:
@Override protected void doStart(){
}

Fixed version (ground truth):
@Override protected void doStart(){
  notifyStarted();
}
Program: 54429
Project: 54429
Buggy source:
@Override protected void postDependenciesStartUp() throws Exception {
  LOGGER.info("String_Node_Str");
  mongodServer.startAsync();
  mongodServer.awaitRunning();
  topologyService.startAsync();
  oplogManager.startAsync();
  topologyService.awaitRunning();
  oplogManager.awaitRunning();
  dbCloner.startAsync();
  dbCloner.awaitRunning();
  replCoordinator.startAsync();
  replCoordinator.awaitRunning();
  LOGGER.info("String_Node_Str");
}

Fixed version (ground truth):
@Override protected void postDependenciesStartUp() throws Exception {
  LOGGER.info("String_Node_Str");
  mongodServer.startAsync();
  mongodServer.awaitRunning();
  topologyService.startAsync();
  oplogManager.startAsync();
  topologyService.awaitRunning();
  oplogManager.awaitRunning();
  dbCloner.startAsync();
  dbCloner.awaitRunning();
  aobe.startAsync();
  aobe.awaitRunning();
  replCoordinator.startAsync();
  replCoordinator.awaitRunning();
  LOGGER.info("String_Node_Str");
}
Program: 54430
Project: 54430
Buggy source:
@Override protected void preDependenciesShutDown() throws Exception {
  LOGGER.info("String_Node_Str");
  LOGGER.debug("String_Node_Str");
  try {
    replCoordinator.stopAsync();
    replCoordinator.awaitTerminated();
  }
 catch (  IllegalStateException ex) {
    Preconditions.checkState(!replCoordinator.isRunning(),"String_Node_Str",replCoordinator);
  }
  dbCloner.stopAsync();
  dbCloner.awaitTerminated();
  oplogManager.stopAsync();
  topologyService.stopAsync();
  try {
    oplogManager.awaitTerminated();
  }
 catch (  IllegalStateException ex) {
    Preconditions.checkState(!oplogManager.isRunning(),"String_Node_Str",replCoordinator);
  }
  try {
    topologyService.awaitTerminated();
  }
 catch (  IllegalStateException ex) {
    Preconditions.checkState(!topologyService.isRunning(),"String_Node_Str",replCoordinator);
  }
  LOGGER.debug("String_Node_Str");
  mongodServer.stopAsync();
  LOGGER.debug("String_Node_Str");
  cachedMongoClientFactory.invalidateAll();
  LOGGER.debug("String_Node_Str");
  try {
    mongodServer.awaitTerminated();
  }
 catch (  IllegalStateException ex) {
    Preconditions.checkState(!mongodServer.isRunning(),"String_Node_Str",replCoordinator);
  }
  LOGGER.info("String_Node_Str");
}

Fixed version (ground truth):
@Override protected void preDependenciesShutDown() throws Exception {
  LOGGER.info("String_Node_Str");
  LOGGER.debug("String_Node_Str");
  try {
    replCoordinator.stopAsync();
    replCoordinator.awaitTerminated();
  }
 catch (  IllegalStateException ex) {
    Preconditions.checkState(!replCoordinator.isRunning(),"String_Node_Str",replCoordinator);
  }
  aobe.stopAsync();
  aobe.awaitTerminated();
  dbCloner.stopAsync();
  dbCloner.awaitTerminated();
  oplogManager.stopAsync();
  topologyService.stopAsync();
  try {
    oplogManager.awaitTerminated();
  }
 catch (  IllegalStateException ex) {
    Preconditions.checkState(!oplogManager.isRunning(),"String_Node_Str",replCoordinator);
  }
  try {
    topologyService.awaitTerminated();
  }
 catch (  IllegalStateException ex) {
    Preconditions.checkState(!topologyService.isRunning(),"String_Node_Str",replCoordinator);
  }
  LOGGER.debug("String_Node_Str");
  mongodServer.stopAsync();
  LOGGER.debug("String_Node_Str");
  cachedMongoClientFactory.invalidateAll();
  LOGGER.debug("String_Node_Str");
  try {
    mongodServer.awaitTerminated();
  }
 catch (  IllegalStateException ex) {
    Preconditions.checkState(!mongodServer.isRunning(),"String_Node_Str",replCoordinator);
  }
  LOGGER.info("String_Node_Str");
}
Program: 54431
Project: 54431
Buggy source:
public MongodbReplBundle(TorodBundle torodBundle,Supervisor supervisor,MongodbReplConfig config,Injector injector){
  super(injector.getInstance(Key.get(ThreadFactory.class,TorodbIdleService.class)),supervisor);
  Supervisor replSupervisor=new ReplSupervisor(supervisor);
  Injector replInjector=injector.createChildInjector(new MongoDbReplModule(config,replSupervisor));
  this.torodBundle=torodBundle;
  this.topologyService=replInjector.getInstance(TopologyService.class);
  this.replCoordinator=replInjector.getInstance(ReplCoordinator.class);
  this.oplogManager=replInjector.getInstance(OplogManager.class);
  this.mongodServer=replInjector.getInstance(MongodServer.class);
  this.cachedMongoClientFactory=replInjector.getInstance(CachedMongoClientFactory.class);
  this.dbCloner=replInjector.getInstance(Key.get(DbCloner.class,MongoDbRepl.class));
}

Fixed version (ground truth):
public MongodbReplBundle(TorodBundle torodBundle,Supervisor supervisor,MongodbReplConfig config,Injector injector){
  super(injector.getInstance(Key.get(ThreadFactory.class,TorodbIdleService.class)),supervisor);
  Supervisor replSupervisor=new ReplSupervisor(supervisor);
  Injector replInjector=injector.createChildInjector(new MongoDbReplModule(config,replSupervisor));
  this.torodBundle=torodBundle;
  this.topologyService=replInjector.getInstance(TopologyService.class);
  this.replCoordinator=replInjector.getInstance(ReplCoordinator.class);
  this.oplogManager=replInjector.getInstance(OplogManager.class);
  this.mongodServer=replInjector.getInstance(MongodServer.class);
  this.cachedMongoClientFactory=replInjector.getInstance(CachedMongoClientFactory.class);
  this.dbCloner=replInjector.getInstance(Key.get(DbCloner.class,MongoDbRepl.class));
  this.aobe=replInjector.getInstance(AnalyzedOplogBatchExecutor.class);
}
Program: 54433
Project: 54433
Buggy source:
public OplogOperation apply(AnalyzedOplogBatch batch,ApplierContext replContext) throws RetrierGiveUpException, RetrierAbortException {
  return batch.accept(this,replContext);
}

Fixed version (ground truth):
public default OplogOperation apply(AnalyzedOplogBatch batch,ApplierContext replContext) throws RetrierGiveUpException, RetrierAbortException {
  return batch.accept(this,replContext);
}
Program: 54434
Project: 54434
Buggy source:
private void execute(NamespaceJob job,ApplierContext applierContext,MongodConnection connection,boolean optimisticDeleteAndCreate) throws RollbackException, UserException, NamespaceJobExecutionException, UniqueIndexViolationException {
  try (WriteMongodTransaction mongoTransaction=connection.openWriteTransaction()){
    namespaceJobExecutor.apply(job,mongoTransaction,applierContext,optimisticDeleteAndCreate);
    mongoTransaction.commit();
  }
 }

Fixed version (ground truth):
public void execute(CudAnalyzedOplogBatch cudBatch,ApplierContext context) throws RollbackException, UserException, NamespaceJobExecutionException ;
Program: 54435
Project: 54435
Buggy source:
@Inject public ConcurrentOplogBatchExecutor(OplogOperationApplier oplogOperationApplier,MongodServer server,Retrier retrier,ConcurrentToolsFactory concurrentToolsFactory,NamespaceJobExecutor namespaceJobExecutor,ConcurrentOplogBatchExecutorMetrics concurrentMetrics,SubBatchHeuristic subBatchHeuristic){
  super(concurrentMetrics,oplogOperationApplier,server,retrier,namespaceJobExecutor);
  this.streamExecutor=concurrentToolsFactory.createStreamExecutor("String_Node_Str",true);
  this.streamExecutor.startAsync();
  this.streamExecutor.awaitRunning();
  this.concurrentMetrics=concurrentMetrics;
  this.subBatchHeuristic=subBatchHeuristic;
}

Fixed version (ground truth):
@Inject public ConcurrentOplogBatchExecutor(OplogOperationApplier oplogOperationApplier,MongodServer server,Retrier retrier,ConcurrentToolsFactory concurrentToolsFactory,NamespaceJobExecutor namespaceJobExecutor,ConcurrentOplogBatchExecutorMetrics concurrentMetrics,SubBatchHeuristic subBatchHeuristic){
  super(concurrentMetrics,oplogOperationApplier,server,retrier,namespaceJobExecutor);
  this.streamExecutor=concurrentToolsFactory.createStreamExecutor("String_Node_Str",true);
  this.concurrentMetrics=concurrentMetrics;
  this.subBatchHeuristic=subBatchHeuristic;
}
Program: 54436
Project: 54436
Buggy source:
public Class<T[]> getArrayType(){
  return dataType.getArrayType();
}

Fixed version (ground truth):
@Override public Class<T[]> getArrayType(){
  return dataType.getArrayType();
}
Program: 54437
Project: 54437
Buggy source:
public SQLDialect getDialect(){
  return dataType.getDialect();
}

Fixed version (ground truth):
@Override public SQLDialect getDialect(){
  return dataType.getDialect();
}
Program: 54438
Project: 54438
Buggy source:
public boolean nullable(){
  return dataType.nullable();
}

Fixed version (ground truth):
@Override public boolean nullable(){
  return dataType.nullable();
}
Program: 54439
Project: 54439
Buggy source:
public Field<T> defaultValue(){
  return dataType.defaultValue();
}

Fixed version (ground truth):
@Override public Field<T> defaultValue(){
  return dataType.defaultValue();
}
Program: 54440
Project: 54440
Buggy source:
public DataType<T> getDataType(Configuration configuration){
  return dataType.getDataType(configuration);
}

Fixed version (ground truth):
@Override public DataType<T> getDataType(Configuration configuration){
  return dataType.getDataType(configuration);
}
Program: 54441
Project: 54441
Buggy source:
public int precision(){
  return dataType.precision();
}

Fixed version (ground truth):
@Override public int precision(){
  return dataType.precision();
}
Program: 54442
Project: 54442
Buggy source:
public boolean isLob(){
  return dataType.isLob();
}

Fixed version (ground truth):
@Override public boolean isLob(){
  return dataType.isLob();
}
Program: 54443
Project: 54443
Buggy source:
public int scale(){
  return dataType.scale();
}

Fixed version (ground truth):
@Override public int scale(){
  return dataType.scale();
}
Program: 54444
Project: 54444
Buggy source:
@SuppressWarnings({"String_Node_Str","String_Node_Str"}) public <E extends EnumType>DataType<E> asEnumDataType(Class<E> enumDataType){
  DataType<E> dataType=this.dataType.asEnumDataType(enumDataType);
  return new DataTypeForKV(dataType,kvValueConverter);
}

Fixed version (ground truth):
@Override @SuppressWarnings({"String_Node_Str","String_Node_Str"}) public <E extends EnumType>DataType<E> asEnumDataType(Class<E> enumDataType){
  DataType<E> dataType=this.dataType.asEnumDataType(enumDataType);
  return new DataTypeForKV(dataType,kvValueConverter);
}
Program: 54445
Project: 54445
Buggy source:
@SuppressWarnings({"String_Node_Str","String_Node_Str"}) public <U>DataType<U> asConvertedDataType(Binding<? super T,U> binding){
  DataType dataType=this.dataType.asConvertedDataType(binding);
  return new DataTypeForKV(dataType,kvValueConverter);
}

Fixed version (ground truth):
@Override @SuppressWarnings({"String_Node_Str","String_Node_Str"}) public <U>DataType<U> asConvertedDataType(Binding<? super T,U> binding){
  DataType dataType=this.dataType.asConvertedDataType(binding);
  return new DataTypeForKV(dataType,kvValueConverter);
}
Program: 54446
Project: 54446
Buggy source:
public List<T> convert(Collection<?> objects){
  return dataType.convert(objects);
}

Fixed version (ground truth):
@Override public List<T> convert(Collection<?> objects){
  return dataType.convert(objects);
}
Program: 54447
Project: 54447
Buggy source:
public Binding<?,T> getBinding(){
  return dataType.getBinding();
}

Fixed version (ground truth):
@Override public Binding<?,T> getBinding(){
  return dataType.getBinding();
}
Program: 54448
Project: 54448
Buggy source:
public boolean defaulted(){
  return dataType.defaulted();
}

Fixed version (ground truth):
@Override public boolean defaulted(){
  return dataType.defaulted();
}
Program: 54449
Project: 54449
Buggy source:
public boolean isTemporal(){
  return dataType.isTemporal();
}

Fixed version (ground truth):
@Override public boolean isTemporal(){
  return dataType.isTemporal();
}
Program: 54450
Project: 54450
Buggy source:
public boolean isString(){
  return dataType.isString();
}

Fixed version (ground truth):
@Override public boolean isString(){
  return dataType.isString();
}
Program: 54451
Project: 54451
Buggy source:
public String getTypeName(Configuration configuration){
  return dataType.getTypeName(configuration);
}

Fixed version (ground truth):
@Override public String getTypeName(Configuration configuration){
  return dataType.getTypeName(configuration);
}
Program: 54452
Project: 54452
Buggy source:
public boolean hasLength(){
  return dataType.hasLength();
}

Fixed version (ground truth):
@Override public boolean hasLength(){
  return dataType.hasLength();
}
Program: 54453
Project: 54453
Buggy source:
public DataType<T> getSQLDataType(){
  return dataType.getSQLDataType();
}

Fixed version (ground truth):
@Override public DataType<T> getSQLDataType(){
  return dataType.getSQLDataType();
}
Program: 54454
Project: 54454
Buggy source:
public boolean hasScale(){
  return dataType.hasScale();
}

Fixed version (ground truth):
@Override public boolean hasScale(){
  return dataType.hasScale();
}
Program: 54455
Project: 54455
Buggy source:
public DataType<T[]> getArrayDataType(){
  return dataType.getArrayDataType();
}

Fixed version (ground truth):
@Override public DataType<T[]> getArrayDataType(){
  return dataType.getArrayDataType();
}
Program: 54456
Project: 54456
Buggy source:
public int length(){
  return dataType.length();
}

Fixed version (ground truth):
@Override public int length(){
  return dataType.length();
}
Program: 54457
Project: 54457
Buggy source:
public boolean isBinary(){
  return dataType.isBinary();
}

Fixed version (ground truth):
@Override public boolean isBinary(){
  return dataType.isBinary();
}
Program: 54458
Project: 54458
Buggy source:
public String getCastTypeName(Configuration configuration){
  return dataType.getCastTypeName(configuration);
}

Fixed version (ground truth):
@Override public String getCastTypeName(Configuration configuration){
  return dataType.getCastTypeName(configuration);
}
Program: 54459
Project: 54459
Buggy source:
public Class<T> getType(){
  return dataType.getType();
}

Fixed version (ground truth):
@Override public Class<T> getType(){
  return dataType.getType();
}
Program: 54460
Project: 54460
Buggy source:
public boolean isNumeric(){
  return dataType.isNumeric();
}

Fixed version (ground truth):
@Override public boolean isNumeric(){
  return dataType.isNumeric();
}
Program: 54461
Project: 54461
Buggy source:
public boolean isDateTime(){
  return dataType.isDateTime();
}

Fixed version (ground truth):
@Override public boolean isDateTime(){
  return dataType.isDateTime();
}
Program: 54462
Project: 54462
Buggy source:
public boolean hasPrecision(){
  return dataType.hasPrecision();
}

Fixed version (ground truth):
@Override public boolean hasPrecision(){
  return dataType.hasPrecision();
}
Program: 54463
Project: 54463
Buggy source:
public boolean isInterval(){
  return dataType.isInterval();
}

Fixed version (ground truth):
@Override public boolean isInterval(){
  return dataType.isInterval();
}
Program: 54464
Project: 54464
Buggy source:
public boolean isArray(){
  return dataType.isArray();
}

Fixed version (ground truth):
@Override public boolean isArray(){
  return dataType.isArray();
}
Program: 54465
Project: 54465
Buggy source:
public int getSQLType(){
  return sqlType;
}

Fixed version (ground truth):
@SuppressFBWarnings(value="String_Node_Str",justification="String_Node_Str" + "String_Node_Str" + "String_Node_Str") @Override public int getSQLType(){
  return sqlType;
}
Program: 54466
Project: 54466
Buggy source:
public Converter<?,T> getConverter(){
  return dataType.getConverter();
}

Fixed version (ground truth):
@Override public Converter<?,T> getConverter(){
  return dataType.getConverter();
}