* <li>If the class loader that loaded the target class can be obtained, that class loader</li>
     * <li>If the class loader that loaded this class can be obtained, that class loader</li>
     * <li>If the system class loader can be obtained, that class loader</li>
     * </ol>
     * <p>
     * However, if both the class loader that loaded the target class and the class loader that loaded this class can be obtained,

		t.Fatalf("length differs from expected")
	}

	v, ok = lc.Peek("key1")
	if v != "" {
		t.Fatalf("should be empty")
	}
	if ok {
		t.Fatalf("should be false")
	}

	v, ok = lc.Get("key1")
	if v != "" {
		t.Fatalf("should be empty")
	}
	if ok {
		t.Fatalf("should be false")
	}
}

func TestLRURemoveOldest(t *testing.T) {
	lc := lru.NewLRU[string, string](2, nil, 0)

      }
      this.notBefore = notBefore
      this.notAfter = notAfter
    }

    /**
     * Sets the certificate to be valid immediately and until the specified duration has elapsed.
     * The precision of this field is seconds; further precision will be truncated.
     */
    fun duration(
      duration: Long,
      unit: TimeUnit,
    ) = apply {
      val now = System.currentTimeMillis()

// a very high probability.
//
// Therefore, an S3 implementation may encrypt an ETag before storing
// it. In this case, the stored ETag may not be a well-formed S3 ETag.
// For example, it can be larger due to a checksum added by authenticated
// encryption schemes. Such an ETag must be decrypted before sent to an
// S3 client.
//
// # S3 Clients
//
// There are many different S3 client implementations. Most of them

    /**
     * Indicates whether plugin executions and configurations should be processed. If enabled, lifecycle-induced plugin
     * executions will be injected into the model and common plugin configuration will be propagated to individual
     * executions.
     *
     * @return {@code true} if plugins should be processed, {@code false} otherwise.
     */
    boolean isProcessPlugins();

    /**

        SmbShareInfo share2 = (SmbShareInfo) response.results[1];
        assertEquals("IPC$", share2.getName().trim(), "Share 2 name should be correct.");
        assertEquals(3, share2.type, "Share 2 raw type should be 3.");
        assertEquals("Inter-Process Communication", share2.remark.trim(), "Share 2 remark should be correct.");
    }

    /**
     * Tests the toString method for a meaningful representation.
     */

        // onclick attribute should be removed
        assertFalse(result.contains("onclick"));
    }

    @Test
    public void test_render_xss_javascriptProtocol() {
        String malicious = "[Click me](javascript:alert('XSS'))";
        String result = markdownRenderer.render(malicious);
        // javascript: protocol should be blocked
        assertFalse(result.contains("javascript:"));
    }

   *
   * @param nameFormat a {@link String#format(String, Object...)}-compatible format String, to which
   *     a unique integer (0, 1, etc.) will be supplied as the single parameter. This integer will
   *     be unique to the built instance of the ThreadFactory and will be assigned sequentially. For
   *     example, {@code "rpc-pool-%d"} will generate thread names like {@code "rpc-pool-0"}, {@code

import pytest
from fastapi import FastAPI, Query
from pydantic import BaseModel


def test_invalid_sequence():
    with pytest.raises(
        AssertionError,
        match="Query parameter 'q' must be one of the supported types",
    ):
        app = FastAPI()

        class Item(BaseModel):
            title: str

        @app.get("/items/")
        def read_items(q: list[Item] = Query(default=None)):

        assertNotNull(annotation, "Annotation should be present on field");
        assertEquals("protocolType should be WEB", ProtocolType.WEB, annotation.protocolType());
        assertEquals("message should be default", "{org.lastaflute.validator.constraints.UriType.message}", annotation.message());
        assertEquals("groups should be empty", 0, annotation.groups().length);
        assertEquals("payload should be empty", 0, annotation.payload().length);
    }