import common.VersionedSettingsBranch
import configurations.BaseGradleBuildType
import configurations.applyDefaults
import configurations.applyTestDefaults
import io.mockk.every
import io.mockk.impl.annotations.MockK
import io.mockk.junit5.MockKExtension
import io.mockk.mockk
import io.mockk.slot
import jetbrains.buildServer.configs.kotlin.BuildStep
import jetbrains.buildServer.configs.kotlin.BuildSteps

        <!-- For tests only. Must be in compile scope such that the Teamcity generate goal is able to compile the tests -->
        <dependency>
            <groupId>io.mockk</groupId>
            <artifactId>mockk-jvm</artifactId>
            <version>${mockk.version}</version>
        </dependency>
        <dependency>
            <groupId>net.bytebuddy</groupId>
            <artifactId>byte-buddy</artifactId>

    private final ProjectBuilder projectBuilder = mock(ProjectBuilder.class);
    private final MavenSession session = mock(MavenSession.class);
    private final MavenExecutionRequest mavenExecutionRequest = mock(MavenExecutionRequest.class);

    private final ProjectsSelector projectsSelector = new DefaultProjectsSelector(projectBuilder);

    // Not using mocks for these strategies - a mock would just copy the actual implementation.

awkward-to-reproduce situations like 500 errors or slow-loading responses.


### Example

Use MockWebServer the same way that you use mocking frameworks like
[Mockito](https://github.com/mockito/mockito):

1. Script the mocks.
2. Run application code.
3. Verify that the expected requests were made.

Here's a complete example:

### Java
```java
public void test() throws Exception {

    assertEquals(0, cms.count("a"));
    assertTrue(cms.removeExactly("b", 2));
    assertEquals(1, cms.count("b"));
  }

  public void testIteratorRemove_actualMap() {
    // Override to avoid using mocks.
    multiset = ConcurrentHashMultiset.create();

    multiset.add(KEY);
    multiset.add(KEY + "_2");
    multiset.add(KEY);

    int mutations = 0;

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(

class SmbTransportPoolImplTest {

    private SmbTransportPoolImpl pool;

    @Mock
    private CIFSContext ctx;
    @Mock
    private Configuration config;
    @Mock
    private NameServiceClient nameSvc;
    @Mock
    private Credentials creds;
    @Mock
    private Address address;
    @Mock
    private SmbNegotiationResponse negotiationResponse;

    @BeforeEach
    void setUp() {

    private StrategyOrchestrator orchestrator;
    private List<UpgradeStrategy> mockStrategies;

    @BeforeEach
    void setUp() {
        mockStrategies = List.of(mock(UpgradeStrategy.class), mock(UpgradeStrategy.class), mock(UpgradeStrategy.class));
        orchestrator = new StrategyOrchestrator(mockStrategies);
    }

    private UpgradeContext createMockContext() {
        return TestUtils.createMockContext();

            data = new byte[128];
            Arrays.fill(data, (byte) 0x00);

            // Set up mock messages
            request = mock(CommonServerMessageBlock.class);
            response = mock(CommonServerMessageBlock.class);
        }

        @Test
        @DisplayName("Should sign data correctly with zero signature field")

  }

  @AndroidIncompatible // Mocking ExecutorService is forbidden there. TODO(b/218700094): Don't mock.
  public void testGetExitingExecutorService_executorDelegatesToOriginal() {
    TestApplication application = new TestApplication();
    ThreadPoolExecutor executor = mock(ThreadPoolExecutor.class);
    ThreadFactory threadFactory = mock(ThreadFactory.class);
    when(executor.getThreadFactory()).thenReturn(threadFactory);