int bytesDecoded = response.decode(buffer, 0, buffer.length);

            assertEquals(12, bytesDecoded);
            assertEquals(Integer.MAX_VALUE, response.getChunksWritten());
            assertEquals(Integer.MAX_VALUE, response.getChunkBytesWritten());
            assertEquals(Integer.MAX_VALUE, response.getTotalBytesWritten());
        }

    new RoundToDoubleTester(maxDoubleAsBigInteger)
        .setExpectation(Double.MAX_VALUE, values())
        .test();
  }

  @J2ktIncompatible
  @GwtIncompatible
  public void testRoundToDouble_maxDoublePlusOne() {
    BigInteger maxDoubleAsBigInteger =
        DoubleMath.roundToBigInteger(Double.MAX_VALUE, UNNECESSARY).add(BigInteger.ONE);

        final Object _value = value;
        RangeQueryBuilder builder = regRangeQ("value", ConditionKey.CK_GREATER_THAN, _value);
        if (opLambda != null) {
            opLambda.callback(builder);
        }
    }

    public void setValue_LessThan(String value) {
        setValue_LessThan(value, null);
    }

        SMBUtil.writeTime(maxTime, buffer, 32); // changeTime
        SMBUtil.writeInt8(Long.MAX_VALUE, buffer, 40); // endOfFile
        SMBUtil.writeInt8(Long.MAX_VALUE, buffer, 48); // allocationSize
        SMBUtil.writeInt4(Integer.MAX_VALUE, buffer, 56); // extFileAttributes
        SMBUtil.writeInt4(Integer.MAX_VALUE, buffer, 64); // eaSize

        // Decode
        fileBothDirectoryInfo.decode(buffer, 0, buffer.length);

        SMBUtil.writeInt4(Integer.MAX_VALUE, buffer, bufferIndex + 3);
        SMBUtil.writeInt4(Integer.MAX_VALUE, buffer, bufferIndex + 7);
        SMBUtil.writeInt4(Integer.MAX_VALUE, buffer, bufferIndex + 11);
        SMBUtil.writeInt4(Integer.MAX_VALUE, buffer, bufferIndex + 15);
        SMBUtil.writeInt4(Integer.MAX_VALUE, buffer, bufferIndex + 19);
        SMBUtil.writeInt4(Integer.MAX_VALUE, buffer, bufferIndex + 23);

            byte[] buffer = createValidWriteResponse(Integer.MAX_VALUE, Integer.MAX_VALUE);

            int bytesRead = response.readBytesWireFormat(buffer, 0);

            assertEquals(16, bytesRead);
            assertEquals(Integer.MAX_VALUE, response.getCount());
            assertEquals(Integer.MAX_VALUE, response.getRemaining());
        }

        @Test

    void testWriteInt4Various(int value) {
        byte[] dst = new byte[4];
        SessionServicePacket.writeInt4(value, dst, 0);

        assertEquals((byte) ((value >> 24) & 0xFF), dst[0]);
        assertEquals((byte) ((value >> 16) & 0xFF), dst[1]);
        assertEquals((byte) ((value >> 8) & 0xFF), dst[2]);
        assertEquals((byte) (value & 0xFF), dst[3]);
    }

    @Test
    @DisplayName("Test edge case with maximum values")
    void testMaximumValues() {
        // Given
        long maxMid = Long.MAX_VALUE;
        long maxAsyncId = Long.MAX_VALUE;
        int maxCredits = Integer.MAX_VALUE;
        int maxTreeId = Integer.MAX_VALUE;

        // When
        Smb2CancelRequest request = new Smb2CancelRequest(mockConfig, maxMid, maxAsyncId);

    assertEquals(
        Range.closedOpen(Integer.MIN_VALUE, 0),
        Range.closedOpen(Integer.MIN_VALUE, 0).canonical(integers()));

    assertEquals(Range.closedOpen(Integer.MIN_VALUE, 0), Range.lessThan(0).canonical(integers()));
    assertEquals(Range.closedOpen(Integer.MIN_VALUE, 1), Range.atMost(0).canonical(integers()));

    for (int value : VALUES) {
      assertThat(Ints.checkedCast((long) value)).isEqualTo(value);
    }
    assertCastFails(GREATEST + 1L);
    assertCastFails(LEAST - 1L);
    assertCastFails(Long.MAX_VALUE);
    assertCastFails(Long.MIN_VALUE);
  }

  public void testSaturatedCast() {
    for (int value : VALUES) {
      assertThat(Ints.saturatedCast((long) value)).isEqualTo(value);
    }