}

  public void testParse_maximumWeightRepeated() {
    assertThrows(IllegalArgumentException.class, () -> parse("maximumWeight=10, maximumWeight=20"));
  }

  public void testParse_maximumSizeAndMaximumWeight() {
    assertThrows(IllegalArgumentException.class, () -> parse("maximumSize=10, maximumWeight=20"));
  }

  public void testParse_concurrencyLevel() {

    }
  }

  public void testFloorPowerOfTwoNegative() {
    for (int x : NEGATIVE_INTEGER_CANDIDATES) {
      assertThrows(IllegalArgumentException.class, () -> IntMath.floorPowerOfTwo(x));
    }
  }

  public void testCeilingPowerOfTwoZero() {
    assertThrows(IllegalArgumentException.class, () -> IntMath.ceilingPowerOfTwo(0));
  }

  public void testFloorPowerOfTwoZero() {

    Callable<@Nullable Void> cancelRunnable =
        new Callable<@Nullable Void>() {
          @Override
          public @Nullable Void call() {
            cancellationSuccess.set(currentFuture.get().cancel(true));
            awaitUnchecked(barrier);
            return null;
          }
        };
    Callable<@Nullable Void> setFutureCompleteSuccessfullyRunnable =

### Casos de uso: serviço externo

Um exemplo pode ser que você possua um provedor de autenticação externo que você precisa chamar.

Você envia ao serviço um *token* e ele retorna um usuário autenticado.

Este provedor pode cobrar por requisição, e chamá-lo pode levar mais tempo do que se você tivesse um usuário fixo para os testes.

@NullUnmarked
public class TypeResolverTest extends TestCase {

  public void testWhere_noMapping() {
    Type t = aTypeVariable();
    assertEquals(t, new TypeResolver().resolveType(t));
  }

  public void testWhere_typeVariableMapping() {
    Type t = aTypeVariable();
    assertEquals(String.class, new TypeResolver().where(t, String.class).resolveType(t));
  }

  public <T> void testWhere_indirectMapping() {

Caso você utilize o arquivo `requirements.txt`, você poderia especificar a versão com:

```txt
fastapi==0.45.0
```

Isso significa que você conseguiria utilizar a versão exata `0.45.0`.

Ou, você poderia fixá-la com:

```txt
fastapi>=0.45.0,<0.46.0
```

            new LegacyComparable("foo"))
        .inOrder();
  }

  public void testNewTreeMultisetComparator() {
    TreeMultiset<String> multiset = TreeMultiset.create(Collections.reverseOrder());
    multiset.add("bar", 3);
    multiset.add("foo", 2);
    assertThat(multiset).containsExactly("foo", "foo", "bar", "bar", "bar").inOrder();
  }

  public void testRetainOccurrencesEmpty() {
    Multiset<String> multiset = HashMultiset.create();

              }
            });
  }

  public void testCreate_invalidType() {
    assertThrows(IllegalArgumentException.class, () -> MediaType.create("te><t", "plaintext"));
  }

  public void testCreate_invalidSubtype() {
    assertThrows(IllegalArgumentException.class, () -> MediaType.create("text", "pl@intext"));
  }

  public void testCreate_wildcardTypeDeclaredSubtype() {

    /**
     * @throws Exception
     */
    @Test
    public void testSplit() throws Exception {
        final String[] array = StringUtil.split("aaa\nbbb", "\n");
        assertEquals("1", 2, array.length);
        assertEquals("2", "aaa", array[0]);
        assertEquals("3", "bbb", array[1]);
    }

    /**
     *
     */
    @Test
    public void testSplit2() {

  }

  public void testWildcardFuture() {
    SettableFuture<String> settable = SettableFuture.create();
    ListenableFuture<?> f = settable;
    FutureCallback<@Nullable Object> callback =
        new FutureCallback<@Nullable Object>() {
          @Override
          public void onSuccess(@Nullable Object result) {}

          @Override
          public void onFailure(Throwable t) {}
        };