*  Fix: Don't throw when converting an `HttpUrl` to a `java.net.URI`.
    Previously URLs with special characters like `|` and `[` would break when
    subjected to URI’s overly-strict validation.
 *  Fix: Don't re-encode `+` as `%20` in encoded URL query strings. OkHttp
    prefers `%20` when doing its own encoding, but will retain `+` when that is
    provided.

    know that it is application specific, it's not part of the specification.


    grant_type: the OAuth2 spec says it is required and MUST be the fixed string "password".
        This dependency is strict about it. If you want to be permissive, use instead the
        OAuth2PasswordRequestForm dependency class.
    username: username string. The OAuth2 spec requires the exact field name "username".

                alreadyEncoded = true,
                strict = true,
                plusIsSpace = true,
              )
          }
        }

        encodedFragment =
          encodedFragment?.canonicalize(
            encodeSet = FRAGMENT_ENCODE_SET_URI,
            alreadyEncoded = true,
            strict = true,
            unicodeAllowed = true,
          )
      }

        this.revision = revision;
        this.qualifier = qualifier == null ? null : Qualifier.of(qualifier);
    }

    /**
     * Parses the supplied string into an object.
     * @param s a version string in strict semver
     * @return a new instance
     */
    public static QualifiedVersion of(final String s) {
        Objects.requireNonNull(s);
        Matcher matcher = pattern.matcher(s);

Pydantic propose un [Guide de migration](https://docs.pydantic.dev/latest/migration/) officiel de la v1 à la v2.

Il inclut aussi ce qui a changé, comment les validations sont désormais plus correctes et strictes, les pièges possibles, etc.

Vous pouvez le lire pour mieux comprendre ce qui a changé.

## Tests { #tests }

            )
        return block_a["content"].copy()  # We don't handle mermaid code blocks for now

    code_block: list[str] = []
    for line_a, line_b in zip(block_a["content"], block_b["content"], strict=False):
        line_a_comment: str | None = None
        line_b_comment: str | None = None

        # Handle comments based on language
        if block_language in {
            "python",
            "py",

            if (failureRate > 0.5 && avgResponseTime < 5000) {
                newThreshold = Math.min(currentThreshold + 2, 15);
            }
            // If failure rate is moderate but response time is very high, be stricter
            else if (failureRate > 0.2 && avgResponseTime > 10000) {
                newThreshold = Math.max(currentThreshold - 1, 2);
            }
            // If system is performing well, be more lenient

    public static final String ORIGIN = "origin";
    public static final String STRICT_ORIGIN = "strict-origin";
    public static final String ORIGIN_WHEN_CROSS_ORIGIN = "origin-when-cross-origin";
    public static final String STRICT_ORIGIN_WHEN_CROSS_ORIGIN = "strict-origin-when-cross-origin";
    public static final String UNSAFE_URL = "unsafe-url";
  }

  /**

same. We’ve chosen Kotlin because it gives us powerful new capabilities while integrating closely
with Java.

We spent a lot of time and energy on retaining strict compatibility with OkHttp 3.x. We’re even
keeping the package name the same: `okhttp3`!

There are three kinds of compatibility we’re tracking:

            }
        }
    }

    @BeforeEach
    void setup() throws MalformedURLException, CIFSException {
        // Common happy-path defaults
        // Use lenient() to avoid strict stubbing issues with Mockito
        lenient().when(tree.acquire()).thenReturn(tree);
        lenient().when(tree.getConfig()).thenReturn(config);
        lenient().when(config.getListCount()).thenReturn(10);