}
            } catch (Exception e) {
                log.debug("Error releasing tree connection during emergency cleanup", e);
            }

            // Note: resourceLoc is final, cannot be set to null
            // Clear other mutable references would go here

        } catch (Exception e) {
            log.error("Failed to perform emergency tree handle cleanup", e);

        assertArgumentNotNull("builder", builder);
        assertArgumentNotNull("is", is);

        try {
            return builder.parse(is);
        } catch (final SAXException e) {
            throw new SAXRuntimeException(e);
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }
    }

                    return item;
                } catch (final IOException e) {
                    throw new DictionaryException("Failed to write: " + item, e);
                }
            }
            return null;
        }

        @Override
        public void close() {
            try {
                writer.flush();
            } catch (final IOException e) {
                // ignore

        }
        this.response = new NetServerEnum2Response(th.getConfig());

        this.treeHandle = th.acquire();
        try {
            this.next = open();
        } catch (final Exception e) {
            this.treeHandle.release();
            throw e;
        }

    }

    private FileEntry open() throws CIFSException {
        this.treeHandle.send(this.request, this.response);

                    }
                }
            } catch (final ClassNotFoundRuntimeException e) {
                logger.debug("{}.{}.Handler does not exist.", basePackage, protocol, e);
            } catch (final NoSuchFieldRuntimeException e) {
                logger.debug("{}.{}.Handler does not contain PROTOCOL_TYPE.", basePackage, protocol, e);
            } catch (final Exception e) {

            fail("Expected NullPointerException for null data");
        } catch (NullPointerException e) {
            // Expected - cannot create ByteArrayInputStream with null
        } catch (IOException e) {
            fail("Expected NullPointerException, not IOException");
        }
    }

    @Test
    public void testMemoryCacheWithBinaryData() throws IOException {

                tikaExtractor.setSpaceChars(getSpaceChars());
            }
        } catch (final ComponentNotFoundException e) {
            if (logger.isDebugEnabled()) {
                logger.debug("tikaExtractor is not found: {}", e.getMessage().replace('\n', ' '));
            }
        } catch (final Exception e) {
            logger.warn("Failed to initiaize TikaExtractor.", e);
        }
    }

                try {
                    return ni.isLoopback() || !ni.isUp() || ni.isVirtual();
                } catch (Exception e) {
                    return true;
                }
            });
            return interfaces;
        } catch (Exception e) {
            log.warn("Failed to get network interfaces: {}", e.getMessage());
            return Collections.emptyList();
        }

            // - Testing basic RDMA operations
            // - Checking for required native libraries

            return true;
        } catch (ClassNotFoundException e) {
            log.debug("DiSNI not available: {}", e.getMessage());
            return false;
        } catch (UnsatisfiedLinkError e) {
            log.debug("DiSNI native libraries not available: {}", e.getMessage());
            return false;
        }
    }

   */
  static Dispatcher perThreadDispatchQueue() {
    return new PerThreadQueuedDispatcher();
  }

  /**
   * Returns a dispatcher that queues events that are posted in a single global queue. This behavior
   * matches the original behavior of AsyncEventBus exactly, but is otherwise not especially useful.
   * For async dispatch, an {@linkplain #immediate() immediate} dispatcher should generally be
   * preferable.
   */