- Remove redundant log lines and reduce severity around parsing kubeEnv
  - Don't treat nodes created by virtual kubelet as nodes from non-autoscaled node groups
  - Remove redundant logging around calculating node utilization
  - Add configurable `--network` and `--rm` flags for docker in `Makefile`
  - Subtract DaemonSet pods' requests from node allocatable in the denominator while computing node utilization

            String result = testBlock.readString(buffer, 0);

            assertEquals("Test", result);
        }

        @Test
        @DisplayName("Test string wire length calculation")
        void testStringWireLength() {
            testBlock.setUseUnicode(false);
            assertEquals(5, testBlock.stringWireLength("Test", 0));

            testBlock.setUseUnicode(true);

        });

        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();

        assertEquals(1, stats.getOperationErrors(), "Should have 1 error");
        assertEquals(0.25, stats.getErrorRate(), 0.001, "Error rate should be 25% (1 error out of 4 successful operations)");

        // Verify latency calculations
        assertTrue(stats.getAverageReadLatencyMicros() > 0, "Read latency should be positive");
        assertTrue(stats.getAverageWriteLatencyMicros() > 0, "Write latency should be positive");

            int bodyOffset = Smb2Constants.SMB2_HEADER_LENGTH;
            assertEquals(sessionId, SMBUtil.readInt8(buffer, bodyOffset + 16));
        }
    }

    @Test
    @DisplayName("Should verify padding calculation")
    void testPaddingCalculation() throws Exception {
        // Given - Create request with token
        byte[] token = new byte[5]; // Non-8-aligned size
        Smb2SessionSetupRequest req =

      calculateNextPermutation();
      return next;
    }

    void calculateNextPermutation() {
      j = list.size() - 1;
      int s = 0;

      // Handle the special case of an empty list. Skip the calculation of the
      // next permutation.
      if (j == -1) {
        return;
      }

      while (true) {
        int q = c[j] + o[j];
        if (q < 0) {
          switchDirection();

        assertArrayEquals(pathBytes, actualPath);
    }

    @Test
    @DisplayName("Should verify size8 alignment calculation")
    void testSize8Alignment() throws Exception {
        // Given - Various path lengths to test alignment
        String[] paths = { "\\\\a\\b", // Short path
                "\\\\server\\share", // Medium path

        void testVariousRemainingBytes(int remaining) {
            assertDoesNotThrow(() -> request.setRemainingBytes(remaining));
        }
    }

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

        @Test
        @DisplayName("Should calculate size correctly with no data")
        void testSizeWithNoData() {
            request.setData(new byte[0], 0, 0);

            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() {

      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 {