}

    @Test
    @DisplayName("Should handle null properties gracefully")
    void testNullProperties() throws CIFSException {
        // PropertyConfiguration doesn't handle null properties
        // It should throw NullPointerException
        assertThrows(NullPointerException.class, () -> {
            new PropertyConfiguration(null);
        });
    }

    @Test

    }

    /**
     * {@inheritDoc}
     *
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString() {
        String mic = null;
        if (this.getMechanismListMIC() != null) {
            mic = Hexdump.toHexString(this.getMechanismListMIC(), 0, this.getMechanismListMIC().length);
        }

        assertEquals(0, unicodeStringTrue.maximum_length, "Maximum length should be 0 for empty string");
        assertNull(unicodeStringTrue.buffer, "Buffer should be null for empty string");

        // Test with zterm = false
        UnicodeString unicodeStringFalse = new UnicodeString(false);
        assertFalse(unicodeStringFalse.zterm, "zterm should be false");

                        // Get or create tree
                        SmbTreeImpl tree = session.getSmbTree(share, null);
                        assertNotNull(tree, "Tree should not be null");

                        // Verify we can acquire the tree
                        tree.acquire();
                        successCount.incrementAndGet();

    this.singleValue = singleValue;
    this.inverse = null;
  }

  private SingletonImmutableBiMap(K singleKey, V singleValue, ImmutableBiMap<V, K> inverse) {
    this.singleKey = singleKey;
    this.singleValue = singleValue;
    this.inverse = inverse;
  }

  @Override
  public @Nullable V get(@Nullable Object key) {
    return singleKey.equals(key) ? singleValue : null;
  }

  @Override
  public int size() {

        when(mockConfig.isDfsDisabled()).thenReturn(false);
        when(mockContext.getCredentials()).thenReturn(mockCredentials);
        when(mockCredentials.getUserDomain()).thenReturn(null);
        assertFalse(dfsResolver.isTrustedDomain(mockContext, "anyDomain"));
    }

    @Test
    void testIsTrustedDomain_EmptyUserDomain() throws CIFSException {

        // The server name is stored in a protected field without a public getter, so we cannot directly test it.
        // We can test the public fields that are set.
        assertEquals(200, dfsRootEnum.level, "The level should be initialized to 200.");
        assertNotNull(dfsRootEnum.info, "The info struct should not be null.");

        userInfoHelper.setCookieSecure(null);

        MockletHttpServletRequest request = getMockRequest();
        request.addHeader("X-Forwarded-Proto", "https");

        assertTrue(userInfoHelper.isSecureCookie());
    }

    public void test_isSecureCookie_noRequest() {
        UserInfoHelper userInfoHelper = new UserInfoHelper();
        userInfoHelper.setCookieSecure(null);

                final BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
                list.forEach(boolQuery::should);
                return boolQuery;
            }
            return null;
        }).filter(q -> q != null).toArray(n -> new QueryBuilder[n]);

        if (queryBuilders.length == 1) {
            builder = queryBuilders[0];
        } else if (queryBuilders.length > 1) {

        this.data = data;
        this.file = null;
    }

    /**
     * Constructs a ContentCache with the given file.
     *
     * @param file the file containing the content
     */
    public ContentCache(final File file) {
        this.data = null;
        this.file = file;
    }

    @Override
    public void close() throws IOException {
        if (file != null) {
            Files.delete(file.toPath());