func gcmCounterCryptGener(b *aes.Block, out, src []byte, counter *[gcmBlockSize]byte) { var mask [gcmBlockSize]byte for len(src) >= gcmBlockSize { aes.EncryptBlockInternal(b, mask[:], counter[:]) gcmInc32(counter) subtle.XORBytes(out, src, mask[:]) out = out[gcmBlockSize:] src = src[gcmBlockSize:] } if len(src) > 0 { aes.EncryptBlockInternal(b, mask[:], counter[:]) gcmInc32(counter) subtle.XORBytes(out, src, mask[:]) } } // gcmInc32 treats the final four bytes of counterBlock as a big-endian value //...

import jcifs.SmbConstants;

/**
 * Basic unit tests for {@link SmbConstants}.  The interface only
 * provides {@code static final} constants, so the test suite focuses on
 * value correctness, bit‑mask logic, and some derived properties.
 *
 * <p>Mockito is exercised in a dummy scenario to satisfy the
 * request for an interaction test.  The mock represents a
 * {@code SmbTransport} collaborator and is used only for

    int[] expected = new int[256];
    for (int i = 0; i < expected.length; i++) {
      int crc = i;
      for (int j = 7; j >= 0; j--) {
        int mask = -(crc & 1);
        crc = (crc >>> 1) ^ (CRC32C_GENERATOR_FLIPPED & mask);
      }
      expected[i] = crc;
    }

    int[] actual = Crc32cHashFunction.Crc32cHasher.byteTable;
    assertTrue(

{* ../../docs_src/app_testing/app_a_py310/test_main.py hl[3] *}

...e ter o código para os testes como antes.

## Testando: exemplo estendido { #testing-extended-example }

Agora vamos estender este exemplo e adicionar mais detalhes para ver como testar diferentes partes.

### Arquivo de aplicação **FastAPI** estendido { #extended-fastapi-app-file }

Vamos continuar com a mesma estrutura de arquivo de antes:

```
.
├── app

func (s *peerRESTServer) ConsoleLogHandler(ctx context.Context, params *grid.MSS, out chan<- *grid.Bytes) *grid.RemoteErr {
	mask, err := strconv.Atoi(params.Get(peerRESTLogMask))
	if err != nil {
		mask = int(madmin.LogMaskAll)
	}
	ch := make(chan log.Info, 1000)
	err = globalConsoleSys.Subscribe(ch, ctx.Done(), "", 0, madmin.LogMask(mask), nil)
	if err != nil {
		return grid.NewRemoteErr(err)
	}
	var buf bytes.Buffer

Vous pouvez utiliser des modèles Pydantic pour déclarer des paramètres de requête dans FastAPI. 😎

/// tip | Astuce

Alerte spoiler : vous pouvez aussi utiliser des modèles Pydantic pour déclarer des cookies et des en-têtes, mais vous lirez cela plus tard dans le tutoriel. 🤫

import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import org.jspecify.annotations.Nullable;

/**
 * A collection that maps keys to values, similar to {@link Map}, but in which each key may be
 * associated with <i>multiple</i> values. You can visualize the contents of a multimap either as a
 * map from keys to <i>nonempty</i> collections of values:
 *

  public final @Nullable V getOrDefault(@Nullable Object key, @Nullable V defaultValue) {
    /*
     * Even though it's weird to pass a defaultValue that is null, some callers do so. Those who
     * pass a literal "null" should probably just use `get`, but I would expect other callers to
     * pass an expression that *might* be null. This could happen with:
     *
     * - a `getFooOrDefault(@Nullable Foo defaultValue)` method that returns

# Sobre HTTPS { #about-https }

É fácil assumir que HTTPS é algo que é apenas "habilitado" ou não.

Mas é bem mais complexo do que isso.

/// tip | Dica

Se você está com pressa ou não se importa, continue com as seções seguintes para instruções passo a passo para configurar tudo com diferentes técnicas.

///

Para aprender o básico de HTTPS do ponto de vista do consumidor, verifique [https://howhttps.works/](https://howhttps.works/).

# Types de données supplémentaires { #extra-data-types }

Jusqu'à présent, vous avez utilisé des types de données courants, comme :

* `int`
* `float`
* `str`
* `bool`

Mais vous pouvez aussi utiliser des types de données plus complexes.

Et vous bénéficierez toujours des mêmes fonctionnalités que jusqu'à présent :

* Excellente prise en charge dans l'éditeur.
* Conversion des données à partir des requêtes entrantes.