return doAssertThrows(expectedThrowable, supplier, /* userPassedSupplier= */ true);
  }

  @CanIgnoreReturnValue
  static <T extends Throwable> T assertThrows(
      Class<T> expectedThrowable, ThrowingRunnable runnable) {
    return doAssertThrows(
        expectedThrowable,
        () -> {
          runnable.run();
          return null;
        },

    return doAssertThrows(expectedThrowable, supplier, /* userPassedSupplier= */ true);
  }

  @CanIgnoreReturnValue
  static <T extends Throwable> T assertThrows(
      Class<T> expectedThrowable, ThrowingRunnable runnable) {
    return doAssertThrows(
        expectedThrowable,
        () -> {
          runnable.run();
          return null;
        },

        }
        return Gson().fromJson(response.body(), klass)
    }

    private
    fun getUserInfo(login: String): GitHubUser {
        val uri = "https://api.github.com/users/$login"
        return invokeGitHubApi(uri, GitHubUser::class.java)
    }

    private

    }

    public ScheduledJob getScheduledJob() {
        return scheduledJob;
    }

    public String getId() {
        return asDocMeta().id();
    }

    public void setId(final String id) {
        asDocMeta().id(id);
    }

    public Long getVersionNo() {
        return asDocMeta().version();
    }

    public void setVersionNo(final Long version) {

async def create_item(item: Item):
    return {"message": "Item received"}


@app.get("/items/", response_model=list[Item], tags=["items"])
async def get_items():
    return [
        {"name": "Plumbus", "price": 3},
        {"name": "Portal Gun", "price": 9001},
    ]


@app.post("/users/", response_model=ResponseMessage, tags=["users"])
async def create_user(user: User):

            while (iterator.hasNext()) {
              Optional<? extends T> optional = iterator.next();
              if (optional.isPresent()) {
                return optional.get();
              }
            }
            return endOfData();
          }
        };
  }

  @GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 0;

    response_model=ResponseModel,
)
async def response_model_has_default_factory_return_dict():
    return {"code": 200}


@app.get(
    "/response_model_has_default_factory_return_model",
    response_model=ResponseModel,
)
async def response_model_has_default_factory_return_model():
    return ResponseModel()


client = TestClient(app)


def test_response_model_has_default_factory_return_dict():

        RdmaProvider provider = RdmaProviderFactory.createProvider("unknown");
        assertNull(provider, "Unknown provider should return null");
    }

    @Test
    public void testSelectBestProvider() {
        RdmaProvider provider = RdmaProviderFactory.selectBestProvider();
        assertNotNull(provider, "Should always return at least TCP provider");
        assertTrue(provider.isAvailable(), "Selected provider should be available");
    }

    MavenExecutionResult setProject(MavenProject project);

    MavenProject getProject();

    MavenExecutionResult setTopologicallySortedProjects(List<MavenProject> projects);

    /**
     * @return the sorted list, or an empty list if there are no projects.
     */
    List<MavenProject> getTopologicallySortedProjects();

    MavenExecutionResult setDependencyResolutionResult(DependencyResolutionResult result);

        }

        @Test
        @DisplayName("Should return tree ID")
        void testGetTid() {
            // Given
            when(mockResponse.getTid()).thenReturn(12345);

            // When
            int tid = mockResponse.getTid();

            // Then
            assertEquals(12345, tid, "Should return the configured tree ID");
            verify(mockResponse).getTid();
        }