// OkHttp does not reject invalid Punycode.
      "xn--a",
      "xn--a.ß",
      "xn--a.xn--zca",
      "xn--a-yoc",
      // OkHttp doesn't reject U+FFFD encoded in Punycode.
      "xn--zn7c.com",
      // OkHttp doesn't reject a U+200D. https://www.rfc-editor.org/rfc/rfc5892.html#appendix-A.2
      "xn--1ug.example",

        @DisplayName("should reject unsupported model versions")
        void shouldRejectUnsupportedModelVersions(String version) {
            assertFalse(ModelVersionUtils.isValidModelVersion(version));
        }

        @ParameterizedTest
        @MethodSource("provideInvalidVersions")
        @DisplayName("should reject invalid version formats")

        assertTrue(filter.accept(mockDir, "document.txt"), "Should accept .txt files in the correct path");
        assertFalse(filter.accept(mockDir, "image.png"), "Should reject non-.txt files");
        assertFalse(filter.accept(mockDir, null), "Should reject null names");

        // Verify getPath was called three times (once for each accept call)
        verify(mockDir, times(3)).getPath();
        verifyNoMoreInteractions(mockDir);

        return new Promise((resolve, reject) => {
            if (img.complete && img.naturalHeight !== 0) {
                resolve();
            } else {
                img.addEventListener('load', () => {
                    if (img.naturalHeight !== 0) {
                        resolve();
                    } else {
                        reject();
                    }
                });

package okhttp3

/**
 * Provides **policy** and **persistence** for HTTP cookies.
 *
 * As policy, implementations of this interface are responsible for selecting which cookies to
 * accept and which to reject. A reasonable policy is to reject all cookies, though that may
 * interfere with session-based authentication schemes that require cookies.
 *
 * As persistence, implementations of this interface must also provide storage of cookies. Simple

        Thread th = new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException ignore) {}
            deferred.reject(new Exception());
        });
        th.start();

        final CountDownLatch latch = new CountDownLatch(1);
        deferred.promise().error(error -> latch.countDown());

 *   The resolve and reject methods decrement the CountDownLatch, allowing the getResponse method
 *   to return the result of the computation.
 * </p>
 *
 * @param <RESPONSE> The type of the response.
 */
public class Deferred<RESPONSE extends Response> {
    /**
     * Constructs a new Deferred object.
     */
    public Deferred() {
        // nothing
    }

Your API now has the power to control its own <abbr title="This is a joke, just in case. It has nothing to do with cookie consents, but it's funny that even the API can now reject the poor cookies. Have a cookie. 🍪">cookie consent</abbr>. 🤪🍪

You can use Pydantic's model configuration to `forbid` any `extra` fields:

{* ../../docs_src/cookie_param_models/tutorial002_an_py310.py hl[10] *}

        assertTrue(key.isZero());
        assertArrayEquals(zeroBytes, key.getKey());
    }

    @Test
    @DisplayName("Should reject null key")
    void testNullKey() {
        assertThrows(IllegalArgumentException.class, () -> new Smb2LeaseKey(null));
    }

    @Test
    @DisplayName("Should reject wrong size key")
    void testWrongSizeKey() {
        assertThrows(IllegalArgumentException.class, () -> new Smb2LeaseKey(new byte[15]));

        SmbFileFilter filter = f -> f.length() > 0;

        // negative size -> reject
        when(smbFile.length()).thenReturn(-1L);
        assertFalse(filter.accept(smbFile), "Negative size should be rejected");
        verify(smbFile, times(1)).length();

        // zero size -> reject
        reset(smbFile);
        when(smbFile.length()).thenReturn(0L);