long weightY = comparator.getProjectWeight(ProjectDependencyGraphStub.Y);
        long weightZ = comparator.getProjectWeight(ProjectDependencyGraphStub.Z);

        // Verify the actual chain length calculation
        // Leaf nodes (no downstream dependencies)
        assertEquals(1L, weightX, "Project X should have weight 1 (1 + 0)");
        assertEquals(1L, weightY, "Project Y should have weight 1 (1 + 0)");

    assertEqualCharNodes(Iterables.limit(result, 2), "ab");
    assertThat(graph.requestedNodes).containsExactly('a', 'a', 'b');

    // Iterate again to see if calculation is done again
    assertEqualCharNodes(Iterables.limit(result, 2), "ab");
    assertThat(graph.requestedNodes).containsExactly('a', 'a', 'a', 'b', 'b');
  }

  @Test

            });
        }
    }

    @Nested
    @DisplayName("Encoding Tests")
    class EncodingTests {

        @Test
        @DisplayName("encode should validate size calculation")
        void testEncodeValidSize() {
            byte[] buffer = new byte[1024];
            testRequest.setTestSize(64);
            testRequest.setTestLength(64);

    }

    @Test
    @DisplayName("Test size calculation with short filename")
    void testSizeWithShortFilename() {
        FileRenameInformation2 info = new FileRenameInformation2("test.txt", false);
        // 20 bytes fixed + 2 * 8 chars = 20 + 16 = 36
        assertEquals(36, info.size());
    }

    @Test
    @DisplayName("Test size calculation with long filename")
    void testSizeWithLongFilename() {

                new ValidateNegotiateInfoRequest(DEFAULT_CAPABILITIES, defaultClientGuid, DEFAULT_SECURITY_MODE, defaultDialects);

        assertNotNull(request);
    }

    @Test
    @DisplayName("Test size calculation with multiple dialects")
    void testSizeWithMultipleDialects() {
        ValidateNegotiateInfoRequest request =

            try {
                // Exponential backoff with overflow protection - ensure safe calculation
                if (retryDelayMs > 0) {
                    // Safe calculation preventing overflow: use Math.max(0, retryCount - 1) and limit shift
                    int safeShift = Math.min(MAX_BACKOFF_SHIFT, Math.max(0, retryCount - 1));

    @DisplayName("Test setFileName method with null")
    void testSetFileNameNull() {
        request = new Smb2QueryDirectoryRequest(mockConfig);

        request.setFileName(null);

        // Verify size calculation doesn't include filename
        int expectedSize = Smb2Constants.SMB2_HEADER_LENGTH + 32;
        assertEquals(((expectedSize + 7) & ~7), request.size());
    }

    @Test

        }
    }

    // Integration test with actual MD5 to verify HMAC calculation logic
    @Test
    void testHMACT64WithActualMD5() throws NoSuchAlgorithmException {
        // This test uses a real MD5 instance to verify the HMAC calculation logic
        // HMACT64 is a modified HMAC-MD5 where the key is truncated at 64 bytes

			Optional:    true,
			Type:        "string",
		},
		config.HelpKV{
			Key:         Optimize,
			Description: `optimize parity calculation for standard storage class, set 'capacity' for capacity optimized (no additional parity)` + defaultHelpPostfix(Optimize),
			Optional:    true,
			Type:        "string",
		},
		config.HelpKV{
			Key:         config.Comment,

		return
	}

	duration := endTime.Sub(m.startTime)

	bytesSinceLastWindow := atomic.SwapUint64(&m.bytesSinceLastWindow, 0)

	if m.expMovingAvg == 0 {
		// Should address initial calculation and should be fine for resuming from 0
		m.expMovingAvg = float64(bytesSinceLastWindow) / duration.Seconds()
		return
	}

	increment := float64(bytesSinceLastWindow) / duration.Seconds()