import org.junit.jupiter.api.*;
import static org.junit.jupiter.api.Assertions.*;

class CalculatorTest {
    private Calculator calc;

    @BeforeAll
    static void initAll() {
        System.out.println("所有测试前执行一次");
    }

    @BeforeEach
    void setUp() {
        calc = new Calculator();
    }

    @Test
    void testAdd() {
        assertEquals(5, calc.add(2, 3));
        assertNotEquals(6, calc.add(2, 3));
    }

    @Test
    void testDivide() {
        assertEquals(2.5, calc.divide(5, 2), 0.001);
        assertThrows(ArithmeticException.class, () -> calc.divide(1, 0));
    }

    @Test
    @DisplayName("测试字符串非空")
    void testString() {
        String result = calc.format(42);
        assertNotNull(result);
        assertTrue(result.contains("42"));
        assertAll("格式化",
            () -> assertNotNull(result),
            () -> assertFalse(result.isEmpty())
        );
    }

    @Test
    @Disabled("待修复")
    void disabledTest() { }

    @ParameterizedTest
    @CsvSource({"1,2,3", "0,0,0", "-1,1,0", "100,200,300"})
    void testAddParameterized(int a, int b, int expected) {
        assertEquals(expected, calc.add(a, b));
    }

    @ParameterizedTest
    @ValueSource(ints = {2, 4, 6, 8})
    void testEven(int n) {
        assertEquals(0, n % 2);
    }

    @AfterEach
    void tearDown() { }

    @AfterAll
    static void tearDownAll() { }
}

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.*;
import org.mockito.junit.jupiter.MockitoExtension;
import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;

@ExtendWith(MockitoExtension.class)
class UserServiceTest {
    @Mock
    private UserRepository userRepository;

    @Mock
    private EmailService emailService;

    @InjectMocks
    private UserService userService;

    @Captor
    private ArgumentCaptor<User> userCaptor;

    @Test
    void testRegister() {
        // Stubbing
        when(userRepository.existsByEmail("test@example.com")).thenReturn(false);
        when(userRepository.save(any(User.class))).thenAnswer(inv -> {
            User u = inv.getArgument(0);
            u.setId(1L);
            return u;
        });

        // 执行
        User result = userService.register("张三", "test@example.com");

        // 验证
        assertNotNull(result);
        assertEquals("张三", result.getName());

        verify(userRepository).save(userCaptor.capture());
        assertEquals("test@example.com", userCaptor.getValue().getEmail());

        verify(emailService).sendWelcome("test@example.com");
        verify(emailService, never()).sendError(any());
    }

    @Test
    void testDuplicateEmail() {
        when(userRepository.existsByEmail("dup@example.com")).thenReturn(true);
        assertThrows(BusinessException.class,
            () -> userService.register("测试", "dup@example.com"));
    }
}

@SpringBootTest
@AutoConfigureMockMvc
class UserControllerIntegrationTest {
    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private UserService userService;

    @Test
    void testGetUser() throws Exception {
        when(userService.findById(1L))
            .thenReturn(Optional.of(new User(1L, "张三", "test@example.com")));

        mockMvc.perform(get("/api/users/1")
                .contentType(MediaType.APPLICATION_JSON))
            .andExpect(status().isOk())
            .andExpect(jsonPath("$.name").value("张三"));
    }

    @Test
    void testCreateUser() throws Exception {
        mockMvc.perform(post("/api/users")
                .contentType(MediaType.APPLICATION_JSON)
                .content("""
                    {"name": "新用户", "email": "new@example.com"}
                    """))
            .andExpect(status().isCreated());
    }
}

import org.testcontainers.containers.MySQLContainer;
import org.testcontainers.junit.jupiter.Container;
import org.testcontainers.junit.jupiter.Testcontainers;

@SpringBootTest
@Testcontainers
class UserRepositoryTest {
    @Container
    static MySQLContainer<?> mysql = new MySQLContainer<>("mysql:8.0")
        .withDatabaseName("testdb")
        .withUsername("test")
        .withPassword("test");

    @DynamicPropertySource
    static void configure(DynamicPropertyRegistry registry) {
        registry.add("spring.datasource.url", mysql::getJdbcUrl);
        registry.add("spring.datasource.username", mysql::getUsername);
        registry.add("spring.datasource.password", mysql::getPassword);
    }

    @Autowired
    private UserRepository userRepository;

    @Test
    void testSaveAndFind() {
        User user = new User("张三", "test@example.com");
        User saved = userRepository.save(user);
        assertNotNull(saved.getId());

        Optional<User> found = userRepository.findById(saved.getId());
        assertTrue(found.isPresent());
        assertEquals("张三", found.get().getName());
    }
}