public long used;
        /** Committed non-heap memory in bytes */
        public long committed;
        /** Maximum non-heap memory in bytes */
        public long max;
        /** The percentage of non-heap memory usage. */
        public short percent;
    }

    /**
     * Data transfer object representing JVM buffer pool statistics.
     */

   * value slightly too high than slightly too low. If the value is not exact, the {@link
   * ImmutableLongArray} that is built will very likely occupy more memory than strictly necessary;
   * to trim memory usage, build using {@code builder.build().trimmed()}.
   */
  public static Builder builder(int initialCapacity) {
    checkArgument(initialCapacity >= 0, "Invalid initialCapacity: %s", initialCapacity);

        // requireNonNull is safe because we always have either `file` or `memory`.
        requireNonNull(memory);
        return new ByteArrayInputStream(memory.getBuffer(), 0, memory.getCount());
      }
    }

    synchronized void reset() throws IOException {
      try {
        close();
      } finally {
        if (memory == null) {
          memory = new MemoryOutput();
        } else {
          memory.reset();

   * value slightly too high than slightly too low. If the value is not exact, the {@link
   * ImmutableDoubleArray} that is built will very likely occupy more memory than strictly
   * necessary; to trim memory usage, build using {@code builder.build().trimmed()}.
   */
  public static Builder builder(int initialCapacity) {
    checkArgument(initialCapacity >= 0, "Invalid initialCapacity: %s", initialCapacity);

   * value slightly too high than slightly too low. If the value is not exact, the {@link
   * ImmutableIntArray} that is built will very likely occupy more memory than strictly necessary;
   * to trim memory usage, build using {@code builder.build().trimmed()}.
   */
  public static Builder builder(int initialCapacity) {
    checkArgument(initialCapacity >= 0, "Invalid initialCapacity: %s", initialCapacity);

 * class to read a response that is larger than the entire memory allocated to the current process.
 * It can even stream a response larger than the total storage on the current device, which is a
 * common requirement for video streaming applications.
 *
 * Because this class does not buffer the full response in memory, the application may not

        cos.close();
        assertTrue(file.exists());
    }

    @Test
    public void testThresholdOne() throws IOException {
        // With threshold 1, writing 1 byte should stay in memory
        ContentOutputStream cos = new ContentOutputStream(1, Curl.tmpDir);
        cos.write(new byte[] { 1 });
        assertTrue(cos.isInMemory());
        assertFalse(cos.done);
        cos.close();
    }

        // Test that constructor accepts Error as cause (verifies Throwable parameter change)
        String message = "SSO login failed due to memory error";
        OutOfMemoryError error = new OutOfMemoryError("Not enough memory for SSO login");
        SsoLoginException exception = new SsoLoginException(message, error);

        assertEquals(message, exception.getMessage());

        long memory1 = MemoryUtil.getUsedMemory();
        assertTrue(memory1 >= 0);

        // Create some objects to change memory usage
        @SuppressWarnings("unused")
        String[] largeArray = new String[1000];
        for (int i = 0; i < 1000; i++) {
            largeArray[i] = "test" + i;
        }

        long memory2 = MemoryUtil.getUsedMemory();

- **Caching** - Bean descriptors and reflection metadata are cached for improved performance
- **Lazy initialization** - Resources and expensive operations are initialized only when needed  
- **Memory efficient** - Specialized collections like `LruHashMap` and `ArrayMap` for memory-conscious applications
- **Java 21 features** - Switch expressions and pattern matching for reduced overhead

## 🧪 Building and Testing

### Development Setup
```bash