};
    }

    @Test
    void testRetainPayload() {
        // Initially, retainPayload should be false
        assertFalse(message.isRetainPayload(), "isRetainPayload should be false initially");

        // Call retainPayload and check if it becomes true
        message.retainPayload();
        assertTrue(message.isRetainPayload(), "isRetainPayload should be true after calling retainPayload");
    }

    @Test

    assertThat(e).hasCauseThat().isEqualTo(exception);
  }

  public static <T> Callable<T> callableThrowing(Exception exception) {
    return new Callable<T>() {
      @Override
      public T call() throws Exception {
        throw exception;
      }
    };
  }

  private static Runnable runnableThrowing(RuntimeException e) {
    return new Runnable() {
      @Override
      public void run() {

    // Verify that the listener executed in a reasonable amount of time.
    Assert.assertTrue(countDownLatch.await(1L, SECONDS));

    try {
      future.get();
      Assert.fail("This call was supposed to throw an ExecutionException");
    } catch (ExecutionException expected) {
      Assert.assertSame(expectedCause, expected.getCause());
    }
  }

  public void assertTimeout() throws Exception {

import jcifs.Configuration;
import jcifs.internal.SMBProtocolDecodingException;

/**
 * Response for SMB1 TRANS_CALL_NAMED_PIPE transaction.
 *
 * This response contains the data returned from the named pipe
 * after a call transaction has been processed by the server.
 */
public class TransCallNamedPipeResponse extends SmbComTransactionResponse {

    private final byte[] outputBuffer;

    /**

 * that are important in the context of using jCIFS. They are:
 *
 * <ul>
 * <li> <code>CallNamedPipe</code> A message-type pipe call that opens,
 *      writes to, reads from, and closes the pipe in a single operation.
 * <li> <code>TransactNamedPipe</code> A message-type pipe call that
 *      writes to and reads from an existing pipe descriptor in one operation.
 * <li> <code>CreateFile</code>, <code>ReadFile</code>,

from flask import Flask, request, abort, make_response
import requests

app = Flask(__name__)
@app.route('/', methods=['POST'])
def get_webhook():
	if request.method == 'POST':
		# obtain the request event from the 'POST' call
		event = request.json

		object_context = event["getObjectContext"]

		# Get the presigned URL to fetch the requested
		# original object from MinIO
		s3_url = object_context["inputS3Url"]

            fail("Constructor with Context parameter should exist");
        }
    }

    public void test_methodsExist() {
        // Verify that processWebInfLib method is overridden (it's protected so we can't call it directly)
        try {
            final java.lang.reflect.Method method = FessWebResourceRoot.class.getDeclaredMethod("processWebInfLib");
            assertNotNull("processWebInfLib method should exist", method);

    public void test_closeMethodExists() {
        // Test that close method is available (inherited from parent)
        try {
            // Just verify the method exists, don't actually call it
            crawlerEngineClient.getClass().getMethod("close");
            assertTrue(true);
        } catch (NoSuchMethodException e) {
            fail("close method should exist");
        }
    }

import okhttp3.internal.toHostHeader
import okio.GzipSource
import okio.buffer

/**
 * Bridges from application code to network code. First it builds a network request from a user
 * request. Then it proceeds to call the network. Finally it builds a user response from the network
 * response.
 */
class BridgeInterceptor(
  private val cookieJar: CookieJar,
) : Interceptor {
  @Throws(IOException::class)

You will see the automatic API docs for the sub-application, including only its own _path operations_, all under the correct sub-path prefix `/subapi`:

<img src="/img/tutorial/sub-applications/image02.png">

If you try interacting with any of the two user interfaces, they will work correctly, because the browser will be able to talk to each specific app or sub-app.

### Technical Details: `root_path` { #technical-details-root-path }