assertTrue(item + " must be equivalent to itself", equivalence.equivalent(item, item));
      assertEquals(
          "the hash of " + item + " must be consistent",
          equivalence.hash(item),
          equivalence.hash(item));
    }
  }

		tops = tops[:0]
		var topSig xlMetaV2VersionHeader
		consistent := true // Are all signatures consistent (shortcut)
		for _, vers := range versions {
			if len(vers) == 0 {
				consistent = false
				continue
			}
			ver := vers[0]
			if len(tops) == 0 {
				consistent = true
				topSig = ver.header
			} else {
				consistent = consistent && ver.header == topSig
			}
			tops = append(tops, vers[0])

generates the identity as a public key. This also // makes this function consistent with crypto/elliptic.GenerateKey. key[1] ^= 0x42 // Mask off any excess bits if the size of the underlying field is not a // whole number of bytes, which is only the case for P-521. if c.curve == p521 && c.N[0]&0b1111_1110 == 0 { key[0] &= 0b0000_0001 } privateKey, err := NewPrivateKey(c, key) if err != nil { continue } // A "Pairwise Consistency Test" makes no sense if we just generated the // public key from an ephemeral...

Do not try to translate everything. In particular, keep common programming terms when that is the established usage in the French docs (e.g. «framework», «endpoint», «plug-in», «payload»). Use French where the existing docs already consistently use French (e.g. «requête», «réponse»).

Keep class names, function names, modules, file names, and CLI commands unchanged.

### List of English terms and their preferred French translations

But now that FastAPI 0.99.0 and above uses OpenAPI 3.1.0, that uses JSON Schema 2020-12, and Swagger UI 5.0.0 and above, everything is more consistent and the examples are included in JSON Schema.

### Swagger UI and OpenAPI-specific `examples` { #swagger-ui-and-openapi-specific-examples }

        @Test
        @DisplayName("getOpnum should be consistent across multiple calls")
        void testGetOpnumConsistency() {
            // When
            int opnum1 = bind.getOpnum();
            int opnum2 = bind.getOpnum();
            int opnum3 = bind.getOpnum();

            // Then
            assertEquals(opnum1, opnum2, "Opnum should be consistent");

    writeOrCountBytes(sink, false)
  }

  /**
   * Either writes this request to [sink] or measures its content length. We have one method
   * do double-duty to make sure the counting and content are consistent, particularly when it comes
   * to awkward operations like measuring the encoded length of header strings, or the
   * length-in-digits of an encoded integer.
   */
  private fun writeOrCountBytes(
    sink: BufferedSink?,

        // Then
        assertEquals(0, bytesRead);
    }

    @ParameterizedTest
    @ValueSource(ints = { 0, 10, 50, 100, 200 })
    @DisplayName("Should write consistent structure at different offsets")
    void testWriteBytesAtDifferentOffsets(int offset) {
        // Given
        Configuration mockConfig = mock(Configuration.class);

            assertEquals(2 + (count * 2), encoded);
            // Note: size() returns 4 + count*2, but encode returns 2 + count*2
            // This is an implementation inconsistency in the original code
            assertNotEquals(context.size(), encoded);
            assertEquals(4 + (count * 2), context.size());
        }

        @Test

        assertNotNull(rp);
        assertEquals(name, rp.name(), "name() must match input");
        assertEquals(name, rp.toString(), "toString() should default to name()");
        // Ordinal is consistent with declaration order
        switch (name) {
        case "NONE":
            assertEquals(0, rp.ordinal());
            break;
        case "NO_TIMEOUT":
            assertEquals(1, rp.ordinal());