docs: public static ConnectionPool newLdaptiveBlockingConnectionPool(final AbstractLdapProperties l) {
          val bindCf = newLdaptiveConnectionFactory(l);
          val pc = newLdaptivePoolConfig(l);
          val cp = new BlockingConnectionPool(pc, bindCf);
  
          cp.setBlockWaitTime(Beans.newDuration(l.getBlockWaitTime()));
          cp.setPoolConfig(pc);
  
          val strategy = new IdlePruneStrategy();
          strategy.setIdleTime(Beans.newDuration(l.getIdleTime()));
          strategy.setPrunePeriod(Beans.newDuration(l.getPrunePeriod()));
  
          cp.setPruneStrategy(strategy);
  
          switch (l.getValidator().getType().trim().toLowerCase()) {
              case "compare":
                  val compareRequest = new CompareRequest();
                  compareRequest.setDn(l.getValidator().getDn());
                  compareRequest.setAttribute(new LdapAttribute(l.getValidator().getAttributeName(),
                      l.getValidator().getAttributeValues().toArray(ArrayUtils.EMPTY_STRING_ARRAY)));
  
                  if (l.isFollowReferrals()) {
                      compareRequest.setReferralHandler(new SearchReferralHandler());
                  }
                  cp.setValidator(new CompareValidator(compareRequest));
                  break;
              case "none":
                  LOGGER.debug("No validator is configured for the LDAP connection pool of [{}]", l.getLdapUrl());
                  break;
              case "search":
              default:
                  val searchRequest = new SearchRequest();
                  searchRequest.setBaseDn(l.getValidator().getBaseDn());
                  searchRequest.setSearchFilter(new SearchFilter(l.getValidator().getSearchFilter()));
                  searchRequest.setReturnAttributes(ReturnAttributes.NONE.value());
                  searchRequest.setSearchScope(SearchScope.valueOf(l.getValidator().getScope()));
                  searchRequest.setSizeLimit(1L);
                  if (l.isFollowReferrals()) {
                      searchRequest.setReferralHandler(new SearchReferralHandler());
                  }
                  cp.setValidator(new SearchValidator(searchRequest));
                  break;
          }
  
          cp.setFailFastInitialize(l.isFailFast());
  
          if (StringUtils.isNotBlank(l.getPoolPassivator())) {
              val pass =
                  AbstractLdapProperties.LdapConnectionPoolPassivator.valueOf(l.getPoolPassivator().toUpperCase());
              switch (pass) {
                  case CLOSE:
                      cp.setPassivator(new ClosePassivator());
                      LOGGER.debug("Created [{}] passivator for [{}]", l.getPoolPassivator(), l.getLdapUrl());
                      break;
                  case BIND:
                      if (StringUtils.isNotBlank(l.getBindDn()) && StringUtils.isNoneBlank(l.getBindCredential())) {
                          val bindRequest = new BindRequest();
                          bindRequest.setDn(l.getBindDn());
                          bindRequest.setCredential(new Credential(l.getBindCredential()));
                          cp.setPassivator(new BindPassivator(bindRequest));
                          LOGGER.debug("Created [{}] passivator for [{}]", l.getPoolPassivator(), l.getLdapUrl());
                      } else {
                          val values = Arrays.stream(AbstractLdapProperties.LdapConnectionPoolPassivator.values())
                              .filter(v -> v != AbstractLdapProperties.LdapConnectionPoolPassivator.BIND)
                              .collect(Collectors.toList());
                          LOGGER.warn("[{}] pool passivator could not be created for [{}] given bind credentials are not specified. "
                                  + "If you are dealing with LDAP in such a way that does not require bind credentials, you may need to "
                                  + "set the pool passivator setting to one of [{}]",
                              l.getPoolPassivator(), l.getLdapUrl(), values);
                      }
                      break;
                  default:
                      break;
              }
          }
  
          LOGGER.debug("Initializing ldap connection pool for [{}] and bindDn [{}]", l.getLdapUrl(), l.getBindDn());
          cp.initialize();
          return cp;
      }