Mockito.when(mockList.get(anyInt())).thenReturn("Default");
System.out.println(mockList.get(0)); // Выведет: Default
System.out.println(mockList.get(999)); // Выведет: Default

Mockito.when(mockList.get(eq(1))).thenReturn("Specific");
System.out.println(mockList.get(1)); // Выведет: Specific
System.out.println(mockList.get(2)); // Выведет: null

Mockito.when(mockList.get(argThat(i -> i % 2 == 0))).thenReturn("Even");
System.out.println(mockList.get(2)); // Выведет: Even
System.out.println(mockList.get(3)); // Выведет: null

List<String> realList = new ArrayList<>();
List<String> spyList = Mockito.spy(realList);

// Переопределяем метод
Mockito.when(spyList.size()).thenReturn(100);

// Реальные методы продолжают работать
spyList.add("Item");
System.out.println(spyList.get(0)); // Выведет: Item
System.out.println(spyList.size()); // Выведет: 100

@Service
public class CalculatorService {
    public int add(int a, int b) {
        return a + b;
    }

    public int multiply(int a, int b) {
        return a * b;
    }
}

@ExtendWith(MockitoExtension.class)
public class CalculatorServiceTest {

    @Spy
    private CalculatorService calculatorService;

    @Test
    void testPartialMocking() {
        // Частично переопределяем метод
        Mockito.when(calculatorService.add(anyInt(), eq(0))).thenReturn(0);

        // Проверка
        Assertions.assertEquals(0, calculatorService.add(10, 0)); // Переопределено
        Assertions.assertEquals(30, calculatorService.add(10, 20)); // Реальная логика

        // Проверяем другой метод
        Assertions.assertEquals(200, calculatorService.multiply(10, 20));
    }
}

import java.util.HashSet;
import java.util.Objects;
import java.util.Set;

public class Task030125_1 {
    static class Person {
        String name;

        Person(String name) {
            this.name = name;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Person person = (Person) o;
            return Objects.equals(name, person.name);
        }

        @Override
        public int hashCode() {
            return Objects.hash(name);
        }
    }

    public static void main(String[] args) {
        Set<Person> set = new HashSet<>();
        set.add(new Person("Alice"));
        set.add(new Person("Bob"));
        set.add(new Person("Alice"));

        System.out.println(set.size());
    }
}

List<String> mockList = Mockito.mock(List.class);

// Настраиваем поведение метода
Mockito.when(mockList.get(0)).thenReturn("MockedValue");

// Проверяем
System.out.println(mockList.get(0)); // Выведет: MockedValue
System.out.println(mockList.get(1)); // Выведет: null (по умолчанию)

Mockito.when(mockList.get(0))
       .thenReturn("FirstCall")
       .thenReturn("SecondCall");

System.out.println(mockList.get(0)); // Выведет: FirstCall
System.out.println(mockList.get(0)); // Выведет: SecondCall
System.out.println(mockList.get(0)); // Выведет: SecondCall (последний возврат повторяется)

Копировать код
List<String> mockList = Mockito.mock(List.class);

// Настраиваем метод
Mockito.when(mockList.get(1)).thenThrow(new RuntimeException("Error occurred"));

// Попробуем вызвать
try {
    mockList.get(1); // Бросит исключение
} catch (RuntimeException e) {
    System.out.println(e.getMessage()); // Выведет: Error occurred
}

Mockito.when(mockList.get(0))
       .thenThrow(new IllegalArgumentException("First error"))
       .thenThrow(new RuntimeException("Second error"));

try {
    mockList.get(0); // Бросит IllegalArgumentException
} catch (IllegalArgumentException e) {
    System.out.println(e.getMessage()); // Выведет: First error
}

try {
    mockList.get(0); // Бросит RuntimeException
} catch (RuntimeException e) {
    System.out.println(e.getMessage()); // Выведет: Second error
}

List<String> mockList = Mockito.mock(List.class);

// Настраиваем кастомное поведение
Mockito.when(mockList.get(anyInt())).thenAnswer(invocation -> {
    int index = invocation.getArgument(0);
    return "Value at index " + index;
});

// Проверяем
System.out.println(mockList.get(0)); // Выведет: Value at index 0
System.out.println(mockList.get(5)); // Выведет: Value at index 5

Mockito.when(mockList.get(anyInt())).thenAnswer(invocation -> {
    int index = invocation.getArgument(0);
    if (index % 2 == 0) {
        return "Even Index";
    } else {
        return "Odd Index";
    }
});

System.out.println(mockList.get(2)); // Выведет: Even Index
System.out.println(mockList.get(3)); // Выведет: Odd Index

Mockito.when(mockList.get(anyInt())).thenAnswer(invocation -> {
    int index = invocation.getArgument(0);
    System.out.println("Method called with index: " + index);
    return "Logged Value";
});

System.out.println(mockList.get(10)); // Лог: Method called with index: 10
                                      // Вывод: Logged Value

@Service
public class OrderService {
    public String createOrder(String productId) {
        return "Order created for product: " + productId;
    }

    public void cancelOrder(String orderId) {
        throw new UnsupportedOperationException("Cancel not supported");
    }

    public String getOrderStatus(String orderId) {
        return "Status for order " + orderId;
    }
}

@ExtendWith(MockitoExtension.class)
public class OrderServiceTest {

    @Mock
    private OrderService orderService;

    @Test
    void testThenReturn() {
        // Настраиваем thenReturn
        Mockito.when(orderService.createOrder("123")).thenReturn("Mocked Order Created");

        String result = orderService.createOrder("123");
        Assertions.assertEquals("Mocked Order Created", result);
    }

    @Test
    void testThenThrow() {
        // Настраиваем thenThrow
        Mockito.when(orderService.cancelOrder("invalid")).thenThrow(new IllegalArgumentException("Invalid Order"));

        Assertions.assertThrows(IllegalArgumentException.class, () -> {
            orderService.cancelOrder("invalid");
        });
    }

    @Test
    void testThenAnswer() {
        // Настраиваем thenAnswer
        Mockito.when(orderService.getOrderStatus(anyString())).thenAnswer(invocation -> {
            String orderId = invocation.getArgument(0);
            return "Dynamic status for " + orderId;
        });

        String status = orderService.getOrderStatus("456");
        Assertions.assertEquals("Dynamic status for 456", status);
    }
}

@SpringBootTest
public class ApplicationTests {

    @Autowired
    private MyService myService;

    @Test
    public void contextLoads() {
        Assertions.assertNotNull(myService);
    }
}

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.MOCK) // Загружается mock-среда
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT) // Используется реальный сервер с портом

@ContextConfiguration(classes = MyConfig.class) // Задаём конкретный класс конфигурации
@SpringBootTest
public class ConfiguredTest {
    @Autowired
    private MyService myService;

    @Test
    public void testWithCustomConfig() {
        Assertions.assertNotNull(myService);
    }
}

@SpringBootTest
public class ServiceTest {

    @MockitoBean
    private MyRepository myRepository;

    @SpyBean
    private MyService myService;

    @Test
    public void testWithMockBean() {
        Mockito.when(myRepository.findById(1L)).thenReturn(Optional.of(new MyEntity(1L, "Test")));

        String result = myService.processEntity(1L);
        Assertions.assertEquals("Processed: Test", result);
    }
}

@TestPropertySource(properties = "spring.datasource.url=jdbc:h2:mem:testdb")
@SpringBootTest
public class PropertySourceTest {

    @Autowired
    private DataSource dataSource;

    @Test
    public void testProperties() throws SQLException {
        Assertions.assertTrue(dataSource.getConnection().getMetaData().getURL().contains("testdb"));
    }
}

public class Task060125_1 {
    public static void main(String[] args) {
        int a = 10;
        double b = 3.0;
        double c = a / b;
        System.out.println(c);
    }
}