import com.google.common.collect.testing.TestCollectionGenerator;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * Creates multisets, containing sample elements, to be tested.
 *
 * @author Jared Levy
 */
@GwtCompatible
@NullMarked
public interface TestMultisetGenerator<E extends @Nullable Object>
    extends TestCollectionGenerator<E> {
  @Override

import com.google.common.annotations.GwtCompatible;
import java.util.Map;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * Creates maps, containing sample elements, to be tested.
 *
 * @author George van den Driessche
 */
@GwtCompatible
@NullMarked
public interface TestMapGenerator<K extends @Nullable Object, V extends @Nullable Object>

It helps a lot during **development**, but you **shouldn't** use it in **production**.

///

## Deployment Concepts { #deployment-concepts }

These examples run the server program (e.g Uvicorn), starting **a single process**, listening on all the IPs (`0.0.0.0`) on a predefined port (e.g. `80`).

 * it easy to get sample values to use in such tests.
 *
 * This class is pretty fast and loose with default values: it attempts to provide values that are
 * well-formed, but doesn't guarantee values are internally consistent. Callers must take care to
 * configure the factory when sample values impact the correctness of the test.
 */
class TestValueFactory : Closeable {

            Trans2QueryPathInformationResponse resp =
                    new Trans2QueryPathInformationResponse(Trans2QueryPathInformationResponse.SMB_QUERY_FILE_BASIC_INFO);

            // Create a buffer with sample data
            byte[] buffer = new byte[100];
            // Fill with some test data
            for (int i = 0; i < buffer.length; i++) {
                buffer[i] = (byte) (i % 256);
            }

You just pass it to `Depends` and **FastAPI** knows how to do the rest.

///

## Share `Annotated` dependencies { #share-annotated-dependencies }

In the examples above, you see that there's a tiny bit of **code duplication**.

When you need to use the `common_parameters()` dependency, you have to write the whole parameter with the type annotation and `Depends()`:

```Python

import com.google.common.collect.testing.TestContainerGenerator;
import java.util.Map.Entry;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * Creates bimaps, containing sample entries, to be tested.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
@NullMarked
public interface TestBiMapGenerator<K extends @Nullable Object, V extends @Nullable Object>

Eles estão, mais ou menos, em pontas opostas, complementando-se.

Requests tem um design muito simples e intuitivo, é muito fácil de usar, com padrões sensatos. Mas ao mesmo tempo, é muito poderoso e personalizável.

É por isso que, como dito no site oficial:

> Requests é um dos pacotes Python mais baixados de todos os tempos

O jeito de usar é muito simples. Por exemplo, para fazer uma requisição `GET`, você escreveria:

```Python

    return result;
  }

  public abstract static class TestShortListGenerator implements TestListGenerator<Short> {
    @Override
    public SampleElements<Short> samples() {
      return new SampleShorts();
    }

    @Override
    public List<Short> create(Object... elements) {
      Short[] array = new Short[elements.length];
      short i = 0;

    return result;
  }

  public abstract static class TestLongListGenerator implements TestListGenerator<Long> {
    @Override
    public SampleElements<Long> samples() {
      return new SampleLongs();
    }

    @Override
    public List<Long> create(Object... elements) {
      Long[] array = new Long[elements.length];
      int i = 0;