// Verify content
        assertEquals(SmbComTransaction.TRANS2_QUERY_FS_INFORMATION, buffer[0]);
        assertEquals(0x00, buffer[1]);
        assertEquals(0x03, buffer[2]); // Low byte of 0x0103
        assertEquals(0x01, buffer[3]); // High byte of 0x0103
    }

    @DisplayName("Test toString with different information levels")
    @ParameterizedTest

  /**
   * Contains the logical entries, in the range of [0, size()). The high bits of each int are the
   * part of the smeared hash of the element not covered by the hashtable mask, whereas the low bits
   * are the "next" pointer (pointing to the next entry in the bucket chain), which will always be
   * less than or equal to the hashtable mask.
   *
   * <pre>
   * hash  = aaaaaaaa
   * mask  = 00000fff

   * of values that will be added, if that knowledge is readily available. It is better to guess a
   * value slightly too high than slightly too low. If the value is not exact, the {@link
   * ImmutableLongArray} that is built will very likely occupy more memory than strictly necessary;
   * to trim memory usage, build using {@code builder.build().trimmed()}.
   */

   * of values that will be added, if that knowledge is readily available. It is better to guess a
   * value slightly too high than slightly too low. If the value is not exact, the {@link
   * ImmutableIntArray} that is built will very likely occupy more memory than strictly necessary;
   * to trim memory usage, build using {@code builder.build().trimmed()}.
   */

            byte[] testBytes = Strings.getUNIBytes("Test");
            System.arraycopy(testBytes, 0, buffer, 0, 8);
            buffer[8] = 0; // null terminator low byte
            buffer[9] = 0; // null terminator high byte

            String result = testBlock.readString(buffer, 0, buffer.length, 8, true);

            assertEquals("Test", result);
        }
    }

        // Prepare buffer with specific type value
        testBuffer[0] = 0x01; // revision
        testBuffer[1] = 0x00; // padding
        testBuffer[2] = 0x04; // type low byte
        testBuffer[3] = (byte) 0x80; // type high byte (0x8004)
        // Set all offsets to 0
        for (int i = 4; i < 20; i++) {
            testBuffer[i] = 0;
        }

    it may slow down the tests for not running in parallel and may cause the
    test to timeout but it could be useful when you need to execute a single
    test or more in general your filtered/selected tests have a very low
    execution time and the sharding
    [could create an overhead on the test execution](https://github.com/bazelbuild/bazel/issues/2113#issuecomment-264054799).

# RDMA (SMB Direct) Feature - Detailed Design Document

## 1. Overview

SMB Direct enables high-performance data transfer using Remote Direct Memory Access (RDMA) technology. This provides ultra-low latency and high bandwidth data transfer by bypassing the traditional TCP/IP stack and allowing direct memory-to-memory transfers between client and server.

## 2. Protocol Specification Reference

- **MS-SMBD**: SMB2 Remote Direct Memory Access (RDMA) Transport Protocol

register, even on architectures with a hardware frame pointer.
</p>

<p>
For assembly functions with Go prototypes, <code>go</code> <code>vet</code> will check that the argument names
and offsets match.
On 32-bit systems, the low and high 32 bits of a 64-bit value are distinguished by adding
a <code>_lo</code> or <code>_hi</code> suffix to the name, as in <code>arg_lo+0(FP)</code> or <code>arg_hi+4(FP)</code>.

    LoadingCache<?, ?> cache = CacheBuilder.newBuilder().initialCapacity(0).build(identityLoader());
    LocalCache<?, ?> map = CacheTesting.toLocalCache(cache);

    assertThat(map.segments).hasLength(4);
    // 1 is as low as it goes, not 0. it feels dirty to know this/test this.
    assertEquals(1, map.segments[0].table.length());
    assertEquals(1, map.segments[1].table.length());
    assertEquals(1, map.segments[2].table.length());