throw new AssertionError(e);
        }
    }

    // Utility to invoke a private method reflectively
    private static Object invokePrivate(Object targetOrClass, String methodName, Class<?>[] paramTypes, Object... args) {
        try {
            final Class<?> cls = targetOrClass instanceof Class<?> ? (Class<?>) targetOrClass : targetOrClass.getClass();

    T proxy =
        Reflection.newProxy(
            interfaceType,
            new AbstractInvocationHandler() {
              @Override
              protected Object handleInvocation(Object p, Method m, @Nullable Object[] args)
                  throws Throwable {
                throw exception;
              }
            });
    T wrapper = wrapperFunction.apply(proxy);
    try {

class ImmutableCollections {

    private static final Map<?, ?> EMPTY_MAP = new AbstractImmutableMap<>() {
        @Override
        public Set<Entry<Object, Object>> entrySet() {
            return new AbstractImmutableSet<>() {
                @Override
                public Iterator<Entry<Object, Object>> iterator() {
                    return new Iterator<>() {
                        @Override
                        public boolean hasNext() {

    listeners = update;
    return old;
  }

  static boolean casValue(AbstractFutureState<?> future, @Nullable Object expect, Object update) {
    if (future.value == expect) {
      future.value = update;
      return true;
    }
    return false;
  }

  final @Nullable Object value() {
    return value;
  }

  final @Nullable Listener listeners() {
    return listeners;
  }

        final List<Map<String, Object>> sentDocList = new ArrayList<>();
        final SearchEngineClient client = new SearchEngineClient() {
            @Override
            public BulkResponse addAll(final String index, final List<Map<String, Object>> docList,
                    final BiConsumer<Map<String, Object>, IndexRequestBuilder> options) {
                sentIndex.set(index);

        @SuppressWarnings("unchecked")
        Map<String, Object> nestedResult = (Map<String, Object>) result.get("nested_map");
        assertEquals("nestedValue", nestedResult.get("nested_key"));
    }

    public void test_toLowerHyphen_emptyMap() {
        Map<String, Object> source = new HashMap<>();
        Map<String, Object> result = searchLogHelper.toLowerHyphen(source);

        assertNotNull(result);

     * Converts to {@link Float}.
     *
     * @param o
     *            The object to convert
     * @return The converted {@link Float}
     */
    public static Float toFloat(final Object o) {
        return toFloat(o, null);
    }

    /**
     * Converts to {@link Float}.
     *
     * @param o
     *            The object to convert
     * @param pattern
     *            The pattern string

  }

  public void testToArray_largeEnough() {
    Object[] actual = getList().toArray(new Object[getNumElements()]);
    assertArrayEquals("toArray(largeEnough) order should match list", createOrderedArray(), actual);
  }

  private static void assertArrayEquals(String message, Object[] expected, Object[] actual) {
    assertEquals(message, asList(expected), asList(actual));
  }

{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[21:22] hl[21:22] *}

### Create a Session Dependency { #create-a-session-dependency }

A **`Session`** is what stores the **objects in memory** and keeps track of any changes needed in the data, then it **uses the `engine`** to communicate with the database.

        }
        return (T) arg;
    }

    private Object convertPrimitiveWrapper(final Object arg) {
        return NumberConversionUtil.convertPrimitiveWrapper(propertyType, arg);
    }

    private Object convertNumber(final Object arg) {
        return NumberConversionUtil.convertNumber(propertyType, arg);
    }

    private Object convertDate(final Object arg) {
        if (propertyType == java.util.Date.class) {