}

        @Override
        public void dispose() {
            ++count;
            names += name;
        }
    }

    /**
     *
     */
    public class TestDisposable2 implements Disposable {
        @Override
        public void dispose() {
            ++count;
            throw new RuntimeException();
        }
    }

        byte[] buffer = new byte[] { 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; // count = 10

        int bytesRead = response.readParameterWordsWireFormat(buffer, 0);

        // The count should be read from the buffer.
        assertEquals(10L, response.count);
        // The method should return the number of bytes read.
        assertEquals(8, bytesRead);
    }

    /**

        verify(mockNdrBuffer).align(4);
        verify(mockNdrBuffer).enc_ndr_long(transSidArray.count);
        verify(mockNdrBuffer).enc_ndr_referent(transSidArray.sids, 1);

        verify(mockDeferredNdrBuffer).enc_ndr_long(transSidArray.count);
        verify(mockDeferredNdrBuffer).advance(12 * transSidArray.count);
        verify(transSidArray.sids[0]).encode(any(NdrBuffer.class)); // Buffer reassignment happens inside encode

         * Number of DFS entries in the array
         */
        public int count;
        /**
         * Array of DFS information level 1 structures
         */
        public DfsInfo1[] s;

        @Override
        public void encode(NdrBuffer _dst) throws NdrException {
            _dst.align(4);
            _dst.enc_ndr_long(this.count);
            _dst.enc_ndr_referent(this.s, 1);

    assertThat(emptyAccumulator.count()).isEqualTo(0);
    assertThat(emptyAccumulatorByAddAllEmptyPairedStats.count()).isEqualTo(0);
    assertThat(oneValueAccumulator.count()).isEqualTo(1);
    assertThat(oneValueAccumulatorByAddAllEmptyPairedStats.count()).isEqualTo(1);
    assertThat(twoValuesAccumulator.count()).isEqualTo(2);
    assertThat(twoValuesAccumulatorByAddAllPartitionedPairedStats.count()).isEqualTo(2);

     * Gets the total number of records that match the search criteria.
     *
     * @return The total record count
     */
    public long getAllRecordCount() {
        return allRecordCount;
    }

    /**
     * Gets the relation type indicating how the record count should be interpreted.
     *
     * @return The record count relation (e.g., "eq" for exact, "gte" for greater than or equal)
     */

    void testGetEntries_largeNumberOfRoots() throws Exception {
        // Create array with many entries
        int count = 100;
        netdfs.DfsEnumArray200 largeArray = new netdfs.DfsEnumArray200();
        largeArray.count = count;
        largeArray.s = new netdfs.DfsInfo200[count];

        for (int i = 0; i < count; i++) {
            netdfs.DfsInfo200 entry = new netdfs.DfsInfo200();
            entry.dfs_name = "share_" + i;

     *
     * @param allRecordCount The total record count
     */
    public void setAllRecordCount(final long allRecordCount) {
        this.allRecordCount = allRecordCount;
    }

    /**
     * Sets the relation type for the record count (e.g., "eq", "gte").
     *
     * @param allRecordCountRelation The record count relation
     */

                }
                file.send(reqx, rspx);
                fp += rspx.count;
                len -= rspx.count;
                off += rspx.count;
            } else {
                req.setParam(file.fid, fp, len - w, b, off, w);
                fp += rsp.count;
                len -= rsp.count;
                off += rsp.count;
                file.send(req, rsp);
            }
        } while (len > 0);

        versionNo = null;

    }

    /**
     * Get the all record count.
     * @return The all record count.
     */
    public int getAllRecordCount() {
        return allRecordCount;
    }

    /**
     * Set the all record count.
     * @param allRecordCount The all record count.
     */
    public void setAllRecordCount(final int allRecordCount) {