docs: private J2CGlobalConfigProperties processServerPoolManagerProperties(AbstractConnectionFactoryService svc, Map<String, Object> properties) throws ResourceException {
          @SuppressWarnings("unchecked")
          Map<String, Object> map = properties == null ? Collections.EMPTY_MAP : new HashMap<String, Object>(properties);
          int agedTimeout, connectionTimeout, maxIdleTime, maxNumberOfMCsAllowableInThread, maxPoolSize, minPoolSize, numConnectionsPerThreadLocal, reapTime;
          PurgePolicy purgePolicy;
  
          if (svc != null) {
              //Cache the value of svc.isLibertyConnectionPoolingDisabled() for the Connection Manager modified code path
              disableLibertyConnectionPool = svc.isLibertyConnectionPoolingDisabled();
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                  Tr.debug(this, tc, "Setting disableLibertyConnectionManager to " + disableLibertyConnectionPool);
          }
  
          if (disableLibertyConnectionPool) {
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                  Tr.debug(this, tc, "Overriding config with values for a disabled connection pool.");
              agedTimeout = 0; //0 discards every connection disabling Liberty connection pooling
              connectionTimeout = -1;
              maxIdleTime = -1;
              maxPoolSize = 0;
              minPoolSize = 0;
              purgePolicy = PurgePolicy.FailingConnectionOnly;
              reapTime = -1;
              maxNumberOfMCsAllowableInThread = 0;
              numConnectionsPerThreadLocal = 0;
          } else {
              agedTimeout = validateProperty(map, J2CConstants.POOL_AgedTimeout, -1, TimeUnit.SECONDS, -1, Integer.MAX_VALUE, true, connectorSvc);
              connectionTimeout = validateProperty(map, J2CConstants.POOL_ConnectionTimeout, 30, TimeUnit.SECONDS, -1, Integer.MAX_VALUE, true, connectorSvc);
              maxIdleTime = validateProperty(map, MAX_IDLE_TIME, ConnectionPoolProperties.DEFAULT_UNUSED_TIMEOUT, TimeUnit.SECONDS, -1, Integer.MAX_VALUE, false, connectorSvc);
              maxNumberOfMCsAllowableInThread = validateProperty(map, MAX_CONNECTIONS_PER_THREAD, 0, null, 0, Integer.MAX_VALUE, true, connectorSvc);
              maxPoolSize = validateProperty(map, MAX_POOL_SIZE, 50, null, 0, Integer.MAX_VALUE, true, connectorSvc);
              minPoolSize = 0;
              if (maxPoolSize == 0)
                  minPoolSize = validateProperty(map, MIN_POOL_SIZE, 0, null, 0, Integer.MAX_VALUE, true, connectorSvc);
              else
                  minPoolSize = validateProperty(map, MIN_POOL_SIZE, 0, null, 0, maxPoolSize, true, connectorSvc);
  
              numConnectionsPerThreadLocal = validateProperty(map, NUM_CONNECTIONS_PER_THREAD_LOCAL, ConnectionPoolProperties.DEFAULT_numConnectionsPerThreadLocal,
                                                              null, 0, Integer.MAX_VALUE, true, connectorSvc);
              reapTime = validateProperty(map, J2CConstants.POOL_ReapTime, ConnectionPoolProperties.DEFAULT_REAP_TIME, TimeUnit.SECONDS, -1, Integer.MAX_VALUE, false,
                                          connectorSvc);
  
              /*
               * The purge policy has three property values in Liberty. The three same combinations
               * can be set in twas, but two properties need to be used.
               * EntirePool --> EntirePool
               * FailingConnectionOnly --> FailingConnectionOnly with defaultPretestOptimizationOverride = false
               * ValidateAllConnections --> FailingConnectionOnly with defaultPretestOptimizationOverride = true
               */
              purgePolicy = validateProperty(map, J2CConstants.POOL_PurgePolicy, PurgePolicy.EntirePool, PurgePolicy.class, connectorSvc);
          }
  
          boolean throwExceptionOnMCThreadCheck = false;
  
          // Identify unrecognized properties - TODO: enable when we have a stricter variant of onError
          //map.remove(ID);
          //for (String name : map.keySet())
          //    if (!name.contains(".")) { // Ignore config service properties that contain .
          //        ResourceException failure = connectorSvc.ignoreWarnOrFail(tc, null, ResourceException.class, "UNKNOWN_PROP_J2CA8010",
          //                                                                          CONNECTION_MANAGER, name);
          //        if (failure != null)
          //            throw failure;
          //    }
  
          if (pm != null) {
              // Connection pool exists, dynamically update values that have changed.
              if (pm.gConfigProps.getAgedTimeout() != agedTimeout)
                  pm.gConfigProps.setAgedTimeout(agedTimeout);
  
              if (pm.gConfigProps.getConnctionWaitTime() != connectionTimeout)
                  pm.gConfigProps.setConnectionTimeout(connectionTimeout);
  
              if (pm.gConfigProps.getUnusedTimeout() != maxIdleTime)
                  pm.gConfigProps.setUnusedTimeout(maxIdleTime);
  
              if (pm.gConfigProps.getMaxConnections() != maxPoolSize)
                  pm.gConfigProps.setMaxConnections(maxPoolSize);
  
              if (pm.gConfigProps.getMinConnections() != minPoolSize)
                  pm.gConfigProps.setMinConnections(minPoolSize);
  
              if (!pm.gConfigProps.getPurgePolicy().equals(purgePolicy))
                  pm.gConfigProps.setPurgePolicy(purgePolicy);
  
              if (pm.gConfigProps.getReapTime() != reapTime)
                  pm.gConfigProps.setReapTime(reapTime);
  
              if (pm.gConfigProps.getnumConnectionsPerThreadLocal() != numConnectionsPerThreadLocal)
                  pm.gConfigProps.setnumConnectionsPerThreadLocal(numConnectionsPerThreadLocal);
  
              if (pm.gConfigProps.getMaxNumberOfMCsAllowableInThread() != maxNumberOfMCsAllowableInThread)
                  pm.gConfigProps.setMaxNumberOfMCsAllowableInThread(maxNumberOfMCsAllowableInThread);
  
              return null;
          } else {
              // Connection pool does not exist, create j2c global configuration properties for creating pool.
              return new J2CGlobalConfigProperties(name, svc, false, // logMissingTranContext
                              200, // maxSharedBuckets,
                              100, // maxFreePoolHashSize,
                              false, // diagnoseConnectionUsage,
                              connectionTimeout, maxPoolSize, minPoolSize, purgePolicy, reapTime, maxIdleTime, agedTimeout, ConnectionPoolProperties.DEFAULT_HOLD_TIME_LIMIT, 0, // commit priority not supported
                              numConnectionsPerThreadLocal, maxNumberOfMCsAllowableInThread, throwExceptionOnMCThreadCheck);
  
          }
      }