}{
		{
			[]clause.Interface{clause.Insert{}},
			"INSERT INTO `users`", nil,
		},
		{
			[]clause.Interface{clause.Insert{Modifier: "LOW_PRIORITY"}},
			"INSERT LOW_PRIORITY INTO `users`", nil,
		},
		{
			[]clause.Interface{clause.Insert{Table: clause.Table{Name: "products"}, Modifier: "LOW_PRIORITY"}},
			"INSERT LOW_PRIORITY INTO `products`", nil,
		},
	}

	for idx, result := range results {

            // Check that it's static
            assertTrue("Method should be static", java.lang.reflect.Modifier.isStatic(method.getModifiers()));

            // Check that it's public
            assertTrue("Method should be public", java.lang.reflect.Modifier.isPublic(method.getModifiers()));

            // Check parameter count

import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verifyNoInteractions;

import java.lang.reflect.Modifier;
import java.util.stream.Stream;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.junit.jupiter.params.ParameterizedTest;

 */

package com.google.common.collect;

import static com.google.common.truth.Truth.assertWithMessage;
import static java.lang.reflect.Modifier.PRIVATE;
import static java.lang.reflect.Modifier.PROTECTED;
import static java.lang.reflect.Modifier.PUBLIC;
import static java.util.Arrays.asList;

import com.google.common.base.Optional;
import com.google.common.reflect.ClassPath;

            )
        ) {
            Predicate<Class<?>> isStaticClass = clazz -> Modifier.isStatic(clazz.getModifiers());
            Predicate<Class<?>> isPublicClass = clazz -> Modifier.isPublic(clazz.getModifiers());
            Predicate<Class<?>> isAbstractClass = clazz -> Modifier.isAbstract(clazz.getModifiers());

            final Map<File, ? extends Class<?>> classes = getTestClassNames().entrySet()

		fh.Flags |= 0x800
	}

	fh.CreatorVersion = fh.CreatorVersion&0xff00 | zipVersion20 // preserve compatibility byte
	fh.ReaderVersion = zipVersion20

	// If Modified is set, this takes precedence over MS-DOS timestamp fields.
	if !fh.Modified.IsZero() {
		// Contrary to the FileHeader.SetModTime method, we intentionally
		// do not convert to UTC, because we assume the user intends to encode

    public String id;

    /**
     * The version number of the user for optimistic locking.
     * This field is required to prevent concurrent modification conflicts
     * by ensuring the user hasn't been modified by another process.
     */
    @Required
    @ValidateTypeFailure
    public Integer versionNo;

        StopwordsItem updateItem = new StopwordsItem(1, "the");
        updateItem.setNewInput("modified");

        StopwordsFile.StopwordsUpdater updater = stopwordsFile.new StopwordsUpdater(updateItem);

        StopwordsItem result = updater.write(originalItem);
        assertNotNull(result);
        assertEquals("modified", result.getInput());

        updater.close();
    }

    @Test

Vous pouvez utiliser [`bump-pydantic`](https://github.com/pydantic/bump-pydantic) de la même équipe Pydantic.

Cet outil vous aidera à modifier automatiquement la majeure partie du code à adapter.

Après cela, vous pouvez exécuter les tests et vérifier que tout fonctionne. Si c'est le cas, vous avez terminé. 😎

## Pydantic v1 dans v2 { #pydantic-v1-in-v2 }

# Étendre OpenAPI { #extending-openapi }

Il existe des cas où vous pouvez avoir besoin de modifier le schéma OpenAPI généré.

Dans cette section, vous verrez comment faire.

## Le processus normal { #the-normal-process }

Le processus normal (par défaut) est le suivant.

Une application (instance) `FastAPI` a une méthode `.openapi()` censée retourner le schéma OpenAPI.