Vous pouvez déclarer qu’un paramètre accepte `None`, mais qu’il est tout de même requis. Cela obligerait les clients à envoyer une valeur, même si la valeur est `None`.

Pour ce faire, vous pouvez déclarer que `None` est un type valide tout en ne déclarant pas de valeur par défaut :

{* ../../docs_src/query_params_str_validations/tutorial006c_an_py310.py hl[9] *}

                        severity,
                        version,
                        prefix + fieldName,
                        sourceHint,
                        "with value '" + id + "' does not match a valid id pattern.",
                        tracker);
                return false;
            }
            validIds.add(id);
            return true;
        }
    }

  private final transient int hashCode;
  // the same values as `elements` in hashed positions (plus nulls)
  @VisibleForTesting final transient @Nullable Object[] table;
  // 'and' with an int to get a valid table index.
  private final transient int mask;
  private final transient int size;

  RegularImmutableSet(
      @Nullable Object[] elements, int hashCode, @Nullable Object[] table, int mask, int size) {

        doNothing().when(mockBufferCache).releaseBuffer(buffer);

        // When & Then
        assertDoesNotThrow(() -> {
            mockBufferCache.releaseBuffer(buffer);
        }, "releaseBuffer should handle valid buffers");
    }

    @Test
    @DisplayName("getBuffer should return buffers for use")
    void testGetBufferBasicUsage() {
        // When
        byte[] buffer1 = testCache.getBuffer();

Mais l’exemple ici utilise `PATCH` car il a été créé pour ces cas d’usage.

///

/// note | Remarque

Remarquez que le modèle d’entrée est toujours validé.

Ainsi, si vous souhaitez recevoir des mises à jour partielles pouvant omettre tous les attributs, vous devez disposer d’un modèle avec tous les attributs marqués comme optionnels (avec des valeurs par défaut ou `None`).

        }
        return facetFieldSet != null && facetFieldSet.contains(field);
    }

    /**
     * Checks if the specified sort value is valid for facet sorting.
     *
     * @param sort the sort value to check
     * @return true if the sort value is valid for facets ("count" or "index"), false otherwise
     */
    public boolean isFacetSortValue(final String sort) {

/*
An example of wrapping a C library in Go. This is the GNU
multiprecision library gmp's integer type mpz_t wrapped to look like
the Go package big's integer type Int.

This is a syntactically valid Go program—it can be parsed with the Go
parser and processed by godoc—but it is not compiled directly by gc.
Instead, a separate tool, cgo, processes it to produce three output

        queryFieldConfig.setSearchFields(searchFields);
    }

    /**
     * Test isSearchField() with Set-based lookup.
     */
    @Test
    public void test_isSearchField_withSetBasedLookup() {
        // Test valid search fields
        assertTrue(queryCommand.isSearchField("title"));
        assertTrue(queryCommand.isSearchField("content"));
        assertTrue(queryCommand.isSearchField("url"));

      }
    }

    return result.readUtf8()
  }

  /**
   * Converts a single label from Punycode to Unicode.
   *
   * @return true if the range of [string] from [pos] to [limit] was valid and decoded successfully.
   *     Otherwise, the decode failed.
   */
  private fun decodeLabel(
    string: String,
    pos: Int,
    limit: Int,
    result: Buffer,
  ): Boolean {

    void testReadString() throws Exception {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        DataOutputStream dos = new DataOutputStream(baos);

        // Write a valid string structure
        String testString = "TEST";
        int totalChars = testString.length();
        writeLittleEndianInt(dos, totalChars); // totalChars
        writeLittleEndianInt(dos, 0); // unusedChars