// need a sample HTTP request to be sent as argument so that the relevant handler is called, the handler registration is expected
// to be done since its called from within the API handler tests, the reference to the registered HTTP handler has to be sent
// as an argument.

    Serialization.writeMultiset(this, stream);
  }

  /**
   * @serialData the {@code Class<E>} for the enum type, the number of distinct elements, the first
   *     element, its count, the second element, its count, and so on
   */
  @GwtIncompatible // java.io.ObjectInputStream
  private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException {
    stream.defaultReadObject();

Il serait en fait plus courant d'utiliser Requests _à l'intérieur_ d'une application FastAPI.

Mais quand même, FastAPI s'est inspiré de Requests.

**Requests** est une bibliothèque pour _interagir_ avec les API (en tant que client), tandis que **FastAPI** est une bibliothèque pour _créer_ des API (en tant que serveur).

Ils sont, plus ou moins, aux extrémités opposées, se complétant l'un l'autre.

        Field remarkField = SmbShareInfo.class.getDeclaredField("remark");
        remarkField.setAccessible(true);
        assertEquals("Remark for Share1", remarkField.get(shareInfo));

        // Verify the second entry
        FileEntry entry2 = entries[1];
        assertNotNull(entry2);
        assertEquals("Share2", entry2.getName());
        assertEquals(32, entry2.getType()); // TYPE_PRINTER constant (0x20)
    }

			return
		}
		if pingInterval < 1 {
			writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrInvalidQueryParams), r.URL)
			return
		}
		t := time.NewTicker(time.Duration(pingInterval) * time.Second)
		defer t.Stop()
		emptyEventTicker = t.C
	} else {
		// Deprecated Apr 2023
		t := time.NewTicker(500 * time.Millisecond)
		defer t.Stop()
		keepAliveTicker = t.C
	}

	enc := json.NewEncoder(w)

Par défaut, **FastAPI** attendra sa déclaration directement dans le body.

Cependant, si vous souhaitez qu'il interprête correctement un JSON avec une clé `item` associée au contenu du modèle, comme cela serait le cas si vous déclariez des paramètres body additionnels, vous pouvez utiliser le paramètre spécial `embed` de `Body` :

```Python
item: Item = Body(embed=True)
```

Voici un exemple complet :

func (r BatchJobExpire) Notify(ctx context.Context, body io.Reader) error {
	if r.NotificationCfg.Endpoint == "" {
		return nil
	}

	ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
	defer cancel()

	req, err := http.NewRequestWithContext(ctx, http.MethodPost, r.NotificationCfg.Endpoint, body)
	if err != nil {
		return err
	}

	if r.NotificationCfg.Token != "" {

	c.Assert(err, nil)
	c.Assert(response.StatusCode, http.StatusOK)

	objectName := "test-multipart-object"

	// 1. Initiate 2 uploads for the same object
	// 2. Upload 2 parts for the second upload
	// 3. Abort the second upload.
	// 4. Abort the first upload.
	// This will test abort upload when there are more than one upload IDs
	// and the case where there is only one upload ID.

		Data:    "something else",
	}

	result := DB.Clauses(clause.OnConflict{
		OnConstraint: "some_id_other_id_unique",
		UpdateAll:    true,
	}).Create(&thing2)
	if result.Error != nil {
		t.Errorf("creating second thing: %v", result.Error)
	}

	var things []Thing
	if err := DB.Find(&things).Error; err != nil {
		t.Errorf("Failed, got error: %v", err)
	}

	if len(things) > 1 {

        long time = System.currentTimeMillis();
        ServerMessageBlock.writeTime(time, buffer, 0);
        long readTime = ServerMessageBlock.readTime(buffer, 0);
        // Precision may be lost, so check within a second
        assertTrue(Math.abs(time - readTime) < 1000);
    }

    @Test
    void testTimeReadWriteZero() {
        byte[] buffer = new byte[8];
        ServerMessageBlock.writeTime(0, buffer, 0);