return props;
    }

    @Test
    void testNullSafe() throws Exception {
        Profile p = Profile.newInstance();

        assertActivation(false, p, newContext(null, null));

        p = p.withActivation(Activation.newInstance());

        assertActivation(false, p, newContext(null, null));
    }

    @Test
    void testWithNameOnlyUserProperty() throws Exception {

    @SuppressWarnings("unused") // accessed reflectively
    public void testPublic() {}

    @SuppressWarnings("unused") // accessed reflectively
    void testNotPublic() {}
  }

  // Shouldn't be mistaken as Foo's test
  static class Foo2Test {
    @SuppressWarnings("unused") // accessed reflectively
    public void testPublic() {}
  }

  private List<Class<?>> findClassesToTest(

public class FluentFutureTest extends TestCase {
  @SuppressWarnings({"deprecation", "InlineMeInliner"}) // test of a deprecated method
  public void testFromFluentFuture() {
    FluentFuture<String> f = FluentFuture.from(SettableFuture.create());
    assertThat(FluentFuture.from(f)).isSameInstanceAs(f);
  }

  public void testFromFluentFuturePassingAsNonFluent() {
    ListenableFuture<String> f = FluentFuture.from(SettableFuture.create());

    /**
     * @throws Exception
     */
    @Test
    public void testSplit() throws Exception {
        final String[] array = StringUtil.split("aaa\nbbb", "\n");
        assertEquals("1", 2, array.length);
        assertEquals("2", "aaa", array[0]);
        assertEquals("3", "bbb", array[1]);
    }

    /**
     *
     */
    @Test
    public void testSplit2() {

    Callable<@Nullable Void> cancelRunnable =
        new Callable<@Nullable Void>() {
          @Override
          public @Nullable Void call() {
            cancellationSuccess.set(currentFuture.get().cancel(true));
            awaitUnchecked(barrier);
            return null;
          }
        };
    Callable<@Nullable Void> setFutureCompleteSuccessfullyRunnable =

@NullUnmarked
public class TypeResolverTest extends TestCase {

  public void testWhere_noMapping() {
    Type t = aTypeVariable();
    assertEquals(t, new TypeResolver().resolveType(t));
  }

  public void testWhere_typeVariableMapping() {
    Type t = aTypeVariable();
    assertEquals(String.class, new TypeResolver().where(t, String.class).resolveType(t));
  }

  public <T> void testWhere_indirectMapping() {

  }

  public void testSubSet_outOfOrder() {
    ImmutableSortedSet<Integer> set = ContiguousSet.create(Range.closed(1, 3), integers());
    assertThrows(IllegalArgumentException.class, () -> set.subSet(3, 2));
  }

  public void testSubSet_tooLarge() {
    assertThat(ContiguousSet.create(Range.closed(1, 3), integers()).subSet(4, 6)).isEmpty();
  }

  public void testSubSet_tooSmall() {

    @BeforeEach
    void setUp() {
        // Initialize a new response object before each test
        response = new Trans2SetFileInformationResponse();
    }

    /**
     * Test for the constructor of {@link Trans2SetFileInformationResponse}.
     * It should initialize the subCommand correctly.
     */
    @Test
    void testConstructor() {

///

## Execute seu código com seu depurador { #run-your-code-with-your-debugger }

Como você está executando o servidor Uvicorn diretamente do seu código, você pode chamar seu programa Python (sua aplicação FastAPI) diretamente do depurador.

---

Por exemplo, no Visual Studio Code, você pode:

* Ir para o painel "Debug".
* "Add configuration...".
* Selecionar "Python"

     */
    public void recordRdmaSend(int bytes, long durationNanos) {
        rdmaSends.incrementAndGet();
        bytesTransferred.addAndGet(bytes);
        totalSendTime.addAndGet(durationNanos);
    }

    /**
     * Record an RDMA receive operation
     *
     * @param bytes number of bytes received
     * @param durationNanos operation duration in nanoseconds
     */