To create the callback *path operation* use the same `APIRouter` you created above.

It should look just like a normal FastAPI *path operation*:

* It should probably have a declaration of the body it should receive, e.g. `body: InvoiceEvent`.
* And it could also have a declaration of the response it should return, e.g. `response_model=InvoiceEventReceived`.

       *   the case that the service is using CustomScheduler). (It needs it so that it can cancel
       *   the task and detect whether it has been cancelled.)
       *
       * - ReschedulableCallable has a reference back to its enclosing CustomScheduler. (It needs it
       *   so that it can call getNextSchedule).
       *
       * Maybe there is a way to avoid this cycle. But we think the cycle is safe enough to ignore:

share and change all versions of a program--to make sure it remains free
software for all its users.

  When we speak of free software, we are referring to freedom, not
price.  Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new

{* ../../docs_src/python_types/tutorial001.py hl[2] *}

### Edit it { #edit-it }

It's a very simple program.

But now imagine that you were writing it from scratch.

At some point you would have started the definition of the function, you had the parameters ready...

But then you have to call "that method that converts the first letter to upper case".

Was it `upper`? Was it `uppercase`? `first_uppercase`? `capitalize`?

        });

        DirFileEntryEnumIterator1 it = new DirFileEntryEnumIterator1(tree, parent, "*", null, 0);

        // Act & Assert: entries a, b, c (dot entries filtered) then end
        assertTrue(it.hasNext());
        assertEquals("a", it.next().getName());
        assertTrue(it.hasNext());
        assertEquals("b", it.next().getName());
        assertTrue(it.hasNext());
        assertEquals("c", it.next().getName());

        } else {
            val testCoverages = model.stages.flatMap { it.functionalTests }
            val foundTestCoverage =
                testCoverages.firstOrNull {
                    it.testType == TestType.PLATFORM &&
                        it.os == testCoverage.os &&
                        it.arch == testCoverage.arch &&
                        it.buildJvm == testCoverage.buildJvm
                }

var GlobalContext, cancelGlobalContext = context.WithCancel(context.Background())

// restartProcess starts a new process passing it the active fd's. It
// doesn't fork, but starts a new process using the same environment and
// arguments as when it was originally started. This allows for a newly
// deployed binary to be started. It returns the pid of the newly started
// process when successful.
func restartProcess() error {

When a **container** is started, it will run that command/program (although you can override it and make it run a different command/program).

A container is running as long as the **main process** (command or program) is running.

     * It should always return 0.
     */
    @Test
    void testWriteDataWireFormat() {
        byte[] dst = new byte[10];
        // The method should not write anything and return 0
        assertEquals(0, response.writeDataWireFormat(dst, 0), "writeDataWireFormat should return 0.");
    }

    /**
     * Test for the readSetupWireFormat method.
     * It should always return 0.
     */
    @Test

You send it a token and it returns an authenticated user.

This provider might be charging you per request, and calling it might take some extra time than if you had a fixed mock user for tests.

You probably want to test the external provider once, but not necessarily call it for every test that runs.