nus-yam/ex-repair huggingface dataset:
Program: 62582
Project: 62582
Buggy source:
@Override public void showError(){
  mTabLayout.setVisibility(View.INVISIBLE);
  mViewPager.setVisibility(View.INVISIBLE);
  RxBus.getDefault().post(new ShowErrorView());
}

Fixed version (ground truth):
@Override public void showError(){
  mTabLayout.setVisibility(View.INVISIBLE);
  mDivider.setVisibility(View.INVISIBLE);
  mViewPager.setVisibility(View.INVISIBLE);
  RxBus.getDefault().post(new ShowErrorView());
}
Program: 62583
Project: 62583
Buggy source:
@Override public void loadMainPagerData(){
  String account=mDataManager.getLoginAccount();
  String password=mDataManager.getLoginPassword();
  if (TextUtils.isEmpty(account) || TextUtils.isEmpty(password)) {
    return;
  }
  Observable<LoginResponse> mLoginObservable=mDataManager.getLoginData(account,password);
  Observable<BannerResponse> mBannerObservable=mDataManager.getBannerData();
  Observable<FeedArticleListResponse> mArticleObservable=mDataManager.getFeedArticleList(Constants.FIRST);
  Observable.zip(mLoginObservable,mBannerObservable,mArticleObservable,(loginResponse,bannerResponse,feedArticleListResponse) -> {
    HashMap<String,Object> map=new HashMap<>(3);
    map.put(Constants.LOGIN_DATA,loginResponse);
    map.put(Constants.BANNER_DATA,bannerResponse);
    map.put(Constants.ARTICLE_DATA,feedArticleListResponse);
    return map;
  }
).compose(RxUtils.rxSchedulerHelper()).subscribe(map -> {
    LoginResponse loginResponse=(LoginResponse)map.get(Constants.LOGIN_DATA);
    if (loginResponse.getErrorCode() == BaseResponse.SUCCESS) {
      mView.showAutoLoginSuccess();
    }
 else {
      mView.showErrorMsg(loginResponse.getErrorMsg());
    }
    mView.showBannerData((BannerResponse)map.get(Constants.BANNER_DATA));
    mView.showArticleList((FeedArticleListResponse)map.get(Constants.ARTICLE_DATA));
  }
);
}

Fixed version (ground truth):
@Override public void loadMainPagerData(){
  String account=mDataManager.getLoginAccount();
  String password=mDataManager.getLoginPassword();
  Observable<LoginResponse> mLoginObservable=mDataManager.getLoginData(account,password);
  Observable<BannerResponse> mBannerObservable=mDataManager.getBannerData();
  Observable<FeedArticleListResponse> mArticleObservable=mDataManager.getFeedArticleList(Constants.FIRST);
  Observable.zip(mLoginObservable,mBannerObservable,mArticleObservable,(loginResponse,bannerResponse,feedArticleListResponse) -> {
    HashMap<String,Object> map=new HashMap<>(3);
    map.put(Constants.LOGIN_DATA,loginResponse);
    map.put(Constants.BANNER_DATA,bannerResponse);
    map.put(Constants.ARTICLE_DATA,feedArticleListResponse);
    return map;
  }
).compose(RxUtils.rxSchedulerHelper()).subscribe(map -> {
    LoginResponse loginResponse=(LoginResponse)map.get(Constants.LOGIN_DATA);
    if (loginResponse.getErrorCode() == BaseResponse.SUCCESS) {
      mView.showAutoLoginSuccess();
    }
    mView.showBannerData((BannerResponse)map.get(Constants.BANNER_DATA));
    mView.showArticleList((FeedArticleListResponse)map.get(Constants.ARTICLE_DATA));
  }
);
}
Program: 62584
Project: 62584
Buggy source:
@Override public void loadMainPagerData(){
  String account=mDataManager.getLoginAccount();
  String password=mDataManager.getLoginPassword();
  Observable<LoginResponse> mLoginObservable=mDataManager.getLoginData(account,password);
  Observable<BannerResponse> mBannerObservable=mDataManager.getBannerData();
  Observable<FeedArticleListResponse> mArticleObservable=mDataManager.getFeedArticleList(Constants.FIRST);
  Observable.zip(mLoginObservable,mBannerObservable,mArticleObservable,(loginResponse,bannerResponse,feedArticleListResponse) -> {
    HashMap<String,Object> map=new HashMap<>(3);
    map.put(Constants.LOGIN_DATA,loginResponse);
    map.put(Constants.BANNER_DATA,bannerResponse);
    map.put(Constants.ARTICLE_DATA,feedArticleListResponse);
    return map;
  }
).compose(RxUtils.rxSchedulerHelper()).subscribe(map -> {
    LoginResponse loginResponse=(LoginResponse)map.get(Constants.LOGIN_DATA);
    if (loginResponse.getErrorCode() == BaseResponse.SUCCESS) {
      mView.showAutoLoginSuccess();
    }
    mView.showBannerData((BannerResponse)map.get(Constants.BANNER_DATA));
    mView.showArticleList((FeedArticleListResponse)map.get(Constants.ARTICLE_DATA));
  }
);
}

Fixed version (ground truth):
@Override public void loadMainPagerData(){
  String account=mDataManager.getLoginAccount();
  String password=mDataManager.getLoginPassword();
  Observable<LoginResponse> mLoginObservable=mDataManager.getLoginData(account,password);
  Observable<BannerResponse> mBannerObservable=mDataManager.getBannerData();
  Observable<FeedArticleListResponse> mArticleObservable=mDataManager.getFeedArticleList(Constants.FIRST);
  Observable.zip(mLoginObservable,mBannerObservable,mArticleObservable,(loginResponse,bannerResponse,feedArticleListResponse) -> {
    HashMap<String,Object> map=new HashMap<>(3);
    map.put(Constants.LOGIN_DATA,loginResponse);
    map.put(Constants.BANNER_DATA,bannerResponse);
    map.put(Constants.ARTICLE_DATA,feedArticleListResponse);
    return map;
  }
).compose(RxUtils.rxSchedulerHelper()).subscribeWith(new BaseObserver<HashMap<String,Object>>(mView){
    @Override public void onNext(    HashMap<String,Object> map){
      LoginResponse loginResponse=(LoginResponse)map.get(Constants.LOGIN_DATA);
      if (loginResponse.getErrorCode() == BaseResponse.SUCCESS) {
        mView.showAutoLoginSuccess();
      }
      mView.showBannerData((BannerResponse)map.get(Constants.BANNER_DATA));
      mView.showArticleList((FeedArticleListResponse)map.get(Constants.ARTICLE_DATA));
    }
  }
);
}
Program: 62585
Project: 62585
Buggy source:
public void reLoad(){
  mPresenter.getKnowledgeHierarchyData();
}

Fixed version (ground truth):
public void reLoad(){
  if (mPresenter != null) {
    mPresenter.getKnowledgeHierarchyData();
  }
}
Program: 62587
Project: 62587
Buggy source:
private void setLoginView(){
  mUsTv=(TextView)mNavigationView.getHeaderView(0).findViewById(R.id.nav_header_login_tv);
  mUsTv.setText(mDataManager.getLoginAccount());
  mUsTv.setOnClickListener(null);
  mNavigationView.getMenu().findItem(R.id.nav_item_logout).setVisible(true);
}

Fixed version (ground truth):
private void setLoginView(){
  if (mNavigationView == null) {
    return;
  }
  mUsTv=(TextView)mNavigationView.getHeaderView(0).findViewById(R.id.nav_header_login_tv);
  mUsTv.setText(mDataManager.getLoginAccount());
  mUsTv.setOnClickListener(null);
  mNavigationView.getMenu().findItem(R.id.nav_item_logout).setVisible(true);
}
Program: 62588
Project: 62588
Buggy source:
private void setLogoutView(){
  mUsTv.setText(R.string.login_in);
  mUsTv.setOnClickListener(v -> startActivity(new Intent(this,LoginActivity.class)));
  mNavigationView.getMenu().findItem(R.id.nav_item_logout).setVisible(false);
}

Fixed version (ground truth):
private void setLogoutView(){
  mUsTv.setText(R.string.login_in);
  mUsTv.setOnClickListener(v -> startActivity(new Intent(this,LoginActivity.class)));
  if (mNavigationView == null) {
    return;
  }
  mNavigationView.getMenu().findItem(R.id.nav_item_logout).setVisible(false);
}
Program: 62589
Project: 62589
Buggy source:
public void reLoad(){
  mPresenter.getNavigationListData();
}

Fixed version (ground truth):
public void reLoad(){
  if (mPresenter != null) {
    mPresenter.getNavigationListData();
  }
}
Program: 62590
Project: 62590
Buggy source:
public void reLoad(){
  mPresenter.getProjectClassifyData();
}

Fixed version (ground truth):
public void reLoad(){
  if (mPresenter != null) {
    mPresenter.getProjectClassifyData();
  }
}
Program: 62591
Project: 62591
Buggy source:
/** 
 * Start building a new annotation for the given name.
 * @param annotation The annotation name
 * @return The builder
 */
public static <T extends Annotation>AnnotationValueBuilder<T> builder(Class<T> annotation){
  return new AnnotationValueBuilder<>(annotation);
}

Fixed version (ground truth):
/** 
 * Start building a new annotation for the given name.
 * @param annotation The annotation name
 * @param < T > The annotation type
 * @return The builder
 */
public static <T extends Annotation>AnnotationValueBuilder<T> builder(Class<T> annotation){
  return new AnnotationValueBuilder<>(annotation);
}
Program: 62592
Project: 62592
Buggy source:
/** 
 * Sets the value member to the given type object.
 * @param type The type
 * @return This builder
 */
public AnnotationValueBuilder<T> member(String name,Class<?> type){
  values.put(name,type);
  return this;
}

Fixed version (ground truth):
/** 
 * Sets the value member to the given type object.
 * @param name The name of the member
 * @param type The type
 * @return This builder
 */
public AnnotationValueBuilder<T> member(String name,Class<?> type){
  values.put(name,type);
  return this;
}
Program: 62593
Project: 62593
Buggy source:
public ExtendedParameter(MethodNode methodNode,Parameter parameter){
  this.methodNode=methodNode;
  this.parameter=parameter;
  this.addAnnotations(parameter.getAnnotations());
  this.setSynthetic(parameter.isSynthetic());
  this.setDeclaringClass(parameter.getDeclaringClass());
  this.setHasNoRealSourcePosition(parameter.hasNoRealSourcePosition());
}

Fixed version (ground truth):
/** 
 * @param methodNode The method node that contains the parameter
 * @param parameter  The parameter
 */
public ExtendedParameter(MethodNode methodNode,Parameter parameter){
  this.methodNode=methodNode;
  this.parameter=parameter;
  this.addAnnotations(parameter.getAnnotations());
  this.setSynthetic(parameter.isSynthetic());
  this.setDeclaringClass(parameter.getDeclaringClass());
  this.setHasNoRealSourcePosition(parameter.hasNoRealSourcePosition());
}
Program: 62594
Project: 62594
Buggy source:
public MethodNode getMethodNode(){
  return methodNode;
}

Fixed version (ground truth):
/** 
 * @return The method node that contains the parameter
 */
public MethodNode getMethodNode(){
  return methodNode;
}
Program: 62595
Project: 62595
Buggy source:
public Parameter getParameter(){
  return parameter;
}

Fixed version (ground truth):
/** 
 * @return The parameter
 */
public Parameter getParameter(){
  return parameter;
}
Program: 62596
Project: 62596
Buggy source:
/** 
 * @param name The name of the logger to configure
 * @param configuredLevel The {@link LogLevel} to set on the named logger
 * @return The {@link HttpResponse} with status code and message on error
 */
@Write public HttpResponse setLogLevel(@QueryValue @NotBlank String name,@Nullable LogLevel configuredLevel){
  try {
    loggersManager.setLogLevel(loggingSystem,name,configuredLevel != null ? configuredLevel : LogLevel.NOT_SPECIFIED);
    return HttpResponse.ok();
  }
 catch (  IllegalArgumentException ex) {
    return HttpResponse.badRequest(ex.getMessage());
  }
}

Fixed version (ground truth):
/** 
 * @param name The name of the logger to configure
 * @param configuredLevel The {@link LogLevel} to set on the named logger
 * @return The {@link HttpResponse} with status code and message on error
 */
@Write public HttpResponse setLogLevel(@QueryValue @NotBlank String name,@Nullable LogLevel configuredLevel){
  try {
    loggersManager.setLogLevel(loggingSystem,name,configuredLevel != null ? configuredLevel : LogLevel.NOT_SPECIFIED);
    return HttpResponse.ok();
  }
 catch (  IllegalArgumentException ex) {
    JsonError error=new JsonError(ex.getMessage());
    return HttpResponse.badRequest(error);
  }
}
Program: 62597
Project: 62597
Buggy source:
@Override public Optional<Object> convert(FileUpload object,Class<Object> targetType,ConversionContext context){
  try {
    if (!object.isCompleted()) {
      return Optional.empty();
    }
    String contentType=object.getContentType();
    ByteBuf byteBuf=object.getByteBuf();
    if (contentType != null) {
      MediaType mediaType=new MediaType(contentType);
      Optional<MediaTypeCodec> registered=decoderRegistry.findCodec(mediaType);
      if (registered.isPresent()) {
        MediaTypeCodec decoder=registered.get();
        Object val=decoder.decode(targetType,new ByteBufInputStream(byteBuf));
        return Optional.of(val);
      }
 else {
        return conversionService.convert(byteBuf,targetType,context);
      }
    }
    return conversionService.convert(byteBuf,targetType,context);
  }
 catch (  Exception e) {
    context.reject(e);
    return Optional.empty();
  }
}

Fixed version (ground truth):
@Override public Optional<Object> convert(FileUpload object,Class<Object> targetType,ConversionContext context){
  try {
    if (!object.isCompleted()) {
      return Optional.empty();
    }
    String contentType=object.getContentType();
    ByteBuf byteBuf=object.getByteBuf();
    if (contentType != null) {
      MediaType mediaType=new MediaType(contentType);
      Optional<MediaTypeCodec> registered=decoderRegistryProvider.get().findCodec(mediaType);
      if (registered.isPresent()) {
        MediaTypeCodec decoder=registered.get();
        Object val=decoder.decode(targetType,new ByteBufInputStream(byteBuf));
        return Optional.of(val);
      }
 else {
        return conversionService.convert(byteBuf,targetType,context);
      }
    }
    return conversionService.convert(byteBuf,targetType,context);
  }
 catch (  Exception e) {
    context.reject(e);
    return Optional.empty();
  }
}
Program: 62598
Project: 62598
Buggy source:
/** 
 * @param conversionService The conversion service
 * @param decoderRegistry   The media type decoder registry
 */
protected FileUploadToObjectConverter(ConversionService conversionService,MediaTypeCodecRegistry decoderRegistry){
  this.conversionService=conversionService;
  this.decoderRegistry=decoderRegistry;
}

Fixed version (ground truth):
/** 
 * @param conversionService       The conversion service
 * @param decoderRegistryProvider The media type decoder registry provider
 */
protected FileUploadToObjectConverter(ConversionService conversionService,Provider<MediaTypeCodecRegistry> decoderRegistryProvider){
  this.conversionService=conversionService;
  this.decoderRegistryProvider=decoderRegistryProvider;
}
Program: 62599
Project: 62599
Buggy source:
/** 
 * Obtains an instance of the specified   {@code Callable} command class from the specified context,injecting any beans from the specified context as required, then parses the specified command line arguments, populating fields and methods annotated with picocli  {@link Option @Option} and {@link Parameters @Parameters}annotations, and finally calls the command and returns the result. <p> The caller is responsible for   {@linkplain ApplicationContext#close() closing} the context.</p>
 * @param cls the Callable command class
 * @param ctx the ApplicationContext that injects dependencies into the command
 * @param args the command line arguments
 * @return {@code null} if an error occurred while parsing the command line options,or if help was requested and printed. Otherwise returns the result of calling the Callable
 * @throws InitializationException if the specified command object does not havea  {@link Command},   {@link Option} or {@link Parameters} annotation
 * @throws ExecutionException if the Callable throws an exception
 */
public static <C extends Callable<T>,T>T call(Class<C> cls,ApplicationContext ctx,String... args){
  return CommandLine.call(cls,new MicronautFactory(ctx),args);
}

Fixed version (ground truth):
/** 
 * Obtains an instance of the specified   {@code Callable} command class from the specified context,injecting any beans from the specified context as required, then parses the specified command line arguments, populating fields and methods annotated with picocli  {@link Option @Option} and {@link Parameters @Parameters}annotations, and finally calls the command and returns the result. <p> The caller is responsible for   {@linkplain ApplicationContext#close() closing} the context.</p>
 * @param cls the Callable command class
 * @param ctx the ApplicationContext that injects dependencies into the command
 * @param args the command line arguments
 * @param < C > The callable type
 * @param < T > The callable return type
 * @return {@code null} if an error occurred while parsing the command line options,or if help was requested and printed. Otherwise returns the result of calling the Callable
 * @throws InitializationException if the specified command object does not havea  {@link Command},   {@link Option} or {@link Parameters} annotation
 * @throws ExecutionException if the Callable throws an exception
 */
public static <C extends Callable<T>,T>T call(Class<C> cls,ApplicationContext ctx,String... args){
  return CommandLine.call(cls,new MicronautFactory(ctx),args);
}
Program: 62600
Project: 62600
Buggy source:
/** 
 * Obtains an instance of the specified   {@code Runnable} command class from the specified context,injecting any beans from the specified context as required, then parses the specified command line arguments, populating fields and methods annotated with picocli  {@link Option @Option} and {@link Parameters @Parameters}annotations, and finally runs the command. <p> The caller is responsible for   {@linkplain ApplicationContext#close() closing} the context.</p>
 * @param cls the Runnable command class
 * @param ctx the ApplicationContext that injects dependencies into the command
 * @param args the command line arguments
 * @throws InitializationException if the specified command object does not havea  {@link Command},   {@link Option} or {@link Parameters} annotation
 * @throws ExecutionException if the Runnable throws an exception
 */
public static <R extends Runnable>void run(Class<R> cls,ApplicationContext ctx,String... args){
  CommandLine.run(cls,new MicronautFactory(ctx),args);
}

Fixed version (ground truth):
/** 
 * Obtains an instance of the specified   {@code Runnable} command class from the specified context,injecting any beans from the specified context as required, then parses the specified command line arguments, populating fields and methods annotated with picocli  {@link Option @Option} and {@link Parameters @Parameters}annotations, and finally runs the command. <p> The caller is responsible for   {@linkplain ApplicationContext#close() closing} the context.</p>
 * @param cls the Runnable command class
 * @param ctx the ApplicationContext that injects dependencies into the command
 * @param args the command line arguments
 * @param < R > The runnable type
 * @throws InitializationException if the specified command object does not havea  {@link Command},   {@link Option} or {@link Parameters} annotation
 * @throws ExecutionException if the Runnable throws an exception
 */
public static <R extends Runnable>void run(Class<R> cls,ApplicationContext ctx,String... args){
  CommandLine.run(cls,new MicronautFactory(ctx),args);
}
Program: 62601
Project: 62601
Buggy source:
@Write public HttpResponse setLogLevel(@QueryValue @NotBlank String name,@Nullable String configuredLevel){
  loggersDataCollector.setLogLevel(loggingSystem,name,configuredLevel);
  return HttpResponse.ok();
}

Fixed version (ground truth):
/** 
 * @param name The name of the logger to configure
 * @param configuredLevel The {@link LogLevel} as a string to set on the named logger
 * @return OK status, empty body
 */
@Write public HttpResponse setLogLevel(@QueryValue @NotBlank String name,@Nullable String configuredLevel){
  loggersDataCollector.setLogLevel(loggingSystem,name,configuredLevel);
  return HttpResponse.ok();
}
Program: 62602
Project: 62602
Buggy source:
/** 
 * @param level The micronaut {@link LogLevel} to convert
 * @return The converted logback {@link Level}
 */
protected static Level toLevel(LogLevel logLevel){
  if (logLevel == LogLevel.NOT_SPECIFIED) {
    return null;
  }
 else {
    return Level.valueOf(logLevel.name());
  }
}

Fixed version (ground truth):
/** 
 * @param logLevel The micronaut {@link LogLevel} to convert
 * @return The converted logback {@link Level}
 */
protected static Level toLevel(LogLevel logLevel){
  if (logLevel == LogLevel.NOT_SPECIFIED) {
    return null;
  }
 else {
    return Level.valueOf(logLevel.name());
  }
}
Program: 62603
Project: 62603
Buggy source:
/** 
 * @param body The body to replace
 * @return The current instance
 */
public NettyMutableHttpResponse replace(ByteBuf body){
  this.nettyResponse=this.nettyResponse.replace(body);
  return this;
}

Fixed version (ground truth):
/** 
 * @param body The body to replace
 * @return The current instance
 */
public NettyMutableHttpResponse replace(ByteBuf body){
  this.nettyResponse=this.nettyResponse.replace(body);
  this.headers.setNettyHeaders(this.nettyResponse.headers());
  return this;
}
Program: 62604
Project: 62604
Buggy source:
Publisher<T> getOne(LoggingSystem loggingSystem,@NotBlank String name);

Fixed version (ground truth):
/** 
 * Find (or create if not found) the named logger in the system.
 * @param loggingSystem The {@link LoggingSystem} in use
 * @param name The name of the logger to find or create
 * @return A {@link Publisher} of <code>T</code>
 */
Publisher<T> getOne(LoggingSystem loggingSystem,@NotBlank String name);
Program: 62605
Project: 62605
Buggy source:
Publisher<T> getData(LoggingSystem loggingSystem);

Fixed version (ground truth):
/** 
 * Collect all existing loggers in the system.
 * @param loggingSystem The {@link LoggingSystem} in use
 * @return A {@link Publisher} of <code>T</code>
 */
Publisher<T> getData(LoggingSystem loggingSystem);
Program: 62606
Project: 62606
Buggy source:
@Read public Single getLogger(@QueryValue @NotBlank String name){
  return Single.fromPublisher(loggersDataCollector.getOne(loggingSystem,name));
}

Fixed version (ground truth):
/** 
 * @param name The name of the logger to find
 * @return the {@link LogLevel} (both configured and effective) of the named logger
 */
@Read public Single getLogger(@QueryValue @NotBlank String name){
  return Single.fromPublisher(loggersDataCollector.getOne(loggingSystem,name));
}
Program: 62607
Project: 62607
Buggy source:
/** 
 * Set the log level for the logger found by name (or created if not found)
 * @param name the logger name
 * @param level the log level to set on the named logger
 */
void setLogLevel(@NotBlank String name,@NotNull LogLevel level);

Fixed version (ground truth):
/** 
 * Set the log level for the logger found by name (or created if not found).
 * @param name the logger name
 * @param level the log level to set on the named logger
 */
void setLogLevel(@NotBlank String name,@NotNull LogLevel level);
Program: 62608
Project: 62608
Buggy source:
/** 
 * Returns a   {@link LoggerConfiguration} for the logger found by name (or created if not found)
 * @param name the logger name
 * @return the logger configuration
 */
LoggerConfiguration getLogger(@NotBlank String name);

Fixed version (ground truth):
/** 
 * Returns a   {@link LoggerConfiguration} for the logger found by name (or created if not found).
 * @param name the logger name
 * @return the logger configuration
 */
LoggerConfiguration getLogger(@NotBlank String name);
Program: 62609
Project: 62609
Buggy source:
/** 
 * Returns all existing loggers
 * @return A {@link Collection} of {@link LoggerConfiguration} instances for all existing loggers
 */
Collection<LoggerConfiguration> getLoggers();

Fixed version (ground truth):
/** 
 * Returns all existing loggers.
 * @return A {@link Collection} of {@link LoggerConfiguration} instances for all existing loggers
 */
Collection<LoggerConfiguration> getLoggers();
Program: 62610
Project: 62610
Buggy source:
/** 
 * @param vertx The Vertx instance.
 * @return
 */
private PgPool createClient(Vertx vertx){
  PgPoolConfiguration configuration=this.pgPoolConfiguration;
  String connectionUri=configuration.getUri();
  if (StringUtils.isNotEmpty(connectionUri)) {
    return PgClient.pool(vertx,connectionUri);
  }
 else {
    return PgClient.pool(vertx,configuration.pgPoolOptions);
  }
}

Fixed version (ground truth):
/** 
 * Create a connection pool to the database configured with the   {@link PgPoolConfiguration}.
 * @param vertx The Vertx instance.
 * @return A pool of connections.
 */
private PgPool createClient(Vertx vertx){
  PgPoolConfiguration configuration=this.pgPoolConfiguration;
  String connectionUri=configuration.getUri();
  if (StringUtils.isNotEmpty(connectionUri)) {
    return PgClient.pool(vertx,connectionUri);
  }
 else {
    return PgClient.pool(vertx,configuration.pgPoolOptions);
  }
}
Program: 62611
Project: 62611
Buggy source:
/** 
 * @return client
 */
@Singleton @Bean(preDestroy="String_Node_Str") public PgPool client(){
  if (this.vertx == null) {
    return createClient();
  }
 else {
    return createClient(vertx);
  }
}

Fixed version (ground truth):
/** 
 * @return client A pool of connections.
 */
@Singleton @Bean(preDestroy="String_Node_Str") public PgPool client(){
  if (this.vertx == null) {
    return createClient();
  }
 else {
    return createClient(vertx);
  }
}
Program: 62612
Project: 62612
Buggy source:
/** 
 * @param pgPoolConfiguration
 * @param vertx
 */
public PgPoolClientFactory(PgPoolConfiguration pgPoolConfiguration,@Nullable Vertx vertx){
  this.pgPoolConfiguration=pgPoolConfiguration;
  this.vertx=vertx;
}

Fixed version (ground truth):
/** 
 * Create the factory with given Posgres Pool configuration and Vertx instance(can be null) if you are running with Vert.x.
 * @param pgPoolConfiguration The Reactive Postgres configurations
 * @param vertx The Vertx instance
 */
public PgPoolClientFactory(PgPoolConfiguration pgPoolConfiguration,@Nullable Vertx vertx){
  this.pgPoolConfiguration=pgPoolConfiguration;
  this.vertx=vertx;
}
Program: 62613
Project: 62613
Buggy source:
/** 
 * @return
 */
public PgPoolOptions getPgPoolOptions(){
  return pgPoolOptions;
}

Fixed version (ground truth):
/** 
 * @return The options for configuring a connection pool.
 */
public PgPoolOptions getPgPoolOptions(){
  return pgPoolOptions;
}
Program: 62614
Project: 62614
Buggy source:
/** 
 * @return
 */
public String getUri(){
  return uri;
}

Fixed version (ground truth):
/** 
 * @return The Postgres connection URI.
 */
public String getUri(){
  return uri;
}
Program: 62615
Project: 62615
Buggy source:
/** 
 * @param client The Reactive Pg Client.
 */
public PgPoolHealthIndicator(PgPool client){
  this.client=client;
}

Fixed version (ground truth):
/** 
 * Constructor.
 * @param client A pool of connections.
 */
public PgPoolHealthIndicator(PgPool client){
  this.client=client;
}
Program: 62616
Project: 62616
Buggy source:
/** 
 * Returns the level of detail that should be returned by the endpoint.
 * @param principal Authenticated user
 * @return The {@link HealthLevelOfDetail}
 */
public HealthLevelOfDetail levelOfDetail(@Nullable Principal principal){
  boolean showDetails=false;
switch (detailsVisibility) {
case AUTHENTICATED:
    showDetails=principal != null;
  break;
case ANONYMOUS:
showDetails=true;
}
if (showDetails) {
return HealthLevelOfDetail.STATUS_DESCRIPTION_DETAILS;
}
 else {
return HealthLevelOfDetail.STATUS;
}
}

Fixed version (ground truth):
/** 
 * Returns the level of detail that should be returned by the endpoint.
 * @param principal Authenticated user
 * @return The {@link HealthLevelOfDetail}
 */
public HealthLevelOfDetail levelOfDetail(@Nullable Principal principal){
  boolean showDetails=false;
switch (detailsVisibility) {
case AUTHENTICATED:
    showDetails=principal != null;
  break;
case ANONYMOUS:
showDetails=true;
default :
}
if (showDetails) {
return HealthLevelOfDetail.STATUS_DESCRIPTION_DETAILS;
}
 else {
return HealthLevelOfDetail.STATUS;
}
}
Program: 62618
Project: 62618
Buggy source:
@Override public String getMessage(){
  Optional<JsonError> body=getResponse().getBody(JsonError.class);
  if (body.isPresent()) {
    return body.get().getMessage();
  }
 else {
    return super.getMessage();
  }
}

Fixed version (ground truth):
@Override public String getMessage(){
  Optional<JsonError> body=getResponse().getBody(JsonError.class);
  if (body.isPresent() && body.get().getMessage() != null) {
    return body.get().getMessage();
  }
 else {
    return super.getMessage();
  }
}
Program: 62619
Project: 62619
Buggy source:
@EachBean(CassandraConfiguration.class) @Bean(preDestroy="String_Node_Str") public Cluster cassandraCluster(CassandraConfiguration cassandraConfiguration){
  return cassandraConfiguration.builder.build();
}

Fixed version (ground truth):
/** 
 * Creates the   {@link Cluster} bean for the given configuration.
 * @param cassandraConfiguration The {@link CassandraConfiguration} object
 * @return A {@link Cluster} bean
 */
@EachBean(CassandraConfiguration.class) @Bean(preDestroy="String_Node_Str") public Cluster cassandraCluster(CassandraConfiguration cassandraConfiguration){
  return cassandraConfiguration.builder.build();
}
Program: 62622
Project: 62622
Buggy source:
private Optional<? extends FileCustomizableResponseType> matchFile(String path){
  Optional<URL> optionalUrl=staticResourceResolver.resolve(path);
  if (optionalUrl.isPresent()) {
    try {
      URL url=optionalUrl.get();
      URI uri=url.toURI();
      File file=new File(uri.getPath());
      System.out.println(uri.getPath());
      System.out.println(file.getAbsolutePath());
      if (file.exists()) {
        System.out.println("String_Node_Str");
        if (!file.isDirectory() && file.canRead()) {
          return Optional.of(new NettySystemFileCustomizableResponseType(file));
        }
      }
 else {
        System.out.println("String_Node_Str");
        return Optional.of(new NettyStreamedFileCustomizableResponseType(uri));
      }
    }
 catch (    URISyntaxException e) {
    }
  }
  return Optional.empty();
}

Fixed version (ground truth):
private Optional<? extends FileCustomizableResponseType> matchFile(String path){
  Optional<URL> optionalUrl=staticResourceResolver.resolve(path);
  if (optionalUrl.isPresent()) {
    try {
      URL url=optionalUrl.get();
      URI uri=url.toURI();
      File file=new File(uri.getPath());
      System.out.println(uri.getPath());
      System.out.println(file.getAbsolutePath());
      if (file.exists()) {
        System.out.println("String_Node_Str");
        if (!file.isDirectory() && file.canRead()) {
          return Optional.of(new NettySystemFileCustomizableResponseType(file));
        }
      }
 else {
        System.out.println("String_Node_Str");
        return Optional.of(new NettyStreamedFileCustomizableResponseType(url));
      }
    }
 catch (    URISyntaxException e) {
    }
  }
  return Optional.empty();
}
Program: 62623
Project: 62623
Buggy source:
public void setAlwaysIncludeNewline(boolean eagerNewlines){
  this.eagerNewlines=eagerNewlines;
}

Fixed version (ground truth):
/** 
 * @param eagerNewlines eager new lines
 */
public void setAlwaysIncludeNewline(boolean eagerNewlines){
  this.eagerNewlines=eagerNewlines;
}
Program: 62624
Project: 62624
Buggy source:
public boolean complete(ConsoleReader reader,@SuppressWarnings("String_Node_Str") List<CharSequence> candidates,int pos) throws IOException {
  CursorBuffer buf=reader.getCursorBuffer();
  if (candidates.size() == 1) {
    String value=candidates.get(0).toString();
    if (value.equals(buf.toString())) {
      return false;
    }
    jline.console.completer.CandidateListCompletionHandler.setBuffer(reader,value,pos);
    return true;
  }
  if (candidates.size() > 1) {
    String value=getUnambiguousCompletions(candidates);
    jline.console.completer.CandidateListCompletionHandler.setBuffer(reader,value,pos);
  }
  if (eagerNewlines) {
    reader.println();
  }
  jline.console.completer.CandidateListCompletionHandler.printCandidates(reader,candidates);
  reader.drawLine();
  return true;
}

Fixed version (ground truth):
/** 
 * @param reader     The console reader
 * @param candidates The candidates
 * @param pos        The position
 * @return Whether the console has been read
 * @throws IOException if there is a problem
 */
public boolean complete(ConsoleReader reader,@SuppressWarnings("String_Node_Str") List<CharSequence> candidates,int pos) throws IOException {
  CursorBuffer buf=reader.getCursorBuffer();
  if (candidates.size() == 1) {
    String value=candidates.get(0).toString();
    if (value.equals(buf.toString())) {
      return false;
    }
    jline.console.completer.CandidateListCompletionHandler.setBuffer(reader,value,pos);
    return true;
  }
  if (candidates.size() > 1) {
    String value=getUnambiguousCompletions(candidates);
    jline.console.completer.CandidateListCompletionHandler.setBuffer(reader,value,pos);
  }
  if (eagerNewlines) {
    reader.println();
  }
  jline.console.completer.CandidateListCompletionHandler.printCandidates(reader,candidates);
  reader.drawLine();
  return true;
}
Program: 62625
Project: 62625
Buggy source:
/** 
 * @return true is all the elements of <i>candidates</i>start with <i>starts</i>
 */
private final boolean startsWith(final String starts,final String[] candidates){
  for (int i=0; i < candidates.length; i++) {
    if (!candidates[i].startsWith(starts)) {
      return false;
    }
  }
  return true;
}

Fixed version (ground truth):
/** 
 * @return true is all the elements of <i>candidates</i>start with <i>starts</i>
 */
private boolean startsWith(final String starts,final String[] candidates){
  for (int i=0; i < candidates.length; i++) {
    if (!candidates[i].startsWith(starts)) {
      return false;
    }
  }
  return true;
}
Program: 62626
Project: 62626
Buggy source:
public ConsoleAntBuilder(){
  super(createAntProject());
}

Fixed version (ground truth):
/** 
 * Default constructor.
 */
public ConsoleAntBuilder(){
  super(createAntProject());
}
Program: 62627
Project: 62627
Buggy source:
public static void addMicronautConsoleBuildListener(Project project){
  final BuildLogger logger=new MicronautConsoleLogger();
  logger.setMessageOutputLevel(Project.MSG_INFO);
  logger.setOutputPrintStream(System.out);
  logger.setErrorPrintStream(System.err);
  project.addBuildListener(logger);
  MicronautConsole instance=MicronautConsole.getInstance();
  project.addBuildListener(new ConsoleBuildListener(instance));
  if (!instance.isVerbose()) {
    for (    Object buildListener : project.getBuildListeners()) {
      if (buildListener instanceof BuildLogger) {
        ((BuildLogger)buildListener).setMessageOutputLevel(LogLevel.ERR.getLevel());
      }
    }
  }
}

Fixed version (ground truth):
/** 
 * @param project The Ant {@link Project}
 */
public static void addMicronautConsoleBuildListener(Project project){
  final BuildLogger logger=new MicronautConsoleLogger();
  logger.setMessageOutputLevel(Project.MSG_INFO);
  logger.setOutputPrintStream(System.out);
  logger.setErrorPrintStream(System.err);
  project.addBuildListener(logger);
  MicronautConsole instance=MicronautConsole.getInstance();
  project.addBuildListener(new ConsoleBuildListener(instance));
  if (!instance.isVerbose()) {
    for (    Object buildListener : project.getBuildListeners()) {
      if (buildListener instanceof BuildLogger) {
        ((BuildLogger)buildListener).setMessageOutputLevel(LogLevel.ERR.getLevel());
      }
    }
  }
}
Program: 62628
Project: 62628
Buggy source:
public ConsoleBuildListener(MicronautConsole ui){
  this.ui=ui;
}

Fixed version (ground truth):
/** 
 * @param ui The Micronaut console
 */
public ConsoleBuildListener(MicronautConsole ui){
  this.ui=ui;
}
Program: 62629
Project: 62629
Buggy source:
public PrintStream getTargetOut(){
  return (PrintStream)out;
}

Fixed version (ground truth):
/** 
 * @return The print stream
 */
public PrintStream getTargetOut(){
  return (PrintStream)out;
}
Program: 62630
Project: 62630
Buggy source:
public ConsoleErrorPrintStream(PrintStream out){
  super(out,true);
}

Fixed version (ground truth):
/** 
 * @param out The print stream
 */
public ConsoleErrorPrintStream(PrintStream out){
  super(out,true);
}
Program: 62631
Project: 62631
Buggy source:
/** 
 * Prints a warning message
 * @param msg The warning message
 */
void warn(String msg);

Fixed version (ground truth):
/** 
 * Prints a warning message.
 * @param msg The warning message
 */
void warn(String msg);
Program: 62632
Project: 62632
Buggy source:
/** 
 * Indicates progress as a percentage for the given number and total
 * @param number The number
 * @param total  The total
 */
void indicateProgressPercentage(long number,long total);

Fixed version (ground truth):
/** 
 * Indicates progress as a percentage for the given number and total.
 * @param number The number
 * @param total  The total
 */
void indicateProgressPercentage(long number,long total);
Program: 62633
Project: 62633
Buggy source:
/** 
 * Logs a message below the current status message
 * @param msg The message to log
 */
void log(String msg);

Fixed version (ground truth):
/** 
 * Logs a message below the current status message.
 * @param msg The message to log
 */
void log(String msg);
Program: 62634
Project: 62634
Buggy source:
/** 
 * Updates the current state message
 * @param msg The message
 */
void updateStatus(String msg);

Fixed version (ground truth):
/** 
 * Updates the current state message.
 * @param msg The message
 */
void updateStatus(String msg);
Program: 62635
Project: 62635
Buggy source:
/** 
 * Adds a new message that won't be overwritten by {#updateStatus(String)}
 * @param msg The message
 */
void addStatus(String msg);

Fixed version (ground truth):
/** 
 * Adds a new message that won't be overwritten by {#updateStatus(String)}.
 * @param msg The message
 */
void addStatus(String msg);
Program: 62636
Project: 62636
Buggy source:
/** 
 * Prints a warning message
 * @param msg The warning message
 */
void warning(String msg);

Fixed version (ground truth):
/** 
 * Prints a warning message.
 * @param msg The warning message
 */
void warning(String msg);
Program: 62637
Project: 62637
Buggy source:
/** 
 * Indicates progress by number
 * @param number The number
 */
void indicateProgress(int number);

Fixed version (ground truth):
/** 
 * Indicates progress by number.
 * @param number The number
 */
void indicateProgress(int number);
Program: 62638
Project: 62638
Buggy source:
/** 
 * Use to log an error
 * @param error The error
 */
void error(Throwable error);

Fixed version (ground truth):
/** 
 * Use to log an error.
 * @param error The error
 */
void error(Throwable error);
Program: 62639
Project: 62639
Buggy source:
/** 
 * Synonym for #log
 * @param msg The message to log
 */
void info(String msg);

Fixed version (ground truth):
/** 
 * Synonym for #log.
 * @param msg The message to log
 */
void info(String msg);
Program: 62640
Project: 62640
Buggy source:
/** 
 * Outputs a verbose message
 * @param msg The message
 */
void verbose(String msg);

Fixed version (ground truth):
/** 
 * Outputs a verbose message.
 * @param msg The message
 */
void verbose(String msg);
Program: 62641
Project: 62641
Buggy source:
public ConsolePrintStream(PrintStream out){
  super(out,true);
}

Fixed version (ground truth):
/** 
 * @param out The print stream
 */
public ConsolePrintStream(PrintStream out){
  super(out,true);
}
Program: 62642
Project: 62642
Buggy source:
public PrintStream getTargetOut(){
  return (PrintStream)out;
}

Fixed version (ground truth):
/** 
 * @return The print stream
 */
public PrintStream getTargetOut(){
  return (PrintStream)out;
}
Program: 62643
Project: 62643
Buggy source:
public JdkApiMacro(String macroName,Map<String,Object> config){
  super(macroName,config);
}

Fixed version (ground truth):
/** 
 * @param macroName The macro name
 * @param config    The configuration
 */
public JdkApiMacro(String macroName,Map<String,Object> config){
  super(macroName,config);
}
Program: 62644
Project: 62644
Buggy source:
public JeeApiMacro(String macroName,Map<String,Object> config){
  super(macroName,config);
}

Fixed version (ground truth):
/** 
 * @param macroName The macro name
 * @param config    The configuration
 */
public JeeApiMacro(String macroName,Map<String,Object> config){
  super(macroName,config);
}
Program: 62645
Project: 62645
Buggy source:
public ReactiveStreamsApiMacro(String macroName,Map<String,Object> config){
  super(macroName,config);
}

Fixed version (ground truth):
/** 
 * @param macroName The macro name
 * @param config    The configuration
 */
public ReactiveStreamsApiMacro(String macroName,Map<String,Object> config){
  super(macroName,config);
}
Program: 62646
Project: 62646
Buggy source:
public RxJavaApiMacro(String macroName,Map<String,Object> config){
  super(macroName,config);
}

Fixed version (ground truth):
/** 
 * @param macroName The macro name
 * @param config    The configuration
 */
public RxJavaApiMacro(String macroName,Map<String,Object> config){
  super(macroName,config);
}
Program: 62647
Project: 62647
Buggy source:
/** 
 * Resolves a type name for the given name
 * @param type The type
 * @return The type reference
 */
String resolveTypeName(TypeMirror type){
  Object reference=resolveTypeReference(type);
  if (reference instanceof Class) {
    return ((Class)reference).getName();
  }
  return reference.toString();
}

Fixed version (ground truth):
/** 
 * Resolves a type name for the given name.
 * @param type The type
 * @return The type reference
 */
String resolveTypeName(TypeMirror type){
  Object reference=resolveTypeReference(type);
  if (reference instanceof Class) {
    return ((Class)reference).getName();
  }
  return reference.toString();
}
Program: 62648
Project: 62648
Buggy source:
public DiscoveryClientCacheConfiguration(ApplicationConfiguration applicationConfiguration){
  super(CACHE_NAME,applicationConfiguration);
  setExpireAfterAccess(Duration.ofSeconds(30));
  setExpireAfterWrite(Duration.ofSeconds(30));
  setInitialCapacity(5);
}

Fixed version (ground truth):
/** 
 * @param applicationConfiguration The application configuration
 */
@SuppressWarnings("String_Node_Str") public DiscoveryClientCacheConfiguration(ApplicationConfiguration applicationConfiguration){
  super(CACHE_NAME,applicationConfiguration);
  setExpireAfterAccess(Duration.ofSeconds(30));
  setExpireAfterWrite(Duration.ofSeconds(30));
  setInitialCapacity(5);
}
Program: 62649
Project: 62649
Buggy source:
public NettyByteBufferFactory(ByteBufAllocator allocator){
  this.allocator=allocator;
}

Fixed version (ground truth):
/** 
 * @param allocator The {@link ByteBufAllocator}
 */
public NettyByteBufferFactory(ByteBufAllocator allocator){
  this.allocator=allocator;
}
Program: 62650
Project: 62650
Buggy source:
/** 
 * @param userFetcher Fetches users from persistence
 * @param passwordEncoder Collaborator which checks if a raw password matches an encoded password
 * @param authoritiesFetcher Fetches authorities for a particular user
 */
public DelegatingAuthenticationProvider(UserFetcher userFetcher,PasswordEncoder passwordEncoder,AuthoritiesFetcher authoritiesFetcher){
  this.userFetcher=userFetcher;
  this.passwordEncoder=passwordEncoder;
  this.authoritiesFetcher=authoritiesFetcher;
}

Fixed version (ground truth):
/** 
 * @param userFetcher        Fetches users from persistence
 * @param passwordEncoder    Collaborator which checks if a raw password matches an encoded password
 * @param authoritiesFetcher Fetches authorities for a particular user
 */
public DelegatingAuthenticationProvider(UserFetcher userFetcher,PasswordEncoder passwordEncoder,AuthoritiesFetcher authoritiesFetcher){
  this.userFetcher=userFetcher;
  this.passwordEncoder=passwordEncoder;
  this.authoritiesFetcher=authoritiesFetcher;
}
Program: 62651
Project: 62651
Buggy source:
/** 
 * @param authenticator {@link Authenticator} collaborator
 * @param loginHandler A collaborator which helps to build HTTP response depending on success or failure.
 * @param eventPublisher The application event publisher
 */
public LoginController(Authenticator authenticator,LoginHandler loginHandler,ApplicationEventPublisher eventPublisher){
  this.authenticator=authenticator;
  this.loginHandler=loginHandler;
  this.eventPublisher=eventPublisher;
}

Fixed version (ground truth):
/** 
 * @param authenticator  {@link Authenticator} collaborator
 * @param loginHandler   A collaborator which helps to build HTTP response depending on success or failure.
 * @param eventPublisher The application event publisher
 */
public LoginController(Authenticator authenticator,LoginHandler loginHandler,ApplicationEventPublisher eventPublisher){
  this.authenticator=authenticator;
  this.loginHandler=loginHandler;
  this.eventPublisher=eventPublisher;
}
Program: 62652
Project: 62652
Buggy source:
/** 
 * @param usernamePasswordCredentials An instance of {@link UsernamePasswordCredentials} in the body payload
 * @param request The {@link HttpRequest} being executed
 * @return An AccessRefreshToken encapsulated in the HttpResponse or a failure indicated by the HTTP status
 */
@Consumes({MediaType.APPLICATION_FORM_URLENCODED,MediaType.APPLICATION_JSON}) @Post public Single<HttpResponse> login(@Body UsernamePasswordCredentials usernamePasswordCredentials,HttpRequest<?> request){
  Flowable<AuthenticationResponse> authenticationResponseFlowable=Flowable.fromPublisher(authenticator.authenticate(usernamePasswordCredentials));
  return authenticationResponseFlowable.map(authenticationResponse -> {
    if (authenticationResponse.isAuthenticated()) {
      UserDetails userDetails=(UserDetails)authenticationResponse;
      eventPublisher.publishEvent(new LoginSuccessfulEvent(userDetails));
      return loginHandler.loginSuccess(userDetails,request);
    }
 else {
      AuthenticationFailed authenticationFailed=(AuthenticationFailed)authenticationResponse;
      eventPublisher.publishEvent(new LoginFailedEvent(authenticationFailed));
      return loginHandler.loginFailed(authenticationFailed);
    }
  }
).first(HttpResponse.status(HttpStatus.UNAUTHORIZED));
}

Fixed version (ground truth):
/** 
 * @param usernamePasswordCredentials An instance of {@link UsernamePasswordCredentials} in the body payload
 * @param request                     The {@link HttpRequest} being executed
 * @return An AccessRefreshToken encapsulated in the HttpResponse or a failure indicated by the HTTP status
 */
@Consumes({MediaType.APPLICATION_FORM_URLENCODED,MediaType.APPLICATION_JSON}) @Post public Single<HttpResponse> login(@Body UsernamePasswordCredentials usernamePasswordCredentials,HttpRequest<?> request){
  Flowable<AuthenticationResponse> authenticationResponseFlowable=Flowable.fromPublisher(authenticator.authenticate(usernamePasswordCredentials));
  return authenticationResponseFlowable.map(authenticationResponse -> {
    if (authenticationResponse.isAuthenticated()) {
      UserDetails userDetails=(UserDetails)authenticationResponse;
      eventPublisher.publishEvent(new LoginSuccessfulEvent(userDetails));
      return loginHandler.loginSuccess(userDetails,request);
    }
 else {
      AuthenticationFailed authenticationFailed=(AuthenticationFailed)authenticationResponse;
      eventPublisher.publishEvent(new LoginFailedEvent(authenticationFailed));
      return loginHandler.loginFailed(authenticationFailed);
    }
  }
).first(HttpResponse.status(HttpStatus.UNAUTHORIZED));
}
Program: 62653
Project: 62653
Buggy source:
/** 
 * @param object The bean
 * @return The lock on the object
 */
ReadWriteLock getLock(Object object){
  ReadWriteLock readWriteLock=locks.get(object);
  if (readWriteLock == null) {
    throw new IllegalStateException("String_Node_Str" + object);
  }
  return readWriteLock;
}

Fixed version (ground truth):
/** 
 * @param object The bean
 * @return The lock on the object
 */
protected ReadWriteLock getLock(Object object){
  ReadWriteLock readWriteLock=locks.get(object);
  if (readWriteLock == null) {
    throw new IllegalStateException("String_Node_Str" + object);
  }
  return readWriteLock;
}
Program: 62654
Project: 62654
Buggy source:
public DefaultCacheManager(SyncCache<C>... caches){
  if (ArrayUtils.isEmpty(caches)) {
    this.cacheMap=Collections.emptyMap();
  }
 else {
    this.cacheMap=new LinkedHashMap<>(caches.length);
    for (    SyncCache<C> cache : caches) {
      this.cacheMap.put(cache.getName(),cache);
    }
  }
}

Fixed version (ground truth):
/** 
 * Create default cache manager for the given caches.
 * @param caches List of synchronous cache implementations
 */
public DefaultCacheManager(SyncCache<C>... caches){
  if (ArrayUtils.isEmpty(caches)) {
    this.cacheMap=Collections.emptyMap();
  }
 else {
    this.cacheMap=new LinkedHashMap<>(caches.length);
    for (    SyncCache<C> cache : caches) {
      this.cacheMap.put(cache.getName(),cache);
    }
  }
}