};

  public void testSchedule() {
    MockExecutor mock = new MockExecutor();
    TestExecutor testExecutor = new TestExecutor(mock);

    Future<?> unused1 = testExecutor.schedule(DO_NOTHING, 10, MINUTES);
    mock.assertLastMethodCalled("scheduleRunnable", 10, MINUTES);

    Future<?> unused2 = testExecutor.schedule(callable(DO_NOTHING), 5, SECONDS);
    mock.assertLastMethodCalled("scheduleCallable", 5, SECONDS);
  }

    }

    def usesSetterToLocateOverriddenPropertyWhenGetterDoesNotOverrideAnything() {
        MethodMetaData getter = Mock()
        MethodMetaData setter = Mock()
        MethodMetaData overriddenSetter = Mock()
        ClassMetaData overriddenClass = Mock()
        PropertyMetaData overriddenProperty = Mock()
        propertyMetaData.getter = getter
        propertyMetaData.setter = setter

        when:

    }

    def locatesOverriddenMethodInAncestorClass() {
        ClassMetaData superClassMetaData = Mock()
        ClassMetaData ancestorClassMetaData = Mock()
        MethodMetaData overriddenMethod = Mock()

        when:
        def m = method.overriddenMethod

        then:
        m == overriddenMethod
        _ * owner.superClass >> superClassMetaData

from unittest.mock import Mock, patch

from fastapi import Depends, FastAPI
from fastapi.testclient import TestClient

from docs_src.dependencies.tutorial010_py39 import get_db


def test_get_db():
    app = FastAPI()

    @app.get("/")
    def read_root(c: Annotated[Any, Depends(get_db)]):
        return {"c": str(c)}

    client = TestClient(app)

    dbsession_mock = Mock()

    with patch(

    PrimitiveSink primitiveSink = mock(PrimitiveSink.class);
    Funnels.byteArrayFunnel().funnel(new byte[] {4, 3, 2, 1}, primitiveSink);
    verify(primitiveSink).putBytes(new byte[] {4, 3, 2, 1});
  }

  public void testForBytes_null() {
    assertNullsThrowException(Funnels.byteArrayFunnel());
  }

  public void testForStrings() {
    PrimitiveSink primitiveSink = mock(PrimitiveSink.class);

import static org.mockito.Mockito.mock;

class RequestImplementationTest {

    @Test
    void testArtifactResolverRequestEquality() {
        Session session = mock(Session.class);
        ArtifactCoordinates coords1 = mock(ArtifactCoordinates.class);
        ArtifactCoordinates coords2 = mock(ArtifactCoordinates.class);
        RemoteRepository repo1 = mock(RemoteRepository.class);

import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

/**
 * Utility class for creating test fixtures and reducing code duplication in tests.
 */
public final class TestUtils {

    private TestUtils() {
        // Utility class
    }

    /**
     * Creates a mock UpgradeContext with default settings.
     *
     * @return a mock UpgradeContext
     */

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.calls;
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.when;

/**
 * @author Sebastien Doyon
 */
class DefaultClassRealmManagerTest {

    app = FastAPI()

    @app.get("/")
    def read_root(c: Annotated[Any, Depends(module.dependency_c)]):
        return {"c": str(c)}

    client = TestClient(app)

    a_mock = Mock()
    b_mock = Mock()
    c_mock = Mock()

    with (
        patch(
            f"{module.__name__}.generate_dep_a",
            return_value=a_mock,
            create=True,
        ),
        patch(

        RepositorySystemSession session = mock(RepositorySystemSession.class);
        when(session.getLocalRepository()).thenReturn(localRepository);

        Artifact localRepositoryArtifact = mock(Artifact.class);
        when(localRepositoryArtifact.getFile()).thenReturn(new File(baseDir, "some/path/within"));

        Artifact nonLocalReposioryArtifact = mock(Artifact.class);