try {
                    customCb.executeWithCircuitBreaker(() -> {
                        throw new RuntimeException("non-critical error");
                    }, isFailure);
                    fail("Should have thrown exception");
                } catch (CIFSException e) {
                    // Expected - exception is thrown but not counted as failure
                }
            }

    throwIf(closed);
    throwIf(WRITE_THROWS);
    super.write(b, off, len);
  }

  @Override
  public void write(int b) throws IOException {
    throwIf(closed);
    throwIf(WRITE_THROWS);
    super.write(b);
  }

  @Override
  public void close() throws IOException {
    closed = true;
    super.close();
    throwIf(CLOSE_THROWS);
  }

   * @throws UncheckedExecutionException if an unchecked exception was thrown while loading the
   *     value
   * @throws ExecutionError if an error was thrown while loading the value
   */
  @CanIgnoreReturnValue // TODO(b/27479612): consider removing this?
  V get(K key) throws ExecutionException;

  /**
   * Returns the value associated with {@code key} in this cache, first loading that value if

      this.closeable = closeable;
      this.thrown = thrown;
      this.suppressed = suppressed;
    }

    @Override
    public boolean equals(@Nullable Object obj) {
      if (obj instanceof Suppression) {
        Suppression other = (Suppression) obj;
        return closeable.equals(other.closeable)
            && thrown.equals(other.thrown)

   * @throws UncheckedExecutionException if an unchecked exception was thrown while loading the
   *     value
   * @throws ExecutionError if an error was thrown while loading the value
   */
  @CanIgnoreReturnValue // TODO(b/27479612): consider removing this?
  V get(K key) throws ExecutionException;

  /**
   * Returns the value associated with {@code key} in this cache, first loading that value if

  public void testFlush_flushableWithEatenException() throws IOException {
    // make sure that no exception is thrown if 'swallowException' is true
    // when the mock does throw an exception on flush.
    setupFlushable(true);
    doFlush(mockFlushable, true, false);
  }

  public void testFlush_flushableWithThrownException() throws IOException {
    // make sure that the exception is thrown if 'swallowException' is false

    }

    /**
     * Tests the {@link PacUnicodeString#check(String)} method with a valid string.
     *
     * @throws PACDecodingException if the check fails, which is not expected in this test.
     */
    @Test
    void testCheck_withValidString() throws PACDecodingException {
        // Corresponds to a string of length 5 (10 bytes for UTF-16)

   *     does nothing
   * @param swallowIOException if true, don't propagate IO exceptions thrown by the {@code close}
   *     methods
   * @throws IOException if {@code swallowIOException} is false and {@code close} throws an {@code
   *     IOException}.
   */
  /*
   * The proper capitalization would be "swallowIoException." However:
   *

        assertTrue(thrown.getCause() instanceof MalformedURLException);
    }

    @Test
    void testGetPipe() throws CIFSException, MalformedURLException {
        // Test getPipe(String url, int pipeType) method
        String url = "smb://server/IPC$/pipeName"; // Corrected URL for named pipe
        int pipeType = 1;
        SmbPipeResource mockSmbPipeResource = mock(SmbNamedPipe.class);

        // Now, mock the behavior for MsrpcLsarClose to throw IOException
        doThrow(new IOException("Close network error")).when(mockDcerpcHandle).sendrecv(any(MsrpcLsarClose.class));

        // Act & Assert
        IOException thrown = assertThrows(IOException.class, () -> {
            handle.close();
        });

        assertEquals("Close network error", thrown.getMessage());