// Prepare test data with maximum int values
        byte[] buffer = new byte[22];
        int idFileSystem = Integer.MAX_VALUE;
        int sectPerAlloc = 100;
        int alloc = Integer.MAX_VALUE / 200;
        int free = Integer.MAX_VALUE / 200;
        int bytesPerSect = 512;

        // Encode test data
        int offset = 0;
        SMBUtil.writeInt4(idFileSystem, buffer, offset);

        when(config.getNotifyBufferSize()).thenReturn(Integer.MAX_VALUE);
        Smb2ChangeNotifyRequest req = new Smb2ChangeNotifyRequest(config, testFileId);

        // When
        byte[] buffer = new byte[512];
        req.writeBytesWireFormat(buffer, 0);

        // Then
        int readBufferSize = SMBUtil.readInt4(buffer, 4);
        assertEquals(Integer.MAX_VALUE, readBufferSize);
    }

    @Test

   * infinite {@code double} values are considered infinitely far away. For example, 2^2000 is not
   * representable as a double, but {@code roundToDouble(BigDecimal.valueOf(2).pow(2000), HALF_UP)}
   * will return {@code Double.MAX_VALUE}, not {@code Double.POSITIVE_INFINITY}.
   *
   * <p>For the case of {@link RoundingMode#HALF_EVEN}, this implementation uses the IEEE 754

    }
    for (int c = 0; c <= Character.MAX_VALUE; c++) {
      assertFalse(positive.contains(Character.valueOf((char) c)) ^ m.matches((char) c));
    }
  }

  static char[] randomChars(Random rand, int size) {
    Set<Character> chars = new HashSet<>(size);
    for (int i = 0; i < size; i++) {
      char c;
      do {
        c = (char) rand.nextInt(Character.MAX_VALUE - Character.MIN_VALUE + 1);

    }
  }

  /**
   * Always returns {@code Integer.MAX_VALUE} because a {@code MonitorBasedPriorityBlockingQueue} is
   * not capacity constrained.
   *
   * @return {@code Integer.MAX_VALUE}
   */
  @CanIgnoreReturnValue // pushed down from class to method
  @Override
  public int remainingCapacity() {
    return Integer.MAX_VALUE;
  }

  /**

  }

  public void testGreaterThan() {
    Range<Integer> range = Range.greaterThan(5);
    assertFalse(range.contains(5));
    assertTrue(range.contains(6));
    assertTrue(range.contains(Integer.MAX_VALUE));
    assertTrue(range.hasLowerBound());
    assertEquals(5, (int) range.lowerEndpoint());
    assertEquals(OPEN, range.lowerBoundType());
    assertUnboundedAbove(range);
    assertFalse(range.isEmpty());

      this.headers_ =
        Headers
          .Builder()
          .add("Content-Length", "0")
      this.trailers_ = Headers.Builder()
      this.throttleBytesPerPeriod = Long.MAX_VALUE
      this.throttlePeriodNanos = 0L
      this.failHandshake = false
      this.onRequestStart = null
      this.doNotReadRequestBody = false
      this.onRequestBody = null
      this.onResponseStart = null

        }

        @Test
        @DisplayName("Should handle locks with maximum values")
        void testLocksWithMaximumValues() {
            Smb2Lock[] locks = new Smb2Lock[] { new Smb2Lock(Long.MAX_VALUE, Long.MAX_VALUE, Integer.MAX_VALUE) };

            Smb2LockRequest req = new Smb2LockRequest(mockConfig, testFileId, locks);
            byte[] buffer = new byte[256];

                Arguments.of((IntGetter) FileEntry::getType, 0, "zero type"),
                Arguments.of((IntGetter) FileEntry::getType, Integer.MAX_VALUE, "max type"),

                Arguments.of((IntGetter) FileEntry::getAttributes, 0, "no attributes"),
                Arguments.of((IntGetter) FileEntry::getAttributes, 0xFFFF, "many attributes"),

   * infinite {@code double} values are considered infinitely far away. For example, 2^2000 is not
   * representable as a double, but {@code roundToDouble(BigDecimal.valueOf(2).pow(2000), HALF_UP)}
   * will return {@code Double.MAX_VALUE}, not {@code Double.POSITIVE_INFINITY}.
   *
   * <p>For the case of {@link RoundingMode#HALF_EVEN}, this implementation uses the IEEE 754