*
     * @param runtime the action runtime context containing request information
     * @return ActionResponse with unauthorized error if access denied, otherwise delegates to parent
     */
    @Override
    public ActionResponse godHandPrologue(final ActionRuntime runtime) {
        if (!isAccessAllowed()) {

 * @since 16.0
 */
@Beta
public final class HashingInputStream extends FilterInputStream {
  private final Hasher hasher;

  /**
   * Creates an input stream that hashes using the given {@link HashFunction} and delegates all data
   * read from it to the underlying {@link InputStream}.
   *
   * <p>The {@link InputStream} should not be read from before or after the hand-off.
   */

      assertWithMessage(
              "To help optimizers, any class that inherits a package-private writeReplace() method"
                  + " should override that method.\n"
                  + "(An override that delegates to the supermethod is fine.)\n"
                  + "%s has no such override despite inheriting writeReplace() from %s",
              clazz.getName(), supersWithPackagePrivateWriteReplace.get().getName())
          .fail();

    }

    @Test
    @DisplayName("accept: propagates SmbException thrown by dependency")
    void accept_propagatesSmbException() throws Exception {
        // Arrange: filter delegates to isDirectory which may throw SmbException
        SmbFileFilter filter = f -> f.isDirectory();
        SmbException boom = new SmbException("io error");
        when(smbFile.isDirectory()).thenThrow(boom);

 * to the wrapped factory instance.
 *
 * This class implements the decorator pattern to extend CrawlerClientFactory functionality while
 * maintaining the same interface.
 *
 */
public class CrawlerClientFactoryWrapper extends CrawlerClientFactory {
    /**
     * The underlying CrawlerClientFactory instance to which operations are delegated.
     */

   *
   * <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) {
    return future instanceof FluentFuture

     *
     * @param delegate
     *            context to delegate non-override methods to
     *
     */
    public CIFSContextWrapper(final CIFSContext delegate) {
        this.delegate = delegate;
    }

    /**
     * {@inheritDoc}
     *
     * @throws CIFSException if the URL is malformed or there is an error creating the SMB resource
     *
     * @see jcifs.CIFSContext#get(java.lang.String)
     */
    @Override

 * an expressive source hint for the model problem. Instead, the source hint is configured by the model builder before
 * it delegates to other components that potentially encounter problems. Then, the problem reporter can focus on
 * providing a simple error message, leaving the donkey work of creating a nice model problem to this component.
 *

    void calculateMIC_nullData() {
        assertThrows(NullPointerException.class, () -> ctx.calculateMIC(null));
    }

    @Test
    @DisplayName("verifyMIC delegates to GSS and succeeds")
    void verifyMIC_success() throws Exception {
        byte[] data = new byte[] { 1, 2 };
        byte[] mic = new byte[] { 3 };
        // No exception means success

 *
 * This class serves as the central coordinator for SSO authentication in Fess.
 * It manages registered SSO authenticators, determines when SSO is available,
 * and delegates authentication operations to the appropriate SSO provider based
 * on the current configuration.
 */
public class SsoManager {
    /** Logger for this class. */