q := r.URL.Query()
	reqQuery := make(map[string]string, len(q))
	for k, v := range q {
		reqQuery[k] = strings.Join(v, ",")
	}
	entry.ReqQuery = reqQuery

	reqHeader := make(map[string]string, len(r.Header))
	for k, v := range r.Header {
		reqHeader[k] = strings.Join(v, ",")
	}
	entry.ReqHeader = reqHeader

	wh := w.Header()
	entry.RequestID = wh.Get(xhttp.AmzRequestID)

		if !strings.HasPrefix(lkey, "x-amz-") {
			continue
		}
		keys = append(keys, lkey)
		keyval[lkey] = strings.Join(headers[key], ",")
	}
	sort.Strings(keys)
	var canonicalHeaders []string
	for _, key := range keys {
		canonicalHeaders = append(canonicalHeaders, key+":"+keyval[key])
	}
	return strings.Join(canonicalHeaders, "\n")
}

// Return canonical resource string.

/// note | Remarque

`PATCH` est moins utilisé et moins connu que `PUT`.

Et de nombreuses équipes n’utilisent que `PUT`, même pour les mises à jour partielles.

Vous êtes libre de les utiliser comme vous le souhaitez, **FastAPI** n’impose aucune restriction.

Mais ce guide vous montre, plus ou moins, la façon dont ils sont censés être utilisés.

///

    assertThat(UnsignedLongs.join(",")).isEmpty();
    assertThat(UnsignedLongs.join(",", 1)).isEqualTo("1");
    assertThat(UnsignedLongs.join(",", 1, 2)).isEqualTo("1,2");
    assertThat(UnsignedLongs.join(",", -1, Long.MIN_VALUE))
        .isEqualTo("18446744073709551615,9223372036854775808");
    assertThat(UnsignedLongs.join("", 1, 2, 3)).isEqualTo("123");
    assertThat(UnsignedLongs.join("", -1, Long.MIN_VALUE))

  }

  public void testJoin() {
    assertThat(SignedBytes.join(",", EMPTY)).isEmpty();
    assertThat(SignedBytes.join(",", ARRAY1)).isEqualTo("1");
    assertThat(SignedBytes.join(",", (byte) 1, (byte) 2)).isEqualTo("1,2");
    assertThat(SignedBytes.join("", (byte) 1, (byte) 2, (byte) 3)).isEqualTo("123");
    assertThat(SignedBytes.join(",", (byte) -128, (byte) -1)).isEqualTo("-128,-1");
  }

        JobProcess jobProcess = new JobProcess(mockProcess, 100, callback);
        InputStreamThread thread = jobProcess.getInputStreamThread();

        thread.start();
        thread.join(1000);

        assertEquals(2, callbackResults.size());
        assertEquals("integration test", callbackResults.get(0));
        assertEquals("second line", callbackResults.get(1));

    assertThat(UnsignedLongs.join(",")).isEmpty();
    assertThat(UnsignedLongs.join(",", 1)).isEqualTo("1");
    assertThat(UnsignedLongs.join(",", 1, 2)).isEqualTo("1,2");
    assertThat(UnsignedLongs.join(",", -1, Long.MIN_VALUE))
        .isEqualTo("18446744073709551615,9223372036854775808");
    assertThat(UnsignedLongs.join("", 1, 2, 3)).isEqualTo("123");
    assertThat(UnsignedLongs.join("", -1, Long.MIN_VALUE))

                fullMessage = join(fullMessage, "Unknown host " + exceptionMessage);
            } else if (!fullMessage.contains(exceptionMessage)) {
                fullMessage = join(fullMessage, exceptionMessage);
            }

            if (!dejaVu.add(t)) {
                fullMessage = join(fullMessage, "[CIRCULAR REFERENCE]");
                break;
            }

func TestNewPReader(t *testing.T) {
	files, err := os.ReadDir("testdata")
	if err != nil {
		t.Fatal(err)
	}
	for _, file := range files {
		t.Run(file.Name(), func(t *testing.T) {
			f, err := os.Open(filepath.Join("testdata", file.Name()))
			if err != nil {
				t.Fatal(err)
			}
			r := NewPReader(f, &ReaderArgs{})
			var record sql.Record
			for {
				record, err = r.Read(record)
				if err != nil {
					break

)

func TestNewReader(t *testing.T) {
	files, err := os.ReadDir("testdata")
	if err != nil {
		t.Fatal(err)
	}
	for _, file := range files {
		t.Run(file.Name(), func(t *testing.T) {
			f, err := os.Open(filepath.Join("testdata", file.Name()))
			if err != nil {
				t.Fatal(err)
			}
			r := NewReader(f, &ReaderArgs{})
			var record sql.Record
			for {
				record, err = r.Read(record)
				if err != nil {
					break
				}