return etag
	}
	return ""
}

// Beginning of unix time is treated as sentinel value here.
var (
	timeSentinel     = time.Unix(0, 0).UTC()
	timeSentinel1970 = time.Unix(0, 1).UTC() // 1970 used for special cases when xlmeta.version == 0
)

// Boot modTimes up to disk count, setting the value to time sentinel.
func bootModtimes(diskCount int) []time.Time {
	modTimes := make([]time.Time, diskCount)

 *
 * <p>{@code UncheckedExecutionException} is intended as an alternative to {@code
 * ExecutionException} when the exception thrown by a task is an unchecked exception. However, it
 * may also wrap a checked exception in some cases.
 *
 * <p>When wrapping an {@code Error} from another thread, prefer {@link ExecutionError}. When
 * wrapping a checked exception, prefer {@code ExecutionException}.
 *
 * @author Charles Fry
 * @since 10.0
 */

            // Then
            assertEquals(443, httpsPort);
            assertEquals(80, httpPort);
            assertNotEquals(httpsPort, httpPort);
        }
    }

    @Nested
    @DisplayName("Edge Cases")
    class EdgeCaseTests {

        @Test
        @DisplayName("Should handle reflection access to protected method")
        void testProtectedMethodAccess() throws Exception {
            // Given

this isn't always possible or practical. In such cases, you should use the
`@SuppressWarnings` annotations to silence the compiler warning, trying to keep
the scope of the suppression as small as possible. Where a piece of code
requires a lot of suppressions, it may be better to apply a single suppression
at a higher level e.g. at the method or even class level. Use your judgement.

     */
    private static Method[] getAccessibleMethods(Class<?> clazz) {
        Method[] methods = clazz.getMethods();

        // Short circuit for the (hopefully) majority of cases where the
        // clazz is public
        if (Modifier.isPublic(clazz.getModifiers())) {
            return methods;
        }

        // No luck - the class is not public, so we're going the longer way.

  var result = STANDARD_DATE_FORMAT.get().parse(this, position)
  if (position.index == length) {
    // STANDARD_DATE_FORMAT must match exactly; all text must be consumed, e.g. no ignored
    // non-standard trailing "+01:00". Those cases are covered below.
    return result
  }
  synchronized(BROWSER_COMPATIBLE_DATE_FORMAT_STRINGS) {
    for (i in 0 until BROWSER_COMPATIBLE_DATE_FORMAT_STRINGS.size) {

   * those sublists might implement a private {@code MySubList} type but serialize as a plain {@code
   * MyList} to save space. So long as {@code MyList} has all the public supertypes of {@code
   * MySubList}, this is safe. For these cases, for which {@code reserializeAndAssert} is too
   * strict, use {@link #reserialize}.
   *
   * @return the re-serialized object
   * @throws RuntimeException if the specified object was not successfully serialized or

`app.add_middleware()` receives a middleware class as the first argument and any additional arguments to be passed to the middleware.

## Integrated middlewares { #integrated-middlewares }

**FastAPI** includes several middlewares for common use cases, we'll see next how to use them.

/// note | Technical Details

For the next examples, you could also use `from starlette.middleware.something import SomethingMiddleware`.

   * to this supplier.
   *
   * <p><b>Warning: do not depend</b> on the behavior of this method.
   *
   * <p>Historically, {@code Supplier} instances in this library have implemented this method to
   * recognize certain cases where distinct {@code Supplier} instances would in fact behave
   * identically. However, as code migrates to {@code java.util.function}, that behavior will
   * disappear. It is best not to depend on it.
   */
  @Override

            // Then
            assertEquals(443, httpsPort);
            assertEquals(80, httpPort);
            assertNotEquals(httpsPort, httpPort);
        }
    }

    @Nested
    @DisplayName("Edge Cases")
    class EdgeCaseTests {

        @Test
        @DisplayName("Should handle reflection access to protected method")
        void testProtectedMethodAccess() throws Exception {
            // Given