docs: public void lookForLeaks(boolean force) {
          if (this.leakDetectionInterval < -1) {
              // should never get here, return
              return;
          }
  
          synchronized (this.leakDetectionSyncObject) {
              try {
                  // get current time
                  long now = System.currentTimeMillis();
  
                  if (force == false) {
                      if (this.lastTimeCheck == 0L) {
                          this.lastTimeCheck = now;
                          return;
                      } else if ((now - this.lastTimeCheck) < getLeakDetectionInterval()) {
                          return;
                      }
                  }
  
                  this.lastTimeCheck = now;
                  int iterIndex = 1;
  
                  for (int i = 0; i < this.poolSizes.length; i++) {
                      WsByteBufferImpl buffer = null;
                      Object[] buffers = this.pools[i].getInUse();
                      if (buffers != null) {
                          for (int j = 0; j < buffers.length; j++) {
                              PooledWsByteBufferImpl x = (PooledWsByteBufferImpl) buffers[j];
  
                              if (x.getallBuffers() == null) {
                                  // This can happen because a new buffer has just been
                                  // allocated, but our initialization of it is not
                                  // complete. Don't sync the init, since we don't want
                                  // to add needless logic for the leak code.
                                  continue;
                              }
  
                              Hashtable<?, ?> possibleLeakers = (Hashtable<?, ?>) (x.getallBuffers().clone());
                              Iterator<?> it = possibleLeakers.values().iterator();
  
                              while (it.hasNext()) {
                                  buffer = (WsByteBufferImpl) it.next();
  
                                  if ((now - buffer.getLastAccessTime()) > getLeakDetectionInterval()) {
                                      String sOutput = iterIndex + " Possible Leak Entry: Buffer ID - " + x.getID() +
                                                       "\nNon-Direct Buffer Pool" +
                                                       "\n" + x.toString(buffer.getOwnerID());
                                      try {
                                          FileWriter outFile = new FileWriter(this.leakDetectionOutput, true);
                                          if (iterIndex == 1) {
                                              outFile.write("\n\n\n****  " + (new Date()) + "  ***\n");
                                          } else {
                                              outFile.write("\n----------\n");
                                          }
                                          outFile.write(sOutput);
  
                                          outFile.close();
  
                                      } catch (IOException e) {
                                          // do nothing if we can't print out leak debug info.
                                      }
                                      iterIndex++;
                                  }
                              }
                          }
                      }
                  } // end-non-direct-pool loop
  
                  // check direct pools in the same way
                  for (int i = 0; i < this.poolSizes.length; i++) {
                      WsByteBufferImpl buffer = null;
                      Object[] buffers = this.poolsDirect[i].getInUse();
  
                      if (buffers != null) {
                          for (int j = 0; j < buffers.length; j++) {
                              PooledWsByteBufferImpl x = (PooledWsByteBufferImpl) buffers[j];
  
                              if (x.getallBuffers() == null) {
                                  // This can happen because a new buffer has just been
                                  // allocated, but the our initialization of it is not
                                  // complete. Don't sync the init, since we don't want
                                  // to add needless logic for the leak code.
                                  continue;
                              }
                              Hashtable<?, ?> possibleLeakers = (Hashtable<?, ?>) (x.getallBuffers().clone());
                              Iterator<?> oIterator = possibleLeakers.values().iterator();
  
                              while (oIterator.hasNext()) {
                                  buffer = (WsByteBufferImpl) oIterator.next();
  
                                  if ((now - buffer.getLastAccessTime()) > getLeakDetectionInterval()) {
                                      String sOutput = iterIndex + " Possible Leak Entry: Buffer ID - " + x.getID() +
                                                       "\nDirect Buffer Pool" +
                                                       "\n" + x.toString(buffer.getOwnerID());
                                      try {
                                          FileWriter outFile = new FileWriter(this.leakDetectionOutput, true);
                                          if (iterIndex == 1) {
                                              outFile.write("\n\n\n****  " + (new Date()) + "  ***\n");
                                          } else {
                                              outFile.write("\n----------\n");
                                          }
                                          outFile.write(sOutput);
                                          outFile.close();
                                      } catch (IOException e) {
                                          // do nothing if we can't print out leak debug info.
                                      }
                                      iterIndex++;
                                  }
                              }
                          }
                      }
                  } // end-direct-pool loop
              } catch (NullPointerException xe) {
                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                      Tr.debug(tc, "WsByteBuffer Leak Detection Caught an NPE looking through the inUse tables");
                  }
                  RuntimeException re = new RuntimeException("WsByteBuffer Leak Detection Caught an NPE looking through the inUse table", xe);
                  FFDCFilter.processException(re, getClass().getName(), "932", this);
                  throw re;
              }
          }
      }