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);
    }
}

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
    <scope>test</scope>
</dependency>

spring.datasource.url=jdbc:postgresql://localhost:5432/testdb
spring.datasource.username=test
spring.datasource.password=test
spring.jpa.hibernate.ddl-auto=update

@SpringBootTest
@TestPropertySource(locations = "classpath:application-test.properties")
@Transactional
public class UserRepositoryTest {

    @Autowired
    private UserRepository userRepository;

    @Test
    public void testSaveAndFindUser() {
        // Создаём пользователя
        User user = new User();
        user.setName("John");
        user.setEmail("john@example.com");

        // Сохраняем пользователя
        userRepository.save(user);

        // Проверяем, что он сохраняется и извлекается
        Optional<User> foundUser = userRepository.findById(user.getId());
        Assertions.assertTrue(foundUser.isPresent());
        Assertions.assertEquals("John", foundUser.get().getName());
    }
}

@Sql(scripts = "/test-data.sql", executionPhase = Sql.ExecutionPhase.BEFORE_TEST_METHOD)
@SpringBootTest
public class SqlTest {

    @Autowired
    private UserRepository userRepository;

    @Test
    public void testWithSqlData() {
        Optional<User> user = userRepository.findByName("PreloadedUser");
        Assertions.assertTrue(user.isPresent());
    }
}

INSERT INTO users (id, name, email) VALUES (1, 'PreloadedUser', 'user@example.com');

@WebMvcTest(controllers = MyController.class)
public class MyControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private MyService myService;

    // Тесты будут здесь
}

@WebMvcTest(controllers = MyController.class)
@Import(MyCustomConfig.class)
public class MyControllerTest {
    // Тесты
}

mockMvc.perform(get("/api/items"))
       .andExpect(status().isOk());

mockMvc.perform(post("/api/items")
        .content("{\"name\":\"Test Item\"}")
        .contentType(MediaType.APPLICATION_JSON))
       .andExpect(status().isCreated());

mockMvc.perform(get("/api/items"))
       .andExpect(status().isOk())                       // Проверка HTTP-статуса
       .andExpect(content().contentType(MediaType.APPLICATION_JSON)) // Проверка заголовка Content-Type
       .andExpect(jsonPath("$.size()").value(3));        // Проверка JSON-данных

MvcResult result = mockMvc.perform(get("/api/items"))
                          .andExpect(status().isOk())
                          .andReturn();

String responseBody = result.getResponse().getContentAsString();
Assertions.assertTrue(responseBody.contains("ItemName"));

ObjectMapper objectMapper = new ObjectMapper();
String json = objectMapper.writeValueAsString(new Item(1L, "Test Item"));

String jsonResponse = "{\"id\":1,\"name\":\"Test Item\"}";
Item item = objectMapper.readValue(jsonResponse, Item.class);
Assertions.assertEquals("Test Item", item.getName());

public class Task070125_1 {
    public static void main(String[] args) {
        String str1 = "hello";
        String str2 = "world";
        String result = str1.concat(" ").concat(str2).toUpperCase();
        System.out.println(result);
    }
}

@RestController
@RequestMapping("/api/items")
public class ItemController {

    private final ItemService itemService;

    @Autowired
    public ItemController(ItemService itemService) {
        this.itemService = itemService;
    }

    @GetMapping
    public List<Item> getAllItems() {
        return itemService.getAllItems();
    }

    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    public Item createItem(@RequestBody Item item) {
        return itemService.saveItem(item);
    }

    @DeleteMapping("/{id}")
    @ResponseStatus(HttpStatus.NO_CONTENT)
    public void deleteItem(@PathVariable Long id) {
        itemService.deleteItem(id);
    }
}

@WebMvcTest(controllers = ItemController.class)
public class ItemControllerTest {

    @Autowired
    private MockMvc mockMvc;

   @MockitoBean
    private ItemService itemService;

    @Test
    public void testGetAllItems() throws Exception {
        List<Item> items = Arrays.asList(new Item(1L, "Item1"), new Item(2L, "Item2"));
        Mockito.when(itemService.getAllItems()).thenReturn(items);

        mockMvc.perform(get("/api/items"))
               .andExpect(status().isOk())
               .andExpect(content().contentType(MediaType.APPLICATION_JSON))
               .andExpect(jsonPath("$.size()").value(2))
               .andExpect(jsonPath("$[0].name").value("Item1"));
    }

    @Test
    public void testCreateItem() throws Exception {
        Item item = new Item(1L, "NewItem");
        Mockito.when(itemService.saveItem(Mockito.any(Item.class))).thenReturn(item);

        mockMvc.perform(post("/api/items")
                .content("{\"name\":\"NewItem\"}")
                .contentType(MediaType.APPLICATION_JSON))
               .andExpect(status().isCreated())
               .andExpect(jsonPath("$.name").value("NewItem"));
    }

    @Test
    public void testDeleteItem() throws Exception {
        mockMvc.perform(delete("/api/items/1"))
               .andExpect(status().isNoContent());
    }
}

<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
    <scope>runtime</scope>
</dependency>

spring.datasource.url=jdbc:postgresql://localhost:5432/testdb
spring.datasource.username=user
spring.datasource.password=password
spring.jpa.hibernate.ddl-auto=create-drop

@DataJpaTest
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
@Sql(scripts = "/init-test-data.sql")
public class UserRepositoryTest {

    @Autowired
    private UserRepository userRepository;

    @Test
    public void testFindByUsername() {
        User user = userRepository.findByUsername("testuser");
        assertNotNull(user);
        assertEquals("testuser", user.getUsername());
    }
}

public class Task080125_1 {
    private static int x = 5;
    
    static {
        x = 10;
    }
    
    {
        x = 15;
    }
    
    public Task080125_1() {
        System.out.println(x);
    }
    
    public static void main(String[] args) {
        new Task080125_1();
    }
}