*
   * <p>Instead of throwing {@link ArithmeticException}, this method silently saturates to either
   * {@link Long#MAX_VALUE} or {@link Long#MIN_VALUE}. This behavior can be useful when decomposing
   * a duration in order to call a legacy API which requires a {@code long, TimeUnit} pair.
   */
  // We use this method only for cases in which we need to decompose to primitives.

 */
@NullMarked
@GwtCompatible
public class SignedBytesTest extends TestCase {
  private static final byte[] EMPTY = {};
  private static final byte[] ARRAY1 = {(byte) 1};

  private static final byte LEAST = Byte.MIN_VALUE;
  private static final byte GREATEST = Byte.MAX_VALUE;

  private static final byte[] VALUES = {LEAST, -1, 0, 1, GREATEST};

  public void testCheckedCast() {
    for (byte value : VALUES) {

        when(messageBlock.getMid()).thenReturn(maxMid);

        messageBlock.setMid(maxMid);
        assertEquals(maxMid, messageBlock.getMid());

        // Test with MIN_VALUE
        long minMid = Long.MIN_VALUE;
        doNothing().when(messageBlock).setMid(minMid);
        when(messageBlock.getMid()).thenReturn(minMid);

        messageBlock.setMid(minMid);

        // Test with minimum integer value
        int minFlags = Integer.MIN_VALUE;
        AvFlags minAvFlags = new AvFlags(minFlags);
        assertNotNull(minAvFlags, "AvFlags object should not be null for min flags");
        assertEquals(minFlags, minAvFlags.getFlags(), "Flags should match Integer.MIN_VALUE");

        // Test with a negative integer
        int negativeFlags = -12345;

        // Test case 5: Min int value
        int minIntValue = Integer.MIN_VALUE;
        NdrLong ndrLongMin = new NdrLong(minIntValue);
        assertEquals(minIntValue, ndrLongMin.value, "Constructor should correctly initialize with Integer.MIN_VALUE.");
    }

    @Test
    void encode_shouldCallEncNdrLongWithCorrectValue() throws NdrException {
        int testValue = 98765;

    }

    @Test
    void constructor_withMinimumShortValue() {
        // Arrange
        short level = Short.MIN_VALUE;

        // Act
        queryPolicy = new MsrpcQueryInformationPolicy(mockPolicyHandle, level, mockNdrObject);

        // Assert
        assertEquals(Short.MIN_VALUE, queryPolicy.level);
    }

    @Test
    void constructor_withMaximumShortValue() {
        // Arrange

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

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

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

        // Test boundary values for safe operations
        assertEquals(Integer.MAX_VALUE, validator.safeAdd(Integer.MAX_VALUE, 0));
        assertEquals(Integer.MIN_VALUE, validator.safeAdd(Integer.MIN_VALUE, 0));
        assertEquals(0, validator.safeMultiply(0, Integer.MAX_VALUE));
        assertEquals(1, validator.safeMultiply(1, 1));

        // Test exact buffer boundaries

  }

  public void testRoundToDouble_halfMinDouble() {
    BigDecimal minDouble = new BigDecimal(Double.MIN_VALUE);
    BigDecimal halfMinDouble = minDouble.divide(BigDecimal.valueOf(2));
    new RoundToDoubleTester(halfMinDouble)
        .roundUnnecessaryShouldThrow()
        .setExpectation(Double.MIN_VALUE, UP, CEILING, HALF_UP)
        .setExpectation(0.0, HALF_EVEN, FLOOR, DOWN, HALF_DOWN)
        .test();
  }