String username = "nonexistentuser";

        try {
            throw new FessUserNotFoundException(username);
        } catch (FessUserNotFoundException e) {
            assertEquals("User is not found: nonexistentuser", e.getMessage());
            assertNull(e.getCause());
        } catch (Exception e) {
            fail("Should have caught FessUserNotFoundException");
        }
    }

                throw new CommandExecutionException("The command execution is timeout: " + String.join(" ", commands));
            }
            return exitValue;
        } catch (final CrawlerSystemException e) {
            throw e;
        } catch (final InterruptedException e) {
            if (mt != null && mt.isTeminated()) {

    void testEncode(byte[] input, String expected) {
        // Arrange & Act
        String actual = Base64.encode(input);
        // Assert
        assertEquals(expected, actual, "Base64.encode should match expected string");
    }

    /**
     * Data provider for Base64 strings and expected decoded byte arrays.
     */
    static Stream<Arguments> decodeProvider() {

            int bytesToRead = Math.min(length, buffer.remaining());

            // Simulate RDMA read operation
            log.debug("DiSNI RDMA read request: {} bytes from remote address 0x{}", bytesToRead, Long.toHexString(remoteAddress));

            return bytesToRead;

        } catch (Exception e) {
            state = RdmaConnectionState.ERROR;

 * Are always invoked once, even if the HTTP response is served from the cache.
 * Observe the application's original intent. Unconcerned with OkHttp-injected headers like `If-None-Match`.
 * Permitted to short-circuit and not call `Chain.proceed()`.
 * Permitted to retry and make multiple calls to `Chain.proceed()`.
 * Can adjust Call timeouts using withConnectTimeout, withReadTimeout, withWriteTimeout.

    bestGetCheckedTypeValidator().validateClass(exceptionClass);
    try {
      return future.get(timeout, unit);
    } catch (InterruptedException e) {
      currentThread().interrupt();
      throw newWithCause(exceptionClass, e);
    } catch (TimeoutException e) {
      throw newWithCause(exceptionClass, e);
    } catch (ExecutionException e) {
      wrapAndThrowExceptionOrError(e.getCause(), exceptionClass);
      throw new AssertionError();

      val byteRead = inputStream.read()
      // OpenJDK behavior: end of stream.
      assertThat(byteRead).isEqualTo(-1)
    } catch (e: ProtocolException) {
      // On Android, HttpURLConnection is implemented by OkHttp v2. OkHttp
      // treats an incomplete response body as a ProtocolException.
    } catch (ioe: IOException) {
      // Change in https://bugs.openjdk.org/browse/JDK-8335135

                } catch (final Exception e1) {
                    logger.warn("Failed to create bucket: {}", fessConfig.getStorageBucket(), e1);
                }
            } else if (logger.isDebugEnabled()) {
                logger.debug("Failed to access {}", fessConfig.getStorageEndpoint(), e);
            }
        } catch (final Exception e) {
            if (logger.isDebugEnabled()) {

        for (final String value : list) {
            buf.append(value).append("\n");
        }
        return buf.toString();
    }

    /**
     * Checks if the buffer contains a line that matches the specified value (after trimming).
     *
     * @param value the value to search for in the buffered lines
     * @return true if a matching line is found, false otherwise
     */

    IOException exception = new IOException();

    try {
      try {
        throw exception;
      } catch (Throwable e) {
        throw closer.rethrow(e);
      } finally {
        closer.close();
      }
    } catch (Throwable expected) {
      assertSame(exception, expected);
    }

    assertTrue(c1.isClosed());
    assertTrue(c2.isClosed());