},
		Totals: madmin.RStat{
			Count: float64(rt.SinceUptime.Count),
			Bytes: rt.SinceUptime.Bytes,
		},
		ErrCounts: errCounts,
	}
}

func (rt *RTimedMetrics) addsize(size int64, err error) {
	// failures seen since uptime
	atomic.AddInt64(&rt.SinceUptime.Bytes, size)
	atomic.AddInt64(&rt.SinceUptime.Count, 1)
	rt.LastMinute.addsize(size)
	rt.LastHour.addsize(size)

We can do better...

## What makes a dependency { #what-makes-a-dependency }

Up to now you have seen dependencies declared as functions.

But that's not the only way to declare dependencies (although it would probably be the more common).

The key factor is that a dependency should be a "callable".

            });

    // Don't copy this into your own test!
    // Use e.g. awaitClear or await(CountDownLatch) instead.
    GcFinalization.awaitFullGc();

    // Attempt to help with some flakiness that we've seen: b/387521512.
    GcFinalization.awaitFullGc();

    assertEquals(0, finalizerRan.getCount());
    assertNull(ref.get());
  }

{* ../../docs_src/query_params/tutorial004_py310.py hl[6,8] *}

## Required query parameters { #required-query-parameters }

When you declare a default value for non-path parameters (for now, we have only seen query parameters), then it is not required.

If you don't want to add a specific value but just make it optional, set the default as `None`.

 * the return type. For this case, we provide a more expensive workaround in {@code
 * JdkFutureAdapters}. However, when possible, it is more efficient and reliable to create a {@code
 * ListenableFuture} directly.
 *
 * @author Sven Mawson
 * @author Nishant Thakkar
 * @since 1.0
 */
/*
 * Some of the annotations below were added after we released our separate
 * com.google.guava:listenablefuture:1.0 artifact. (For more on that artifact, see

{* ../../docs_src/path_operation_advanced_configuration/tutorial004.py hl[19:29] *}

## Additional Responses { #additional-responses }

You probably have seen how to declare the `response_model` and `status_code` for a *path operation*.

That defines the metadata about the main response of a *path operation*.

 * the return type. For this case, we provide a more expensive workaround in {@code
 * JdkFutureAdapters}. However, when possible, it is more efficient and reliable to create a {@code
 * ListenableFuture} directly.
 *
 * @author Sven Mawson
 * @author Nishant Thakkar
 * @since 1.0
 */
/*
 * Some of the annotations below were added after we released our separate
 * com.google.guava:listenablefuture:1.0 artifact. (For more on that artifact, see

  // the "short hash".
  //
  // The `keys`, `values`, and `entries` arrays always have the same size as each other. They can be
  // seen as fields of an imaginary `Entry` object like this:
  //
  // class Entry {
  //    int hash;
  //    Entry next;
  //    K key;
  //    V value;
  // }
  //

        // Reserved (4 bytes) - The implementation skips writing these bytes,
        // so they will have the initial pattern (0xCCCCCCCC)
        // This is expected behavior as seen in the implementation at line 131
        assertEquals((byte) 0xCC, buffer[4]);
        assertEquals((byte) 0xCC, buffer[5]);
        assertEquals((byte) 0xCC, buffer[6]);
        assertEquals((byte) 0xCC, buffer[7]);

 * thrown by {@linkplain MoreExecutors#directExecutor direct execution}) will be caught and logged.
 *
 * @author Nishant Thakkar
 * @author Sven Mawson
 * @since 1.0
 */
@J2ktIncompatible
@GwtIncompatible
public final class ExecutionList {
  /** Logger to log exceptions caught when running runnables. */