this.releases = new LinkedList<>();
        } else {
            this.acquires = null;
            this.releases = null;
        }
    }

    boolean matches(final String shr, final String servc) {
        return this.share.equalsIgnoreCase(shr) && (servc == null || servc.startsWith("??") || this.service.equalsIgnoreCase(servc));
    }

    @Override

            if (this.root_directory != null) {
                _dst = _dst.deferred;
                this.root_directory.encode(_dst);

            }
            if (this.object_name != null) {
                _dst = _dst.deferred;
                this.object_name.encode(_dst);

            }
            if (this.security_quality_of_service != null) {
                _dst = _dst.deferred;

            if (netname != null) {
                _dst = _dst.deferred;
                _dst.enc_ndr_string(netname);

            }
            if (remark != null) {
                _dst = _dst.deferred;
                _dst.enc_ndr_string(remark);

            }
            if (path != null) {
                _dst = _dst.deferred;

        assertEquals("first,null,third", result);
    }

    @Test
    @DisplayName("Should handle all null elements")
    void testJoinWithAllNullElements() {
        String result = StringUtil.join(",", null, null, null);
        assertEquals("null,null,null", result);
    }

    @Test
    @DisplayName("Should handle empty string elements")
    void testJoinWithEmptyStringElements() {

    }

    @Test
    @DisplayName("Constructor should handle null tree handle")
    void testConstructor_NullTreeHandle_ThrowsNPE() throws Exception {
        // Given: Valid parent but null tree handle
        when(locator.getType()).thenReturn(SmbConstants.TYPE_WORKGROUP);
        when(locator.getURL()).thenReturn(createSmbURL("smb://"));

    MEMBER_ID INTEGER IDENTITY NOT NULL PRIMARY KEY,
    MEMBER_NAME VARCHAR(200) NOT NULL,
    MEMBER_ACCOUNT VARCHAR(50) NOT NULL,
    MEMBER_STATUS_CODE CHAR(3) NOT NULL,
    FORMALIZED_DATETIME DATETIME,
    BIRTHDATE DATE,
    REGISTER_DATETIME DATETIME NOT NULL,
    REGISTER_USER VARCHAR(200) NOT NULL,
    UPDATE_DATETIME DATETIME NOT NULL,
    UPDATE_USER VARCHAR(200) NOT NULL,
    VERSION_NO BIGINT NOT NULL

        if (_conditionQuery != null) {
            QueryBuilder queryBuilder = _conditionQuery.getQuery();
            if (queryBuilder != null) {
                builder.setQuery(queryBuilder);
            }
            _conditionQuery.getFieldSortBuilderList().forEach(sort -> {
                builder.addSort(sort);
            });
        }

        if (_conditionAggregation != null) {

        assertEquals(1, tags.length);
        assertEquals("PrunedTag [tag=a, id=null, css=null, attrName=null, attrValue=null]", tags[0].toString());

        tags = PrunedTag.parse("a#test");
        assertEquals(1, tags.length);
        assertEquals("PrunedTag [tag=a, id=test, css=null, attrName=null, attrValue=null]", tags[0].toString());

        tags = PrunedTag.parse("a.test");
        assertEquals(1, tags.length);

        current.elemCount = 0;
        // Also clear these fields so that one deleted Entry doesn't retain all elements.
        current.left = null;
        current.right = null;
        current.pred = null;
        current.succ = null;

        current = next;
      }
      successor(header, header);
      rootReference.clear();
    } else {

   *     for the keys
   */
  @CanIgnoreReturnValue
  public @Nullable V erase(@Nullable Object rowKey, @Nullable Object columnKey) {
    Integer rowIndex = rowKeyToIndex.get(rowKey);
    Integer columnIndex = columnKeyToIndex.get(columnKey);
    if (rowIndex == null || columnIndex == null) {
      return null;
    }