* Searches for classes handled by this instance and calls the handler for each class.
     * <p>
     * If a root package is specified at instance construction, only classes under the root package are targeted.
     * </p>
     *
     * @param handler the handler to process classes
     */
    void forEach(ClassHandler handler);

    /**
     * Searches for resources handled by this instance and calls the handler for each resource.

        // Mock Postbox - no need to mock, the framework will handle it

        // Register components
        ComponentUtil.register(searchEngineClient, "searchEngineClient");
        ComponentUtil.register(systemHelper, "systemHelper");
        ComponentUtil.setFessConfig(fessConfig);
        ComponentUtil.register(notificationHelper, "notificationHelper");
        // Postbox is handled by the framework

        // Execute

    }

    @Test
    @DisplayName("Constructor with null request should work")
    void testConstructorWithNullRequest() {
        // Test that null request is handled properly
        SmbNegotiation negotiationWithNullRequest = new SmbNegotiation(null, mockResponse, testRequestBuffer, testResponseBuffer);

        assertNull(negotiationWithNullRequest.getRequest());

        String emptyString = "";
        AvTargetName avTargetNameFromString = new AvTargetName(emptyString);
        assertEquals(emptyString, avTargetNameFromString.getTargetName(),
                "Empty string should be handled correctly from string constructor");
        assertArrayEquals(emptyString.getBytes(StandardCharsets.UTF_16LE), avTargetNameFromString.getRaw(),
                "Raw bytes for empty string should be empty");

    }

    /**
     * Checks whether the asynchronous interim response has been handled.
     *
     * @return whether the interim response has been handled
     */
    public boolean isAsyncHandled() {
        return this.asyncHandled;
    }

    /**
     * Sets whether the asynchronous interim response has been handled.
     *
     * @param asyncHandled
     *            the asyncHandled to set
     */

    addEdge(N1, N2, E12);
    assertThat(network.inEdges(N2)).containsExactly(E12);
    // Edge direction handled correctly
    assertThat(network.inEdges(N1)).isEmpty();
  }

  @Test
  public void outEdges_oneEdge() {
    addEdge(N1, N2, E12);
    assertThat(network.outEdges(N1)).containsExactly(E12);
    // Edge direction handled correctly
    assertThat(network.outEdges(N2)).isEmpty();
  }

  @Test

    addEdge(N1, N2, E12);
    assertThat(network.inEdges(N2)).containsExactly(E12);
    // Edge direction handled correctly
    assertThat(network.inEdges(N1)).isEmpty();
  }

  @Test
  public void outEdges_oneEdge() {
    addEdge(N1, N2, E12);
    assertThat(network.outEdges(N1)).containsExactly(E12);
    // Edge direction handled correctly
    assertThat(network.outEdges(N2)).isEmpty();
  }

  @Test

In most cases, the same tool that is used to **run the program on startup** is also used to handle automatic **restarts**.

For example, this could be handled by:

* Docker
* Kubernetes
* Docker Compose
* Docker in Swarm Mode
* Systemd
* Supervisor
* Handled internally by a cloud provider as part of their services
* Others...

And then mount that under a path.

{* ../../docs_src/wsgi/tutorial001.py hl[2:3,3] *}

## Check it { #check-it }

Now, every request under the path `/v1/` will be handled by the Flask application.

And the rest will be handled by **FastAPI**.

If you run it and go to <a href="http://localhost:8000/v1/" class="external-link" target="_blank">http://localhost:8000/v1/</a> you will see the response from Flask:

```txt

    putEdge(N1, N2);
    assertThat(graph.predecessors(N2)).containsExactly(N1);
    // Edge direction handled correctly
    assertThat(graph.predecessors(N1)).isEmpty();
  }

  @Test
  public void successors_oneEdge() {
    putEdge(N1, N2);
    assertThat(graph.successors(N1)).containsExactly(N2);
    // Edge direction handled correctly
    assertThat(graph.successors(N2)).isEmpty();
  }

  @Test