* high wastes memory.
   *
   * @return this {@code CacheBuilder} instance (for chaining)
   * @throws IllegalArgumentException if {@code initialCapacity} is negative
   * @throws IllegalStateException if an initial capacity was already set
   */
  @CanIgnoreReturnValue
  public CacheBuilder<K, V> initialCapacity(int initialCapacity) {
    checkState(

        @Test
        @DisplayName("Should throw exception on negative buffer index")
        void testDecodeWithNegativeIndex() {
            assertThrows(SMBProtocolDecodingException.class, () -> testResponse.decode(testBuffer, -1, 10),
                    "Should throw exception for negative buffer index");
        }

        @Test
        @DisplayName("Should throw exception on negative length")
        void testDecodeWithNegativeLength() {

            bufferOverflowsPrevented.incrementAndGet();
            throw new SmbException("Negative offset: " + offset);
        }

        if (length < 0) {
            failedValidations.incrementAndGet();
            bufferOverflowsPrevented.incrementAndGet();
            throw new SmbException("Negative length: " + length);
        }

        // Check for integer overflow

        }
    }

    @Test
    void testNegativeValueHandling() {
        byte[] buffer = new byte[8];

        // Test negative values in writeInt4
        SMBUtil.writeInt4(-1L, buffer, 0);
        assertEquals(-1, SMBUtil.readInt4(buffer, 0));

        // Test negative values in writeInt8
        SMBUtil.writeInt8(-1L, buffer, 0);
        assertEquals(-1L, SMBUtil.readInt8(buffer, 0));
    }

    }

    @Test
    @DisplayName("Test decode with negative values")
    void testDecodeWithNegativeValues() throws SMBProtocolDecodingException {
        // Prepare test data with negative values (when interpreted as signed)
        byte[] buffer = new byte[16];
        int bufferIndex = 0;

        // Set up negative values
        int namedPipeState = -1;
        int readDataAvailable = -100;

  }

  private void assertSetCountNegativeOldCount() {
    try {
      getMultiset().setCount(e3(), -1, 1);
      fail("calling setCount() with a negative oldCount should throw IllegalArgumentException");
    } catch (IllegalArgumentException expected) {
    }
  }

  // Negative oldCount.

  @CollectionFeature.Require(SUPPORTS_ADD)
  public void testSetCountConditional_negativeOldCount_addSupported() {

            assertEquals(0, ndrShort.value);
        }

        @Test
        @DisplayName("Should decode negative value correctly")
        void testDecodeNegativeValue() throws NdrException {
            // Given: NdrShort and mock returning negative value
            int negativeValue = -1;
            NdrShort ndrShort = new NdrShort(0);

        assertEquals(22, bytesDecoded);
        assertEquals(minLong, fileStandardInfo.getSize());
    }

    @Test
    @DisplayName("Test decode with negative values")
    void testDecodeWithNegativeValues() throws SMBProtocolDecodingException {
        // Prepare test data with negative values
        byte[] buffer = new byte[22];
        long negativeLong = -1L;
        int negativeInt = -1;

        // Encode test data

    @DisplayName("Test edge case with minimum/negative values")
    void testMinimumValues() {
        // Given
        long negativeMid = -1L;
        long negativeAsyncId = -1L;

        // When
        Smb2CancelRequest request = new Smb2CancelRequest(mockConfig, negativeMid, negativeAsyncId);

        // Then
        assertEquals(negativeMid, request.getMid(), "Should handle negative MID");

    if (value < 0) {
      throw new IllegalArgumentException(name + " cannot be negative but was: " + value);
    }
    return value;
  }

  @CanIgnoreReturnValue
  static long checkNonnegative(long value, String name) {
    if (value < 0) {
      throw new IllegalArgumentException(name + " cannot be negative but was: " + value);
    }
    return value;
  }