static final byte SMB_COM_NT_CREATE_ANDX = (byte) 0xA2;

    /*
     * Some fields specify the offset from the beginning of the header. This
     * field should be used for calculating that. This would likely be zero
     * but an implemantation that encorporates the transport header(for
     * efficiency) might use a different initial bufferIndex. For example,

      min = otherMin;
      max = otherMax;
    } else {
      count += otherCount;
      if (isFinite(mean) && isFinite(otherMean)) {
        // This is a generalized version of the calculation in add(double) above.
        double delta = otherMean - mean;
        mean += delta * otherCount / count;
        sumOfSquaresOfDeltas += otherSumOfSquaresOfDeltas + delta * (otherMean - mean) * otherCount;
      } else {

            request.setFileId(secondFileId);

            assertDoesNotThrow(() -> request.setFileId(secondFileId));
        }
    }

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

        @Test
        @DisplayName("Should calculate size correctly with single lock")
        void testSizeWithSingleLock() {

		},
		config.HelpKV{
			Key:         config.ScannerSubSys,
			Description: "manage namespace scanning for usage calculation, lifecycle, healing and more",
		},
		config.HelpKV{
			Key:         config.BatchSubSys,
			Description: "manage batch job workers and wait times",
		},
		config.HelpKV{

            if (maxResponseTime.compareAndSet(currentMax, responseTimeMs)) {
                break;
            }
            currentMax = maxResponseTime.get();
        }

        // Add to history for percentile calculation
        responseTimeHistory.addLast(responseTimeMs);
        if (responseTimeHistory.size() > 1000) { // Keep last 1000 measurements
            responseTimeHistory.removeFirst();
        }

    }

    @Test
    void readWireFormat_withNonSpacePaddingCharacters_shouldPreserveLength() {
        // Test that non-space characters in padding are preserved in length calculation
        byte[] src = new byte[100];
        src[0] = 0x20;

        // Encode "AB" followed by non-space padding
        src[1] = 'E';
        src[2] = 'B'; // A
        src[3] = 'E';

    }

    @Test
    @DisplayName("Test readDataWireFormat with converter offset")
    void testReadDataWireFormatWithConverter() throws Exception {
        // Set converter to test offset calculation
        int converterValue = 100;
        setConverter(response, converterValue);
        setNumEntries(response, 1);

        String serverName = "TEST";
        String comment = "Test comment";

        assertArrayEquals(bufferCopy, buffer, "Buffer content should not be modified");
    }

    @Test
    @DisplayName("Test readBytesWireFormat with offset calculation")
    void testReadBytesWireFormatOffsetCalculation() throws Exception {
        response = new Smb2QueryInfoResponse(mockConfig, Smb2Constants.SMB2_0_INFO_FILE, FileInformation.FILE_INTERNAL_INFO);

            assertEquals(0, testMessage.getSessionId());
            assertEquals(0, testMessage.getTreeId());
        }
    }

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

        @Test
        @DisplayName("Should calculate size8 without alignment")
        void testSize8NoAlignment() {

                assertEquals(i + 1, context.getHashAlgos()[i]);
            }
            assertArrayEquals(salt, context.getSalt());
        }
    }

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

        @Test
        @DisplayName("Should calculate size for null hash algorithms and salt")
        void testSizeWithNullHashAlgosAndSalt() {