goAction = new TestableGoAction();
    }

    @Override
    protected void tearDown(TestInfo testInfo) throws Exception {
        ComponentUtil.setFessConfig(null);
        super.tearDown(testInfo);
    }

    // Test class to expose protected method for testing
    private static class TestableGoAction extends GoAction {
        @Override

 * See [RFC 1928](https://www.ietf.org/rfc/rfc1928.txt).
 */
class SocksProxy {
  private val executor = Executors.newCachedThreadPool(threadFactory("SocksProxy"))
  private var serverSocket: ServerSocket? = null
  private val connectionCount = AtomicInteger()
  private val openSockets: MutableSet<Socket> = ConcurrentHashMap.newKeySet()

  fun play() {
    serverSocket = ServerSocket(0)
    executor.execute {

        .build()
    applyConnectionSpec(connectionSpec, socket, false)
    assertArrayEquals(arrayOf("TLSv1.1", "TLSv1.2"), socket.enabledProtocols)
  }

  internal class FakeSslSocket : DelegatingSSLSocket(null) {
    private lateinit var enabledProtocols: Array<String>
    private lateinit var supportedCipherSuites: Array<String>
    private lateinit var enabledCipherSuites: Array<String>

    }
  }

  public void testGetResource_contextClassLoaderNull() {
    ClassLoader oldContextLoader = Thread.currentThread().getContextClassLoader();
    try {
      Thread.currentThread().setContextClassLoader(null);
      assertThat(Resources.getResource("com/google/common/io/testdata/i18n.txt")).isNotNull();
      assertThrows(IllegalArgumentException.class, () -> Resources.getResource("no such resource"));
    } finally {

```JSON
{
  "detail": [
    {
      "type": "missing",
      "loc": [
        "query",
        "needy"
      ],
      "msg": "Field required",
      "input": null
    }
  ]
}
```

Comme `needy` est un paramètre requis, vous devez le définir dans l'URL :

```
http://127.0.0.1:8000/items/foo-item?needy=sooooneedy
```

... cela fonctionnerait :

   *
   * @throws NumberFormatException if the string does not contain a valid unsigned {@code int} value
   * @throws NullPointerException if {@code s} is null (in contrast to {@link
   *     Integer#parseInt(String)})
   */
  @CanIgnoreReturnValue
  public static int parseUnsignedInt(String s) {
    return parseUnsignedInt(s, 10);
  }

  /**

      notifyFailed(new IllegalStateException("stop failure"));
    }
  }

  public void testServiceStartupTimes() {
    if (isWindows() && isJava8()) {
      // Flaky there: https://github.com/google/guava/pull/6731#issuecomment-1736298607
      return;
    }
    Service a = new NoOpDelayedService(150);
    Service b = new NoOpDelayedService(353);
    ServiceManager serviceManager = new ServiceManager(asList(a, b));

			stmt.DB.Dialector.BindVarTo(writer, stmt, v)
		case []interface{}:
			if len(v) > 0 {
				writer.WriteByte('(')
				stmt.AddVar(writer, v...)
				writer.WriteByte(')')
			} else {
				writer.WriteString("(NULL)")
			}
		case interface{ getInstance() *DB }:
			cv := v.getInstance()

			subdb := cv.Session(&Session{Logger: logger.Discard, DryRun: true}).getInstance()
			if cv.Statement.SQL.Len() > 0 {
				var (

    var $boxElement,
      $textArea,
      inputText = "",
      isFocusList = false,
      listNum = 0,
      listSelNum = 0,
      isMouseHover = false,
      started = false,
      debounceTimer = null,

      settingMinTerm = 1,
      settingAjaxInfo,
      settingAdjustWidthVal,
      $settingSearchForm,
      listSelectedCssInfo,
      listDeselectedCssInfo,
      boxCssInfo,

This library makes it easy to test that your app Does The Right Thing when it
makes HTTP and HTTPS calls. It lets you specify which responses to return and
then verify that requests were made as expected.

Because it exercises your full HTTP stack, you can be confident that you're
testing everything. You can even copy & paste HTTP responses from your real web
server to create representative test cases. Or test that your code survives in