void testGetDefaultPort() {
        // Arrange
        Handler handler = newHandler();
        // Act & Assert
        assertEquals(SmbConstants.DEFAULT_PORT, handler.getDefaultPort(), "Default port should match SmbConstants");
    }

    @Test
    @DisplayName("openConnection returns SmbFile using provided CIFSContext")

        public void columnId() {
            doColumn("_id");
        }

        public void columnAuthRealm() {
            doColumn("authRealm");
        }

        public void columnCreatedBy() {
            doColumn("createdBy");
        }

        public void columnCreatedTime() {
            doColumn("createdTime");
        }

        public void columnHostname() {
            doColumn("hostname");

        waitJob(NAME_PREFIX);
        refresh();

        ThreadUtil.sleep(3000);
    }

    @BeforeEach
    protected void init() {
        refresh();
    }

    @AfterEach
    protected void tearDown() {
    }

    @AfterAll
    protected static void tearDownAll() {
        final List<Map<String, Object>> jobLogList = readJobLog(NAME_PREFIX);
        for (Map<String, Object> elem : jobLogList) {

  }

  public void testWildcardFuture() {
    SettableFuture<String> settable = SettableFuture.create();
    ListenableFuture<?> f = settable;
    FutureCallback<@Nullable Object> callback =
        new FutureCallback<@Nullable Object>() {
          @Override
          public void onSuccess(@Nullable Object result) {}

          @Override
          public void onFailure(Throwable t) {}
        };

        cifsContextWrapper = new CIFSContextWrapper(mockDelegate);
    }

    @Test
    void testConstructor() {
        // Verify that the delegate is correctly set
        assertNotNull(cifsContextWrapper);
    }

    @Test
    void testGetSmbResource() throws CIFSException, MalformedURLException {
        // Test get(String url) method

  }

  @Before
  public void init() {
    network = createGraph();
    if (network instanceof MutableNetwork) {
      networkAsMutableNetwork = (MutableNetwork<Integer, String>) network;
    }
  }

  @After
  public void validateNetworkState() {
    validateNetwork(network);
  }

  static <N, E> void validateNetwork(Network<N, E> network) {

    @Override
    public boolean isSMB2() throws SmbException {
        return this.smb2 || getNegotiateResponse() instanceof Smb2NegotiateResponse;
    }

    /**
     * @param digest
     */
    public void setDigest(final SMBSigningDigest digest) {
        this.digest = digest;
    }

    /**
     * @return the digest
     */
    public SMBSigningDigest getDigest() {
        return this.digest;
    }

    @Mock
    private SmbTreeHandle smbTreeHandle;

    @BeforeEach
    void setUp() throws CIFSException {
        // Reset mock before each test if necessary, though MockitoExtension does this.
    }

    /**
     * Test that getTree() returns the correct SmbTreeHandle.
     */
    @Test
    void testGetTree() {
        when(smbFileHandle.getTree()).thenReturn(smbTreeHandle);

  static final Predicate<Entry<String, Integer>> CORRECT_LENGTH =
      input -> input.getKey().length() == input.getValue();

  abstract Map<String, Integer> createUnfiltered();

  public void testFilteredKeysIllegalPut() {
    Map<String, Integer> unfiltered = createUnfiltered();
    Map<String, Integer> filtered = Maps.filterKeys(unfiltered, NOT_LENGTH_3);
    filtered.put("a", 1);
    filtered.put("b", 2);

  public void testOf0() {
    assertThat(ImmutableLongArray.of().asList()).isEmpty();
  }

  public void testOf1() {
    assertThat(ImmutableLongArray.of(0).asList()).containsExactly(0L);
  }

  public void testOf2() {
    assertThat(ImmutableLongArray.of(0, 1).asList()).containsExactly(0L, 1L).inOrder();
  }

  public void testOf3() {