assertNull(mock.getName());
        }

        @Test
        @DisplayName("Negative length is allowed via mock")
        void negativeLength() {
            FileEntry mock = mock(FileEntry.class);
            when(mock.length()).thenReturn(-10L);
            assertEquals(-10L, mock.length());
        }
    }

    @ParameterizedTest(name = "getType returns {0}")

 * addresses, and lengths for direct memory access operations.
 */
public class RdmaChannelInfo {

    private final Smb2RdmaTransform transform;

    /**
     * Create new RDMA channel info
     *
     * @param remoteKey remote memory key for RDMA access (token)
     * @param address remote memory address (offset)
     * @param length length of the memory region
     */

        int length = s.read();
        if (0 == length >>> 7) {
            // definite-length short form
            return length;
        }
        if (0x80 == length) {
            // indefinite-length
            return -1;
        }
        if (length < 0) {
            throw new EOFException("EOF found when length expected");
        }
        if (0xFF == length) {

        assertEquals(4, dst[0]);

        // Should end with 0x00
        assertEquals(0x00, dst[length - 1]);

        // Length should be scope length + 2
        assertEquals(name.scope.length() + 2, length);
    }

    @Test
    void readScopeWireFormat_withNullScope_shouldReturnOne() {
        byte[] src = new byte[10];
        src[0] = 0x00;

    checkNotNull(array);
    checkPositionIndexes(fromIndex, toIndex, array.length);
    if (array.length <= 1) {
      return;
    }

    int length = toIndex - fromIndex;
    // Obtain m = (-distance mod length), a non-negative value less than "length". This is how many
    // places left to rotate.
    int m = -distance % length;
    m = (m < 0) ? m + length : m;

        byte[] data = { 0x01, 0x02, 0x03, 0x04 };
        ndrBuffer.writeOctetArray(data, 0, data.length);

        assertEquals(data.length, ndrBuffer.getIndex());
        assertEquals(data.length, ndrBuffer.getLength());
        assertArrayEquals(data, Arrays.copyOfRange(buffer, 0, data.length));

        // Write with offset and length
        ndrBuffer.setIndex(10);
        byte[] partialData = { 0x05, 0x06, 0x07, 0x08, 0x09 };

    private int length; // 4 bytes: Length of buffer

    /**
     * Create SMB2 RDMA Transform
     *
     * @param offset offset within registered buffer
     * @param token RDMA provider token (steering tag/memory handle)
     * @param length length of buffer
     */
    public Smb2RdmaTransform(long offset, int token, int length) {
        this.offset = offset;
        this.token = token;

// If length <= 0, the access key length is chosen automatically.
//
// GenerateAccessKey returns an error if length is too small for a valid
// access key.
func GenerateAccessKey(length int, random io.Reader) (string, error) {
	if random == nil {
		random = rand.Reader
	}
	if length <= 0 {
		length = accessKeyMaxLen
	}
	if length < accessKeyMinLen {

      if (x.length() != (originalString.length() * count)) {
        throw new RuntimeException("Wrong length: " + x);
      }
    }
  }

  private static String oldRepeat(String string, int count) {
    // If this multiplication overflows, a NegativeArraySizeException or
    // OutOfMemoryError is not far behind
    int len = string.length();
    int size = len * count;
    char[] array = new char[size];

     * Tests the {@link PacUnicodeString#check(String)} method with a string of incorrect length.
     */
    @Test
    void testCheck_withInvalidLength_throwsException() {
        // Length is 10 bytes, so expected string length is 5 characters
        PacUnicodeString pacString = new PacUnicodeString((short) 10, (short) 20, 100);
        String testString = "too-long"; // Length is 8

        // Expect a PACDecodingException to be thrown