throw (Error) cause;
      }
    }
    throw e;
  }

  @Override
  public V get() throws ExecutionException, InterruptedException {
    try {
      super.get();
    } catch (ExecutionException e) {
      rethrow(e);
    }
    throw new AssertionError("Unreachable");
  }

  @Override
  public V get(long timeout, TimeUnit unit)
      throws InterruptedException, ExecutionException, TimeoutException {

      // don't let the entries get GCed
      List<Entry<Object, Object>> warmed = warmUp(cache);
      for (int i = WARMUP_MIN; i < WARMUP_MAX; i++) {
        Entry<Object, Object> entry = warmed.get(i - WARMUP_MIN);
        Object newValue = new Object();
        assertSame(entry.getValue(), cache.asMap().put(entry.getKey(), newValue));
        // don't let the new entry get GCed

#### Définir un *décorateur d'opération de chemin*

{* ../../docs_src/first_steps/tutorial001.py hl[6] *}

Le `@app.get("/")` dit à **FastAPI** que la fonction en dessous est chargée de gérer les requêtes qui vont sur :

* le chemin `/`
* en utilisant une <abbr title="une méthode GET HTTP">opération <code>get</code></abbr>

/// info | `@décorateur` Info

Cette syntaxe `@something` en Python est appelée un "décorateur".

			buf.WriteByte('\n')
		}
	}
	canonicalHeaders := buf.String()

	// Get signed headers.
	signedHeaders := strings.Join(headers, ";")

	// Get canonical query string.
	req.URL.RawQuery = strings.ReplaceAll(req.URL.Query().Encode(), "+", "%20")

	// Get canonical URI.
	canonicalURI := s3utils.EncodePath(req.URL.Path)

	// Get canonical request.
	// canonicalRequest =
	//  <HTTPMethod>\n

| `minio_cluster_health_status`                     | Get current cluster health status              |
| `minio_cluster_health_erasure_set_healing_drives` | Count of healing drives in the erasure set     |
| `minio_cluster_health_erasure_set_online_drives`  | Count of online drives in the erasure set      |
| `minio_cluster_health_erasure_set_read_quorum`    | Get read quorum of the erasure set             |

        assertNotNull(readings);
        assertEquals(3, readings.size());
        assertEquals("TEST_en", readings.get(0));
        assertEquals("TEST_ja", readings.get(1));
        assertEquals("TEST_fr", readings.get(2));
    }

    @Test
    public void testConvertWithNoLanguages() throws IOException {
        // Test convert with no languages specified

    Collection<V> result = multimap().asMap().get(k0());
    result.add(v3());
    assertContentsAnyOrder(multimap().get(k0()), v0(), v3());
  }

  @CollectionSize.Require(absent = ZERO)
  @MapFeature.Require({SUPPORTS_REMOVE, SUPPORTS_PUT})
  public void testPropagatesRemoveThenAddToMultimap() {
    int oldSize = getNumElements();

    Collection<V> result = multimap().asMap().get(k0());
    assertTrue(result.remove(v0()));

        final int maxQueryLength = fessConfig.getQueryMaxLengthAsInteger();

        stream(conditions.get(SearchRequestParams.AS_OCCURRENCE))
                .of(stream -> stream.filter(this::isOccurrence).findFirst().ifPresent(q -> queryBuf.insert(0, q + ":")));

        stream(conditions.get(SearchRequestParams.AS_Q))
                .of(stream -> stream.filter(q -> StringUtil.isNotBlank(q) && q.length() <= maxQueryLength)

  enum CollectStrategy {
    /** Get one accumulator and accumulate the elements into it sequentially. */
    SEQUENTIAL {
      @Override
      final <T extends @Nullable Object, A extends @Nullable Object, R extends @Nullable Object>
          A result(Collector<T, A, R> collector, Iterable<T> inputs) {
        A accum = collector.supplier().get();
        for (T input : inputs) {

        testRule.register(1);

        List<Rule> rules = ruleManager.getRules();
        assertEquals(3, rules.size());
        assertEquals("rule1", rules.get(0).getRuleId());
        assertEquals("middle", rules.get(1).getRuleId());
        assertEquals("rule2", rules.get(2).getRuleId());
    }

    /**
     * Test register method with last index
     */
    public void test_register_lastIndex() {