// Then
            assertEquals(HEADER_SIZE + CHUNK_SIZE, bytesWritten);

            // Verify source key at correct position
            for (int i = 0; i < SOURCE_KEY_SIZE; i++) {
                assertEquals(sourceKey[i], largeBuffer[position + i]);
            }

            // Verify chunk count at correct position

            assertEquals(6, smallEncodedSize); // actual: 2 bytes count + 2*2 bytes for ciphers
            assertEquals(6, largeEncodedSize);

            // Verify data at different positions
            assertArrayEquals(Arrays.copyOfRange(smallBuffer, 0, smallEncodedSize),
                    Arrays.copyOfRange(largeBuffer, 500, 500 + largeEncodedSize));
        }
    }

    @Nested

        byte[] buffer = new byte[1024];

        int length = testBlock.encode(buffer, 0);

        assertTrue(length > 0);
        // Just verify that encoding worked without checking specific byte positions
        assertNull(testBlock.getAndx());
    }

    @Test
    @DisplayName("Test encode with andx command and batching disabled")
    void testEncodeWithAndxBatchingDisabled() {

   * printing space backward on the same printing line. (Applicable also to display devices.)
   *
   * @since 8.0
   */
  public static final byte BS = 8;

  /**
   * Horizontal Tabulation ('\t'): A format effector which controls the movement of the printing
   * position to the next in a series of predetermined positions along the printing line.

    void testStructureSizeImmutability() throws Exception {
        // Given
        byte[] buffer = new byte[2048];

        // When - encode at multiple positions
        for (int i = 0; i < 5; i++) {
            Smb2TreeConnectRequest req = new Smb2TreeConnectRequest(mockConfig, TEST_PATH);
            req.encode(buffer, i * 200);
        }

        assertEquals('E', dst[2]); // (0x54 & 0x0F) + 0x41 = 0x45 = 'E'

        // Check padding (positions 8-30 should be 'CA' pairs for spaces)
        for (int i = 8; i < 31; i += 2) {
            assertEquals('C', dst[i + 1]);
            assertEquals('A', dst[i + 2]);
        }

        // Check type encoding at position 31-32
        assertEquals('C', dst[31]); // (0x20 >> 4) + 0x41 = 'C'

        @DisplayName("Should write at different buffer positions")
        void testWriteAtDifferentPositions() {
            byte[] buffer = new byte[512];

            // Test at position 0
            int bytesWritten = request.writeBytesWireFormat(buffer, 0);
            assertEquals(48, bytesWritten);
            assertEquals(48, SMBUtil.readInt2(buffer, 0));

            // Test at position 100
            Arrays.fill(buffer, (byte) 0);

        }
      }
      return false;
    }

    /**
     * If more than this many consecutive positions are filled in a table of the specified size,
     * report probable hash flooding. ({@link #hashFloodingDetected} may also report hash flooding
     * if fewer consecutive positions are filled; see that method for details.)
     */
    static int maxRunBeforeFallback(int tableSize) {

        }

        @Test
        @DisplayName("Should write at different buffer positions")
        void testWriteAtDifferentPositions() {
            request.setReadLength(2048);
            request.setOffset(4096L);

            byte[] buffer = new byte[512];

            // Test at position 0
            int bytesWritten = request.writeBytesWireFormat(buffer, 0);

   * returned by {@code get(rowKeyList().get(rowIndex), columnKeyList().get(columnIndex))}, but this
   * method runs more quickly.
   *
   * @param rowIndex position of the row key in {@link #rowKeyList()}
   * @param columnIndex position of the row key in {@link #columnKeyList()}
   * @return the value with the specified row and column