}
}

private InetAddress discoverWitnessService() throws IOException {
    // Try the same server first
    InetAddress serverAddress = transport.getRemoteAddress();
    
    if (isWitnessServiceAvailable(serverAddress)) {
        return serverAddress;
    }
    
    // Query for cluster witness service via DNS
    try {
        String clusterName = getClusterName(serverAddress);
        if (clusterName != null) {

  }

  public void testNullsOnReturnValues_bad() throws Exception {
    try {
      tester.forAllPublicStaticMethods(BadNullsFactory.class).thatReturn(Object.class).testNulls();
    } catch (AssertionError expected) {
      return;
    }
    fail();
  }

  public void testNullsOnReturnValues_returnTypeFiltered() throws Exception {
    try {
      tester
          .forAllPublicStaticMethods(BadNullsFactory.class)

     */
    public static String getCanonicalPath(final File file) {
        assertArgumentNotNull("file", file);

        try {
            return file.getCanonicalPath();
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }
    }

    /**

        lock.writeLock().lock();
        try {
            if (children.remove(childName) != null) {
                hasChanges = true;
                lastUpdateTime = System.currentTimeMillis();
            }
        } finally {
            lock.writeLock().unlock();
        }
    }
    
    public List<FileInfo> getChildren() {
        lock.readLock().lock();
        try {

        Thread th = new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException ignore) {}
            deferred.reject(new SuggesterException("test"));
        });
        th.start();

        try {
            deferred.promise().getResponse(10, TimeUnit.SECONDS);
            fail();

        try {
            labelTypeHelper.refresh(labelTypeList);
            // Method is protected, so we test it indirectly through refresh
        } catch (Exception e) {
            fail("buildLabelTypePatternList() should not throw an exception: " + e.getMessage());
        }
    }

    public void test_labelTypePattern_constructor() {
        try {

    /**
     * Test AutoCloseable behavior with try-with-resources
     */
    @Test
    void testAutoCloseable() throws CIFSException {
        // Create a mock that tracks close calls
        SmbWatchHandle autoCloseableHandle = mock(SmbWatchHandle.class);
        when(autoCloseableHandle.watch()).thenReturn(mockNotifications);

        // Use try-with-resources
        try (SmbWatchHandle handle = autoCloseableHandle) {

            }
        }

        final SmbTreeConnection treeConn = SmbTreeConnection.create(tc);
        try (SmbTreeHandleImpl th = treeConn.connectHost(locator, locator.getServerWithDfs());
                SmbSessionImpl session = th.getSession();
                SmbTransportImpl transport = session.getTransport()) {
            try {
                entries = doMsrpcShareEnum(tc, locator, transport.getRemoteAddress());

        for (int i = 0; i < 3; i++) {
            rateLimiter.checkAttempt(username, ip);
            rateLimiter.recordFailure(username, ip);
        }

        // Try after lockout (will be blocked)
        try {
            rateLimiter.checkAttempt(username, ip);
        } catch (SmbException e) {
            // Expected
        }

        // Block an IP
        String ip2 = "192.168.1.11";

                    if (isQualifiedForInterpolation(field, type)) {
                        boolean isAccessible = field.isAccessible();
                        field.setAccessible(true);
                        try {
                            try {
                                if (String.class == type) {
                                    String value = (String) field.get(target);
                                    if (value != null) {