pf := &fakePortForwarder{
			expected: expectedFromClient,
			received: make(map[int32]string),
			send:     serverSends,
		}
		portforward.ServePortForward(w, req, pf, "pod", "uid", nil, 0, 10*time.Second, portforward.SupportedProtocols)

		for port, expected := range expectedFromClient {
			actual, ok := pf.received[port]
			if !ok {
				t.Errorf("%s: server didn't receive any data for port %d", testName, port)
				continue
			}

		}
		// no revision should receive all objects
		expectedNoRevision = append(expectedNoRevision, TranslateObject(obj, gvk.ServiceEntry, ""))
	}

	storeCases := map[string][]config.Config{
		"":       expectedNoRevision, // No revision specified, should receive all events.
		"canary": expectedCanary,     // Only SEs from the canary revision should be received.

    def events = ProgressEvents.create()

    void customizeLauncher(BuildLauncher launcher) {
        launcher.addProgressListener(events)
    }

    def "client can receive appropriate logging and progress events for subsequent builds"() {
        when:
        def javaSrcFile = sourceDir.file("Thing.java") << 'public class Thing {}'

        then:
        runBuild {
            succeeds()

            - query_params
            - path_params
            - cookies
            - client
            - state
            - url_for
            - client_state
            - application_state
            - receive
            - send
            - accept
            - receive_text
            - receive_bytes
            - receive_json
            - iter_text
            - iter_bytes
            - iter_json

## The normal **FastAPI** app

Let's first see how the normal API app would look like before adding the callback.

It will have a *path operation* that will receive an `Invoice` body, and a query parameter `callback_url` that will contain the URL for the callback.

This part is pretty normal, most of the code is probably already familiar to you:

```Python hl_lines="9-13  36-53"

    public final static String ABOUT_TO_CLOSE_STREAMS = "Daemon started. About to close the streams. Daemon details: ";
    public final static String STARTED_RELAYING_LOGS = "The client will now receive all logging from the daemon (pid: ";
    public final static String UNABLE_TO_START_DAEMON = "Unable to start the daemon process.";
    public final static String STARTED_EXECUTING_COMMAND = "Starting executing command: ";

* Processing data:
    * For example, let's say you receive a file that must go through a slow process, you can return a response of "Accepted" (HTTP 202) and process it in the background.

## Using `BackgroundTasks`

     */
    boolean haveCapabilitiy ( int cap );


    /**
     * @return the send buffer size
     */
    int getSendBufferSize ();


    /**
     * @return the receive buffer size
     */
    int getReceiveBufferSize ();


    /**
     * 
     * @return the transaction buffer size
     */
    int getTransactionBufferSize ();


    /**
     * 

	RLDICR	$0, R1, $59, R1         // Align for C code
	MOVD	R12, CTR
	MOVD	R1, R4

	// Store g on gsignal's stack, so if we receive a signal
	// during VDSO code we can find the g.
	// If we don't have a signal stack, we won't receive signal,
	// so don't bother saving g.
	// When using cgo, we already saved g on TLS, also don't save
	// g here.

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Attach this annotation to an abstract getter that should receive the input artifact for an artifact transform.
 * This is the artifact that the transform is applied to.
 *