long doubleConversionTest = 0xfffffffffffff402L;

    for (long i = -3; i <= 3; i++) {
      testLongsBuilder
          .add(i)
          .add(Long.MAX_VALUE + i)
          .add(Long.MIN_VALUE + i)
          .add(Integer.MIN_VALUE + i)
          .add(Integer.MAX_VALUE + i)
          .add(floatConversionTest + i)
          .add(doubleConversionTest + i);
      BigInteger bigI = BigInteger.valueOf(i);
      testBigIntegersBuilder

    assertMean(0, -1, 2);
    assertMean(0, Integer.MIN_VALUE + 2, Integer.MAX_VALUE);
    assertMean(0, 0, 1);
    assertMean(-1, -1, 0);
    assertMean(-1, Integer.MIN_VALUE, Integer.MAX_VALUE);

    // x == y == mean
    assertMean(1, 1, 1);
    assertMean(0, 0, 0);
    assertMean(-1, -1, -1);
    assertMean(Integer.MIN_VALUE, Integer.MIN_VALUE, Integer.MIN_VALUE);

   *       Long.MIN_VALUE}
   *   <li>{@link Math#absExact(long)}, which throws {@link ArithmeticException} when passed {@code
   *       Long.MIN_VALUE}
   *   <li>this method, {@code LongMath.saturatedAbs(long)}, which returns {@code Long.MAX_VALUE}
   *       when passed {@code Long.MIN_VALUE}
   * </ul>
   *

        // 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;

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

    }
  }

  public static final class DoublesAsListHeadSubListGenerator extends TestDoubleListGenerator {
    @Override
    protected List<Double> create(Double[] elements) {
      Double[] suffix = {Double.MIN_VALUE, Double.MAX_VALUE};
      Double[] all = concat(elements, suffix);
      return asList(all).subList(0, elements.length);
    }
  }

      assertThat(UnsignedInts.toLong(UnsignedInts.checkedCast(value))).isEqualTo(value);
    }
    assertCastFails(1L << 32);
    assertCastFails(-1L);
    assertCastFails(Long.MAX_VALUE);
    assertCastFails(Long.MIN_VALUE);
  }

  private static void assertCastFails(long value) {
    try {
      UnsignedInts.checkedCast(value);
      fail("Cast to int should have failed: " + value);
    } catch (IllegalArgumentException ex) {

    # o cursorSelectFetchSize: (NotRequired - Default null)
    #  The fetch size of JDBC parameter for cursor select.
    #  For example, specify Integer.MIN_VALUE to enable fetch of MySQL.
    #
    #; cursorSelectFetchSize = Integer.MIN_VALUE
    # - - - - - - - - - -/

    # /- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

    void testDecodeWithMinIndexNumber() throws SMBProtocolDecodingException {
        // Prepare test data
        byte[] buffer = new byte[8];
        long expectedIndexNumber = Long.MIN_VALUE;

        // Encode test data
        SMBUtil.writeInt8(expectedIndexNumber, buffer, 0);

        // Decode
        int bytesDecoded = fileInternalInfo.decode(buffer, 0, buffer.length);

        // Verify

    // escaping elements from a map you would use a ArrayBasedCharEscaper).
    UnicodeEscaper escaper =
        new ArrayBasedUnicodeEscaper(
            SIMPLE_REPLACEMENTS, Character.MIN_VALUE, Character.MAX_CODE_POINT, null) {
          @Override
          protected char[] escapeUnsafe(int c) {
            return NO_CHARS;
          }
        };
    EscaperAsserts.assertBasic(escaper);