if (parameters.getPull().get()) {
                parameters.getBaseImages().get().forEach(this::pullBaseImage);
            }

            LoggedExec.exec(execOperations, spec -> {
                spec.executable("docker");

                spec.args("build", parameters.getDockerContext().get().getAsFile().getAbsolutePath());

                if (parameters.getNoCache().get()) {

  public void testNewReference() throws Exception {
    assertThat(Atomics.newReference().get()).isNull();
  }

  public void testNewReference_withInitialValue() throws Exception {
    assertThat(Atomics.newReference(null).get()).isNull();
    assertEquals(OBJECT, Atomics.newReference(OBJECT).get());
  }

  public void testNewReferenceArray_withLength() throws Exception {
    int length = 42;

                (Integer) combination.get(0),
                (Integer) combination.get(1),
                (Integer) combination.get(2),
                (DurationSpec) combination.get(3),
                (DurationSpec) combination.get(4),
                (DurationSpec) combination.get(5),
                (Strength) combination.get(6),
                (Strength) combination.get(7)));
  }

  /**

        assertEquals("value1", builder.initialSettings.get("key1"));

        // Test adding multiple settings
        builder.addInitialSettings("key2", 100);
        builder.addInitialSettings("key3", true);
        assertEquals(3, builder.initialSettings.size());
        assertEquals("value1", builder.initialSettings.get("key1"));
        assertEquals(100, builder.initialSettings.get("key2"));

        // Get password fields using reflection
        Field passwordField = NtlmPasswordAuthenticator.class.getDeclaredField("password");
        passwordField.setAccessible(true);

        char[] originalPassword = (char[]) passwordField.get(authenticator);
        char[] clonedPassword = (char[]) passwordField.get(cloned);

        assertNotNull(stats);
        assertTrue((long) stats.get("totalAllocated") >= 2);
        assertTrue((long) stats.get("totalReleased") >= 1);
        assertNotNull(stats.get("activeResources"));
        assertNotNull(stats.get("closedResources"));
    }

    @Test
    @DisplayName("Test get active resources")
    void testGetActiveResources() {

security = HTTPBearer(description="HTTP Bearer token scheme")


@app.get("/users/me")
def read_current_user(credentials: HTTPAuthorizationCredentials = Security(security)):
    return {"scheme": credentials.scheme, "credentials": credentials.credentials}


client = TestClient(app)


def test_security_http_bearer():
    response = client.get("/users/me", headers={"Authorization": "Bearer foobar"})

        testFilesCleanupService.get().addTaskReports(path, validatePluginsReports())
    }

    project.tasks.withType<FindBrokenInternalLinks>().configureEach {
        testFilesCleanupService.get().addTaskReports(path, findBrokenInternalLinksReports())
    }
    project.tasks.withType<DistributionTest>().configureEach {
        testFilesCleanupService.get().addTaskReports(path, distributionReports())
    }

def get_data_override():
    return [3, 4, 5]


@app.get("/user")
def read_user(
    user_data: tuple[str, list[str]] = Security(get_user, scopes=["foo", "bar"]),
    data: list[int] = Depends(get_data),
):
    return {"user": user_data[0], "scopes": user_data[1], "data": data}


client = TestClient(app)


def test_normal():
    response = client.get("/user")
    assert response.json() == {
        "user": "john",

]


@app.get("/items/stream", response_class=EventSourceResponse)
async def sse_items() -> AsyncIterable[Item]:
    for item in items:
        yield item


@app.get("/items/stream-no-async", response_class=EventSourceResponse)
def sse_items_no_async() -> Iterable[Item]:
    for item in items:
        yield item


@app.get("/items/stream-no-annotation", response_class=EventSourceResponse)