assertThat(cache.isClosed()).isTrue()
  }

  @Test
  fun journalWriteFailsDuringEdit() {
    set("a", "a", "a")
    set("b", "b", "b")

    // We can't begin the edit if writing 'DIRTY' fails.
    filesystem.setFaultyWrite(journalFile, true)
    assertThat(cache.edit("c")).isNull()

    // Once the journal has a failure, subsequent writes aren't permitted.
    filesystem.setFaultyWrite(journalFile, false)

     * Creates a RelatedQuery entity from the provided form data.
     *
     * @param form the form containing the related query data
     * @return optional entity containing the related query data, or empty if creation fails
     */
    public static OptionalEntity<RelatedQuery> getRelatedQuery(final CreateForm form) {
        final SystemHelper systemHelper = ComponentUtil.getSystemHelper();

            // Check if the message contains the expected text
            // It could be either "Unexpected number of update indices" or "Unexpected number of search indices"
            // depending on which check fails first
            assertTrue("Exception message should mention unexpected indices: " + exceptionMessage,
                    exceptionMessage.contains("Unexpected number of update indices")

    }

    @Override
    protected Map<Integer, Character> getValueNotInPopulatedMap() {
      return ImmutableMap.of();
    }

    /**
     * The version of this test supplied by {@link MapInterfaceTest} fails for this particular map
     * implementation, because {@code map.get()} returns a view collection that changes in the
     * course of a call to {@code remove()}. Thus, the expectation doesn't hold that {@code

        // 3. after setFuture and set() are called but before the listener completes.
        if (!setFutureSetSuccess.get() || !setFutureCompletionSuccess.get()) {
          // If setFuture fails or set on the future fails then it must be because that future was
          // cancelled
          assertTrue(setFuture.isCancelled());
          assertTrue(setFuture.wasInterrupted()); // we only call cancel(true)
        }

    }

    /**
     * Resolves a hostname to an InetAddress.
     *
     * @param host the hostname to resolve
     * @return the resolved InetAddress
     * @throws FessSystemException if hostname resolution fails
     */
    protected InetAddress getInetAddressByName(final String host) {
        try {
            return InetAddress.getByName(host);
        } catch (final UnknownHostException e) {

        // Should skip zero-length message and read actual data
        assertEquals(10, sis.read());
        assertEquals(20, sis.read());

        // After all data consumed, next read fails
        assertThrows(IOException.class, () -> sis.read());
    }

    @Test
    @DisplayName("Unknown packet type is handled by continuing to next packet")
    void unknownPacketTypeHandled() throws IOException {

     *
     * @param buffer the buffer to validate
     * @param expectedSize expected minimum size
     * @param maxSize maximum allowed size
     * @throws SmbException if validation fails
     */
    public void validateBuffer(byte[] buffer, int expectedSize, int maxSize) throws SmbException {
        totalValidations.incrementAndGet();

        if (buffer == null) {

        String s = ctx.toString();
        assertEquals("KERB5[src=client,targ=service,mech=1.2.3]", s);
    }

    @Test
    @DisplayName("toString falls back when GSS access fails")
    void toString_established_throws() throws Exception {
        when(gssContext.isEstablished()).thenReturn(true);
        when(gssContext.getSrcName()).thenThrow(new GSSException(GSSException.FAILURE));

    connection.calls.add(CallReference(this, callStackTrace))
  }

  /**
   * Releases resources held with the request or response of [exchange]. This should be called when
   * the request completes normally or when it fails due to an exception, in which case [e] should
   * be non-null.
   *
   * If the exchange was canceled or timed out, this will wrap [e] in an exception that provides