import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.EnumMap;
import java.util.Map;

/**
 * A {@code BiMap} backed by two {@code EnumMap} instances. Null keys and values are not permitted.
 * An {@code EnumBiMap} and its inverse are both serializable.
 *
 * <p>See the Guava User Guide article on <a href=

internal fun <T> readFieldOrNull(
  instance: Any,
  fieldType: Class<T>,
  fieldName: String,
): T? {
  var c: Class<*> = instance.javaClass
  while (c != Any::class.java) {
    try {
      val field = c.getDeclaredField(fieldName)
      field.isAccessible = true
      val value = field.get(instance)
      return if (!fieldType.isInstance(value)) null else fieldType.cast(value)

   * this parameter is marked nullable, this method does nothing.
   *
   * @param instance the instance to invoke {@code method} on, or null if {@code method} is static
   */
  public void testMethodParameter(@Nullable Object instance, Method method, int paramIndex) {
    method.setAccessible(true);
    testParameter(instance, invokable(instance, method), paramIndex, method.getDeclaringClass());
  }

  /**

            // Both non-null - should be same instance
            assertSame(first, second, "Second getSubject should return same cached instance as first");
        } else {
            fail("Inconsistent behavior: first=" + first + ", second=" + second);
        }

        // Third call should return the same cached Subject instance
        Subject third = auth.getSubject();

interface NestedType {
    Property<String> getSomeProperty()
}
class Example {
    Property<NestedType> getNestedProperty()
}
```

This is unnecessary because users will have trouble creating instances of `NestedType` and merging different instances of `NestedType`. It's also more awkward for users to access the properties in the nested property.

 *   }
 * }, executor);
 * }
 *
 * <h3>How to get an instance</h3>
 *
 * <p>We encourage you to return {@code ListenableFuture} from your methods so that your users can
 * take advantage of the {@linkplain Futures utilities built atop the class}. The way that you will
 * create {@code ListenableFuture} instances depends on how you currently create {@code Future}
 * instances:
 *
 * <ul>

 *   }
 * }, executor);
 * }
 *
 * <h3>How to get an instance</h3>
 *
 * <p>We encourage you to return {@code ListenableFuture} from your methods so that your users can
 * take advantage of the {@linkplain Futures utilities built atop the class}. The way that you will
 * create {@code ListenableFuture} instances depends on how you currently create {@code Future}
 * instances:
 *
 * <ul>

 * and DI container integration.
 *
 * <p>Thread Safety: This class is thread-safe. Each evaluate() call creates
 * a new GroovyShell instance to ensure thread isolation.</p>
 *
 * <p>Resource Management: GroovyClassLoader instances are properly managed
 * and cleaned up after script evaluation to prevent memory leaks.</p>
 */
public class GroovyEngine extends AbstractScriptEngine {

     */
    Iterable<FieldDesc> getFieldDescs();

    /**
     * Creates a new instance.
     *
     * @param <T>
     *            The type of the Bean class
     * @param args
     *            The arguments to pass to the constructor
     * @return A new instance
     */
    <T> T newInstance(Object... args);

    /**

        }
    }

    // Heterogeneous buffer sizes: cache should return exactly what was released
    @Test
    @DisplayName("Cache preserves and returns original buffer instances of varying sizes")
    void returnsExactReleasedInstances() {
        BufferCacheImpl impl = new BufferCacheImpl(3, 8);
        byte[] s1 = new byte[2];
        byte[] s2 = new byte[7];