// Trigger integer overflow prevention
        try {
            validator.safeAdd(Integer.MAX_VALUE, Integer.MAX_VALUE);
        } catch (SmbException e) {
            // Expected
        }

        try {
            validator.safeMultiply(Integer.MAX_VALUE, 2);
        } catch (SmbException e) {
            // Expected
        }

        when(negotiationResponse.getSendBufferSize()).thenReturn(Integer.MAX_VALUE);
        when(negotiationResponse.getReceiveBufferSize()).thenReturn(Integer.MAX_VALUE);
        when(negotiationResponse.getTransactionBufferSize()).thenReturn(Integer.MAX_VALUE);

        assertEquals(Integer.MAX_VALUE, negotiationResponse.getSendBufferSize());
        assertEquals(Integer.MAX_VALUE, negotiationResponse.getReceiveBufferSize());

internal fun Long.commonClampToInt(): Int =
  when {
    this > Int.MAX_VALUE -> Int.MAX_VALUE
    else -> toInt()
  }

internal fun CacheControl.Companion.commonForceNetwork() =
  CacheControl
    .Builder()
    .noCache()
    .build()

internal fun CacheControl.Companion.commonForceCache() =
  CacheControl
    .Builder()
    .onlyIfCached()
    .maxStale(Int.MAX_VALUE.seconds)
    .build()

        assertEquals("EndOfFileInformation[endOfFile=0]", info2.toString());

        // Test max value
        FileEndOfFileInformation info3 = new FileEndOfFileInformation(Long.MAX_VALUE);
        assertEquals("EndOfFileInformation[endOfFile=" + Long.MAX_VALUE + "]", info3.toString());
    }

    @Test
    @DisplayName("Test multiple encode operations")
    void testMultipleEncodeOperations() {

        serverData.sflags2 = Integer.MAX_VALUE;
        serverData.smaxMpxCount = Integer.MAX_VALUE;
        serverData.maxBufferSize = Integer.MAX_VALUE;
        serverData.sessKey = Integer.MAX_VALUE;
        serverData.scapabilities = Integer.MAX_VALUE;

        assertEquals(Integer.MAX_VALUE, serverData.sflags2);
        assertEquals(Integer.MAX_VALUE, serverData.smaxMpxCount);

    while (h < input.size) {
      val m = input.minBy { if (it >= n) it else Int.MAX_VALUE }

      val increment = (m - n) * (h + 1)
      if (delta > Int.MAX_VALUE - increment) return false // Prevent overflow.
      delta += increment

      n = m

      for (c in input) {
        if (c < n) {
          if (delta == Int.MAX_VALUE) return false // Prevent overflow.
          delta++
        } else if (c == n) {

            request.setPadding((byte) 0xFF);
            request.setReadFlags((byte) 0xFF);
            request.setReadLength(Integer.MAX_VALUE);
            request.setOffset(Long.MAX_VALUE);
            request.setMinimumCount(Integer.MAX_VALUE);
            request.setRemainingBytes(Integer.MAX_VALUE);

            byte[] buffer = new byte[256];
            int bytesWritten = request.writeBytesWireFormat(buffer, 0);

        void shouldHandleMaximumLongValues() {
            // Given
            TestAllocInfo allocInfo = new TestAllocInfo(Long.MAX_VALUE, Long.MAX_VALUE);

            // When & Then
            assertEquals(Long.MAX_VALUE, allocInfo.getCapacity());
            assertEquals(Long.MAX_VALUE, allocInfo.getFree());
        }

        @Test
        @DisplayName("Should handle minimum long values")

            // Given
            byte[] maxKey = new byte[SOURCE_KEY_SIZE];
            Arrays.fill(maxKey, (byte) 0xFF);
            SrvCopychunk chunk = new SrvCopychunk(Long.MAX_VALUE, Long.MAX_VALUE, Integer.MAX_VALUE);
            SrvCopychunkCopy copy = new SrvCopychunkCopy(maxKey, chunk);
            byte[] buffer = new byte[100];

            // When
            int bytesWritten = copy.encode(buffer, 0);

    longValues.addAll(Iterables.transform(POSITIVE_INTEGER_CANDIDATES, TO_LONG));
    // Add boundary values manually to avoid over/under flow (this covers 2^N for 31 and 63).
    longValues.add(Integer.MAX_VALUE + 1L, Long.MAX_VALUE - 1L, Long.MAX_VALUE);

    // Now add values near 2^N for lots of values of N.
    for (int exponent : asList(32, 33, 39, 40, 41, 47, 48, 49, 55, 56, 57)) {
      long x = 1L << exponent;