return closeable;
  }

  /**
   * Stores the given throwable and rethrows it. It will be rethrown as is if it is an {@code
   * IOException}, {@code RuntimeException} or {@code Error}. Otherwise, it will be rethrown wrapped
   * in a {@code RuntimeException}. <b>Note:</b> Be sure to declare all of the checked exception
   * types your try block can throw when calling an overload of this method so as to avoid losing
   * the original exception type.

     * Instance a <code>SpnegoContext</code> object by wrapping a {@link SSPContext}
     * with the same mechanism this {@link SSPContext} used.
     *
     * @param source
     *            the {@link SSPContext} to be wrapped
     */
    SpnegoContext(final Configuration config, final SSPContext source) {
        this(config, source, source.getSupportedMechs());
    }

    /**

  + Lowercase verb after the colon
  + No trailing period
  + Keep the title as short as possible. ideally under 76 characters or shorter
+ No Markdown
+ The first PR comment (this one) is wrapped at 76 characters, unless it's
  really needed (ASCII art, table, or long link)
+ If there is a corresponding issue, add either `Fixes #1234` or `Updates #1234`
  (the latter if this is not a complete fix) to this comment

 */
public interface DcerpcSecurityProvider {
    /**
     * Wraps outgoing DCERPC message data for security protection
     * @param outgoing the buffer containing data to be wrapped
     * @throws DcerpcException if the wrapping operation fails
     */
    void wrap(NdrBuffer outgoing) throws DcerpcException;

    /**
     * Unwraps incoming DCERPC message data after security processing

    val buffer = Buffer()
    val writer = DerWriter(buffer)
    toDer(writer, value)
    return buffer.readByteString()
  }

  /**
   * Returns an adapter that expects this value wrapped by another value. Typically this occurs
   * when a value has both a context or application tag and a universal tag.
   *
   * Use this for EXPLICIT tag types:
   *
   * ```
   * [5] EXPLICIT UTF8String
   * ```

        ntlmConnection = new NtlmHttpURLConnection(mockConnection, mockCifsContext);
    }

    /**
     * Test that the constructor copies settings from the wrapped connection.
     * @throws ProtocolException
     */
    @Test
    void testConstructorCopiesSettings() throws ProtocolException {
        // Arrange
        when(mockConnection.getRequestMethod()).thenReturn("GET");

 * {@code equals} would break symmetry, as the forwarding object might consider itself equal to the
 * object being tested, but the reverse could not be true. This behavior is consistent with the
 * JDK's collection wrappers, such as {@link java.util.Collections#unmodifiableCollection}. Use an
 * interface-specific subclass of {@code ForwardingObject}, such as {@link ForwardingList}, to
 * preserve equality behavior, or override {@code equals} directly.

import org.eclipse.aether.transfer.TransferEvent;
import org.eclipse.aether.transfer.TransferResource;

/**
 * Console download progress meter.
 * <p>
 * This listener is not thread-safe and should be wrapped in the {@link SimplexTransferListener} in a multi-threaded scenario.
 */
public class ConsoleMavenTransferListener extends AbstractMavenTransferListener {

2) In the French docs, guillemets are written without extra spaces: use «texte», not « texte ».

3) Do not convert quotes inside code blocks, inline code, paths, URLs, or anything wrapped in backticks.

Examples:

    Source (English):

        «««
        "Hello world"
        “Hello Universe”
        "He said: 'Hello'"
        "The module is `__main__`"
        »»»

  /**
   * Converts the given {@code ListenableFuture} to an equivalent {@code FluentFuture}.
   *
   * <p>If the given {@code ListenableFuture} is already a {@code FluentFuture}, it is returned
   * directly. If not, it is wrapped in a {@code FluentFuture} that delegates all calls to the
   * original {@code ListenableFuture}.
   */
  public static <V extends @Nullable Object> FluentFuture<V> from(ListenableFuture<V> future) {