/**
         * Returns the algorithm end result as string, never {@code null}. After invoking this method, this instance should
         * be discarded and not reused. For new checksum calculation you have to get new instance.
         */
        @Nonnull
        String checksum();
    }

            response.readDataWireFormat(buffer, 0, 0);
        });
    }

    @Test
    @DisplayName("Test readDataWireFormat preserves buffer index calculation")
    void testReadDataWireFormatBufferIndexCalculation() throws Exception {
        byte[] buffer = createValidSecurityDescriptorBuffer();
        int startIndex = 10;

        // Prepare buffer with offset

        // When
        int size = request.size();

        // Then
        // Verify size includes SMB2_HEADER_LENGTH
        assertTrue(size >= Smb2Constants.SMB2_HEADER_LENGTH);

        // The actual calculation: (SMB2_HEADER_LENGTH + 4 + 7) & ~7
        int expectedBase = Smb2Constants.SMB2_HEADER_LENGTH + 4;
        int expectedAligned = (expectedBase + 7) & ~7;
        assertEquals(expectedAligned, size);
    }

      return;
    }

    xStats.addAll(values.xStats());
    if (yStats.count() == 0) {
      sumOfProductsOfDeltas = values.sumOfProductsOfDeltas();
    } else {
      // This is a generalized version of the calculation in add(double, double) above. Note that
      // non-finite inputs will have sumOfProductsOfDeltas = NaN, so non-finite values will result
      // in NaN naturally.
      sumOfProductsOfDeltas +=

            // Create valid signature using HmacSHA256
            Mac mac = Mac.getInstance("HmacSHA256");
            mac.init(new SecretKeySpec(sessionKey, "HmacSHA256"));

            // Zero signature field for calculation
            for (int i = 0; i < SIGNATURE_LENGTH; i++) {
                data[SIGNATURE_OFFSET + i] = 0;
            }

            mac.update(data, 0, data.length);
            byte[] signature = mac.doFinal();

     * @param messageData the message data to hash
     * @param hashAlgorithm the hash algorithm to use
     * @return the new hash
     * @throws CIFSException if hash calculation fails
     */
    private byte[] calculateHash(byte[] previousHash, byte[] messageData, int hashAlgorithm) throws CIFSException {
        try {
            MessageDigest digest;
            switch (hashAlgorithm) {

            for (int i = 0; i < cipherCount; i++) {
                assertEquals(i + 1, context.getCiphers()[i]);
            }
        }
    }

    @Nested
    @DisplayName("Size Calculation Tests")
    class SizeCalculationTests {

        @Test
        @DisplayName("Should calculate size for null ciphers")
        void testSizeWithNullCiphers() {

            }
        }
    }

    @Nested
    @DisplayName("Usage Pattern Tests")
    class UsagePatternTests {

        @Test
        @DisplayName("Should support percentage calculation pattern")
        void shouldSupportPercentageCalculationPattern() {
            // Given
            TestAllocInfo allocInfo = new TestAllocInfo(1000L, 250L);

            // When - calculate percentage free

    private static final long BASE_POLL_INTERVAL = 1000;
    private static final long BASE_ERROR_DELAY = 1000;
    private static final int MAX_FAILURE_LIMIT = 5; // Limit failures for backoff calculation

    private final InetAddress witnessServer;
    private final int port;
    private final CIFSContext context;
    private final ConcurrentHashMap<String, WitnessRegistration> registrations;

        });

        assertTrue(exception.getMessage().contains("Security buffer extends beyond available data"));
    }

    /**
     * Test integer overflow protection in security buffer offset calculation.
     */
    @Test
    public void testSecurityBufferIntegerOverflow() {
        byte[] buffer = createBasicNegotiateResponseBuffer();