package com.example;

import cn.hutool.core.util.StrUtil;

public class Main {
    public static void main(String[] args) {
        // 1. 规范化输入：无论前缀大小写，都统一移除
        String rawSku1 = "SKU_A-001";
        String rawSku2 = "sku_B-002";
        String normalizedSku1 = StrUtil.removePrefixIgnoreCase(rawSku1, "SKU_");
        String normalizedSku2 = StrUtil.removePrefixIgnoreCase(rawSku2, "SKU_");
        System.out.println(StrUtil.format("规范化前缀: '{}' -> '{}'", rawSku1, normalizedSku1));
        System.out.println(StrUtil.format("规范化前缀: '{}' -> '{}'", rawSku2, normalizedSku2));


        System.out.println("---");

        // 2. 转换命名风格：适配数据库查询
        String javaField = "productName";
        String dbColumn = StrUtil.toUnderlineCase(javaField);
        System.out.println(StrUtil.format("Java字段: '{}' -> '{}'", javaField, dbColumn));

        System.out.println("---");

        // 3. 校验与动态响应：检查用户输入并生成提示
        String userInput = "   ";
        if (StrUtil.isBlank(userInput)) {
            // 使用 format 生成动态错误提示
            System.out.println(StrUtil.format("输入无效,用户名不能为空,当前输入:'{}'", userInput));
        }
    }
}

package com.example;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.map.MapUtil;
import cn.hutool.core.util.StrUtil;

import java.util.Date;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        // 模拟从配置文件读取的原始数据，使用 MapUtil.builder() 创建允许 null 值的 Map
        Map<Object, Object> configMap = MapUtil.builder()
                .put("server.port", "808a")           // 格式错误的端口号
                .put("server.timeout", 30000L)        // 正确的 Long 类型
                .put("feature.enabled", "true")       // 布尔字符串
                .put("app.name", "My Awesome App")
                .put("db.connection", null)           // 一个 null 值
                .put("event.startTime", "2025-01-01") // 日期字符串
                .build();

        // 使用 Convert 进行安全的加载
        Integer port = Convert.toInt(configMap.get("server.port"));
        long timeout = Convert.toLong(configMap.get("server.timeout"), 60000L);
        boolean isFeatureEnabled = Convert.toBool(configMap.get("feature.enabled"), false);
        String appName = Convert.toStr(configMap.get("app.name"), "Default App");
        String dbConnection = Convert.toStr(configMap.get("db.connection"), "jdbc:default:connection");
        Date startTime = Convert.toDate(configMap.get("event.startTime"));

        System.out.println(StrUtil.format("端口号 (仅提取出数字位): {}", port)); // 端口号 (仅提取出数字位): 808
        System.out.println(StrUtil.format("超时时间 (Long转Long): {}", timeout)); // 超时时间 (Long 转 Long): 30000
        System.out.println(StrUtil.format("特性开关 (字符串转布尔): {}", isFeatureEnabled)); // 特性开关 (字符串转布尔): true
        System.out.println(StrUtil.format("应用名称 (正常转换): '{}'", appName)); // 应用名称 (正常转换): 'My Awesome App'
        System.out.println(StrUtil.format("数据库连接 (null转String，使用默认值): '{}'", dbConnection)); // 数据库连接 (null 转 String，使用默认值): 'jdbc:default:connection'
        System.out.println(StrUtil.format("活动开始时间 (字符串转Date): {}", startTime)); // 活动开始时间 (字符串转 Date): Wed Jan 01 00:00:00 CST 2025
    }
}

package com.example;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.List;

// 定义一个简单的员工类用于演示
@Data
@AllArgsConstructor
@NoArgsConstructor
class Employee {
    private String name;
    private String department;
    private boolean active;
}

public class Main {
    public static void main(String[] args) {
        // 1. 准备数据：使用 CollUtil.newArrayList 快速创建列表
        List<Employee> allEmployees = CollUtil.newArrayList(
                new Employee("张三", "技术部", true),
                new Employee("李四", "市场部", true),
                new Employee("王五", "技术部", false), // 已离职
                new Employee("赵六", "技术部", true)
        );

        // 2. 过滤：使用 CollUtil.filter 筛选出“技术部”的“在职”员工
        List<Employee> activeTechEmployees = CollUtil.filter(allEmployees,
                (Employee e) -> "技术部".equals(e.getDepartment()) && e.isActive()
        );

        // 3. 映射：使用 CollUtil.map 从员工对象列表中提取出姓名列表
        List<String> names = CollUtil.map(activeTechEmployees, Employee::getName, true);// true 表示忽略空值
        String reportNames = CollUtil.join(names, ",");
        System.out.println(StrUtil.format("技术部在职员工汇报名单: {}", reportNames));
    }
}
// 输出:
// 技术部在职员工汇报名单: 张三, 赵六

package com.example;

import cn.hutool.core.map.MapUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.crypto.SecureUtil;
import cn.hutool.crypto.digest.MD5;

import java.util.Map;

public class Main {
    public static void main(String[] args) {
        // 1. 准备 API 请求参数，顺序是混乱的
        Map<String, Object> params = MapUtil.newHashMap();
        params.put("amount", 100);
        params.put("timestamp", "1672502400");
        params.put("app_id", "xyz789");
        params.put("nonce_str", "bu_ying_gai_bei_bao_han"); // 假设这个字段不参与签名

        // 2. 过滤掉不需要参与签名的字段
        Map<String, Object> filteredParams = MapUtil.filter(params,
                (Map.Entry<String, Object> entry) -> !"nonce_str".equals(entry.getKey())
        );

        // 3. 使用 sortJoin 直接生成“key 正序排列并用&和 = 拼接”的待签名字符串
        // 参数 1: map
        // 参数 2: 键值对之间的连接符
        // 参数 3: 键和值之间的连接符
        String toSign = MapUtil.sortJoin(filteredParams, "&", "=", false);
        System.out.println(StrUtil.format("待签名字符串: {}", toSign));
        // 接下来就可以用这个 toSign 字符串去进行 MD5 或 HMAC 加密了
        String md5_sign = SecureUtil.md5(toSign);
        System.out.println(StrUtil.format("MD5 加密结果: {}", md5_sign));
    }
}
// 输出:
//待签名字符串: amount = 100&app_id = xyz789&timestamp = 1672502400
//MD5 加密结果: eb035d28beaae11764e663e5318ce0b1

package com.example;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.crypto.SecureUtil;
import lombok.Data;
import lombok.ToString;

import java.util.List;

// 1. DTO: 数据传输对象，来自前端
@Data
class UserDTO {
    private String username;
    private String password;
}

// 2. Entity: 实体对象，与数据库表对应
@Data
class UserEntity {
    private Long id;
    private String username;
    private String hashedPassword; // 注意字段名不同
}

// 3. VO: 视图对象，返回给前端
@Data
@ToString
class UserVO {
    private Long id;
    private String username;
}

public class Main {
    public static void main(String[] args) {
        // --- 模拟用户注册流程 ---
        // a. 接收到前端传来的 DTO
        UserDTO userDto = new UserDTO();
        userDto.setUsername("admin");
        userDto.setPassword("123456");

        // b. 将 DTO 转换为 Entity，并处理业务逻辑（如加密密码）
        UserEntity userEntity = new UserEntity();
        BeanUtil.copyProperties(userDto, userEntity); // 自动复制 username 属性
        // 加密密码
        String hash_password = SecureUtil.md5(userDto.getPassword());
        userEntity.setHashedPassword(hash_password);
        userEntity.setId(1L); // 模拟存入数据库后获得 ID

        // c. 将 Entity 转换为 VO，用于返回给前端
        UserVO userVo = BeanUtil.toBean(userEntity, UserVO.class);
        System.out.println("返回给前端的VO: " + userVo);

        // --- 批量转换场景 ---
        UserEntity entity2 = new UserEntity();
        entity2.setId(2L);
        entity2.setUsername("guest");
        List<UserEntity> entityList = List.of(userEntity, entity2);

        List<UserVO> voList = BeanUtil.copyToList(entityList, UserVO.class);
        System.out.println("返回给前端的批量VO列表: " + voList);

    }
}
// 输出:
//返回给前端的 VO: UserVO(id = 1, username = admin)
//返回给前端的批量 VO 列表: [UserVO(id = 1, username = admin), UserVO(id = 2, username = guest)]

package com.example;

import lombok.Data;
import lombok.Value;

// 场景 1: 使用@Data 定义一个用于数据传输的可变 DTO
@Data
class UserDTO {
    private Long id;
    private String username;
    private String email;
}

// 场景 2: 使用@Value 定义一个不可变的数据库配置类
@Value
class DbConfig {
    String jdbcUrl;
    String username;
    String password;
    // @Value 会自动生成包含这三个 final 字段的构造函数
}


public class Main {
    public static void main(String[] args) {
        // @Data 示例
        UserDTO user = new UserDTO();
        user.setId(1L); // 可以调用 setter
        user.setUsername("admin");
        System.out.println(user); // toString()已自动生成

        // @Value 示例
        DbConfig config = new DbConfig("jdbc:mysql://localhost:3306/mydb", "root", "password");
        System.out.println("数据库URL: " + config.getJdbcUrl()); // 可以调用 getter
        // config.setUsername("new_user"); // 这行代码会编译失败，因为没有 setter 方法
    }
}
// 输出:
// UserDTO(id = 1, username = admin, email = null)
// 数据库 URL: jdbc:mysql://localhost: 3306/mydb

package com.example;

import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service; // 假设在 Spring 环境

// 定义依赖接口
interface UserRepository {}
interface EmailService {}

// 使用@RequiredArgsConstructor 实现构造器注入
@Service
@RequiredArgsConstructor
public class UserService {
    
    // final 字段是“必需”的依赖
    private final UserRepository userRepository;
    private final EmailService emailService;

    // Lombok 会自动生成以下构造函数:
    // public UserService(UserRepository userRepository, EmailService emailService) {
    //     this.userRepository = userRepository;
    //     this.emailService = emailService;
    // }
    
    public void registerUser() {
        System.out.println("正在使用 " + userRepository.getClass().getSimpleName() + " 和 " 
                                    + emailService.getClass().getSimpleName() + " 注册用户...");
    }
}

package com.example;

import lombok.Builder;
import lombok.ToString;

@Builder
@ToString
public class ProductQuery {
    private String keyword;       // 关键词 (可选)
    private Long categoryId;      // 分类 ID (可选)
    private Double minPrice;      // 最低价 (可选)
    
    @Builder.Default // 可以为字段设置默认值
    private String sortBy = "default_sort";
    
    @Builder.Default
    private int pageSize = 10;
}


public class Main {
    public static void main(String[] args) {
        // 使用 Builder 模式创建对象，可读性极高
        ProductQuery query = ProductQuery.builder()
            .keyword("笔记本电脑")
            .categoryId(101L)
            .minPrice(5000.0)
            // sortBy 和 pageSize 使用默认值
            .build();
            
        System.out.println(query);
    }
}
// 输出:
// ProductQuery(keyword = 笔记本电脑, categoryId = 101, minPrice = 5000.0, sortBy = default_sort, pageSize = 10)

package com.example;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class Main {
    // Lombok 已自动为我们注入了:
    // private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(Main.class);

    public static void main(String[] args) {
        String username = "testUser";
        
        // 我们可以直接使用 log 变量
        log.info("用户 '{}' 正在尝试登录...", username);
        
        try {
            int result = 1 / 0;
        } catch (Exception e) {
            log.error("计算出错，用户: {}", username, e); // 同时记录异常堆栈
        }
    }
}

package com.example;

import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.Data;
import lombok.NoArgsConstructor; // 反序列化需要无参构造函数

@Data
@NoArgsConstructor // Jackson 反序列化时，通常需要一个无参构造函数来创建对象实例
class SimpleUser {
    private Long id;
    private String name;

    public SimpleUser(Long id, String name) {
        this.id = id;
        this.name = name;
    }
}

public class Main {
    public static void main(String[] args) throws Exception {
        // 1. 准备 ObjectMapper 实例和对象
        ObjectMapper mapper = new ObjectMapper();
        SimpleUser user = new SimpleUser(1L, "admin");

        // 2. 序列化：将 Java 对象转换为 JSON 字符串
        String jsonString = mapper.writeValueAsString(user);
        System.out.println("序列化结果: " + jsonString);

        // 3. 反序列化：将 JSON 字符串转换回 Java 对象
        SimpleUser deserializedUser = mapper.readValue(jsonString, SimpleUser.class);
        System.out.println("反序列化结果: " + deserializedUser);
    }
}
// 输出:
// 序列化结果: {"id": 1, "name": "admin"}
// 反序列化结果: SimpleUser(id = 1, name = admin)

package com.example;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Map;

@Data
@NoArgsConstructor
@AllArgsConstructor
class User {
    private long id;
    private String name;
}


public class Main {
    public static void main(String[] args) {
        User user = new User(1L, "admin");
        // 转 JSON 字符串
        Map<String, Object> stringObjectMap = BeanUtil.beanToMap(user);
        JSONObject jsonObj = JSONUtil.parseObj(stringObjectMap);
        System.out.println("序列化结果: " + jsonObj);
        // 从 JSON 字符串转回对象
        User deserializedUser = JSONUtil.toBean(jsonObj, User.class);
        System.out.println("反序列化结果: " + deserializedUser);
    }
}

package com.example;


import com.fasterxml.jackson.annotation.*;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import lombok.Data;

import java.time.LocalDateTime;

@Data
@JsonInclude(JsonInclude.Include.NON_NULL) // 全局策略：值为 null 的字段不参与序列化
class ApiUser {
    private Long id;

    @JsonProperty("user_name") // 序列化和反序列化时，都使用 user_name
    private String username;

    @JsonIgnore // 此字段将永远不会被序列化或反序列化
    private String password;

    @JsonAlias({"email_address", "mail"}) // 反序列化时，"email_address" 或 "mail" 都能映射到 email 字段
    private String email;

    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") // 指定日期时间格式
    private LocalDateTime createTime;
}


public class Main {
    public static void main(String[] args) throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
        mapper.registerModule(new JavaTimeModule()); // 注册 Java 8 日期模块


        // --- 序列化演示 ---
        ApiUser user = new ApiUser();
        user.setId(101L);
        user.setUsername("test-user");
        user.setPassword("a_very_secret_password"); // 这个字段将被忽略
        user.setCreateTime(LocalDateTime.of(2025, 8, 8, 10, 30, 0));
        // user.email 为 null，所以根据@JsonInclude，它不会出现在输出中

        // 先通过writerWithDefaultPrettyPrinter()再使用writeValueAsString()能得到一个美观的Json格式
        String serializedJson = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(user);
        System.out.println("--- 序列化（对象转JSON）---");
        System.out.println(serializedJson);

        // --- 反序列化演示 ---
        // 注意这里的一个核心:无论使用的是mail还是email_address，反序列化时都会映射到email字段
        String incomingJson = "{ \"id\": 102, \"user_name\": \"guest\", \"mail\": \"guest@example.com\" }";
        ApiUser deserializedUser = mapper.readValue(incomingJson, ApiUser.class);
        System.out.println("\n--- 反序列化（JSON转对象）---");
        System.out.println(deserializedUser);


    }
}
// 输出:
// --- 序列化（对象转JSON）---
// {
//   "id" : 101,
//   "user_name" : "test-user",
//   "createTime" : "2025-08-08 10:30:00"
// }
//
// --- 反序列化（JSON转对象）---
// ApiUser(id = 102, username = guest, password = null, email = guest@example.com, createTime = null)

package com.example;

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.List;


@Data
@NoArgsConstructor
@AllArgsConstructor
class User {
    private long id;
    private String name;
}


public class Main {
    public static void main(String[] args) throws Exception {
        ObjectMapper mapper = new ObjectMapper();
        String json = "[{\"id\":1,\"name\":\"UserA\"},{\"id\":2,\"name\":\"UserB\"}]";

        // 使用 TypeReference 来保留完整的泛型信息
        List<User> userList = mapper.readValue(json, new TypeReference<List<User>>() {});

        System.out.println("List大小: " + userList.size());
        System.out.println("第一个用户的名字: " + userList.get(0).getName());
    }
}
// 输出:
// List 大小: 2
// 第一个用户的名字: UserA

package com.example;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

public class Main {
    public static void main(String[] args) throws Exception {
        ObjectMapper mapper = new ObjectMapper();
        String json = "{\"meta\":{\"code\":200},\"data\":{\"user\":{\"name\":\"Admin\",\"roles\":[\"ADMIN\",\"EDITOR\"]}}}";

        // 将 JSON 解析为一个树节点
        JsonNode rootNode = mapper.readTree(json);

        // 使用.path()方法安全地导航，如果节点不存在不会抛异常
        String username = rootNode.path("data").path("user").path("name").asText();
        String firstRole = rootNode.path("data").path("user").path("roles").get(0).asText();

        System.out.println("用户名: " + username);
        System.out.println("第一个角色: " + firstRole);
    }
}
// 输出:
// 用户名: Admin
// 第一个角色: ADMIN

package com.example;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;

public class Main {
    public static void main(String[] args) {
        String json = "{\"meta\":{\"code\":200},\"data\":{\"user\":{\"name\":\"Admin\",\"roles\":[\"ADMIN\",\"EDITOR\"]}}}";

        // 使用JSONUtil.parseObj解析并逐层获取
        JSONObject jsonObj = JSONUtil.parseObj(json);

        // 使用JSONPath更简洁地获取值
        String username = JSONUtil.getByPath(jsonObj, "data.user.name").toString();
        String firstRole = JSONUtil.getByPath(jsonObj, "data.user.roles[0]").toString();

        System.out.println("用户名: " + username); //  Admin
        System.out.println("第一个角色: " + firstRole); //  ADMIN
    }
}

package com.example.utils;
public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
}

package com.example.utils;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;

@DisplayName("计算器基础功能测试")
class CalculatorTest {
    @Test // 标记这是一个测试方法
    @DisplayName("测试两个正数相加")
    void test_add_two_positive_numbers() {
        // 1. Arrange (准备): 创建计算器实例，定义预期结果
        Calculator calculator = new Calculator();
        int expectedResult = 15;

        // 2. Act (执行): 调用add方法
        int actualResult = calculator.add(5, 10);

        // 3. Assert (断言): 验证实际结果是否与预期相等
        assertEquals(expectedResult, actualResult, "两个正数相加的结果不正确");
    }
}

import org.junit.jupiter.api.*;

@DisplayName("JUnit 5 生命周期注解演示")
class LifecycleDemoTest {

    // 1. 在所有测试开始前执行一次，必须是静态方法
    @BeforeAll
    static void beforeAllTests() {
        System.out.println("【@BeforeAll】: 所有测试即将开始，执行一次性全局设置...");
    }

    // 2. 在每个测试方法开始前执行
    @BeforeEach
    void setUpForEachTest() {
        System.out.println("【@BeforeEach】: 测试方法即将开始，准备测试环境...");
    }

    @Test
    @DisplayName("测试方法一")
    void testMethodOne() {
        System.out.println(">> 执行测试方法 1...");
        Assertions.assertTrue(true);
    }

    @Test
    @DisplayName("测试方法二")
    void testMethodTwo() {
        System.out.println(">> 执行测试方法 2...");
        Assertions.assertEquals(4, 2 + 2);
    }

    // 3. 在每个测试方法结束后执行
    @AfterEach
    void tearDownForEachTest() {
        System.out.println("【@AfterEach】: 测试方法已结束，清理测试环境...");
    }

    // 4. 在所有测试结束后执行一次，必须是静态方法
    @AfterAll
    static void afterAllTests() {
        System.out.println("【@AfterAll】: 所有测试已完成，执行一次性全局清理...");
    }
}

import org.junit.jupiter.api.*;
import java.util.Stack;
import static org.junit.jupiter.api.Assertions.*;

@DisplayName("一个栈(Stack)的测试")
class StackTest {

    Stack<Object> stack;

    @Test
    @DisplayName("新创建的栈应该是空的")
    @Tag("fast")
    void is_instantiated_with_new() {
        new Stack<>();
    }

    @Nested
    @DisplayName("当栈是新创建时")
    class WhenNew {

        @BeforeEach
        void createNewStack() {
            stack = new Stack<>();
        }

        @Test
        @DisplayName("isEmpty() 应该返回 true")
        @Tag("fast")
        void is_empty() {
            assertTrue(stack.isEmpty());
        }

        @Test
        @DisplayName("当 pop 一个空栈时，应抛出 EmptyStackException 异常")
        void throws_exception_when_popped() {
            assertThrows(java.util.EmptyStackException.class, () -> stack.pop());
        }

        @Test
        @Disabled("这个功能暂时不做，等待需求明确")
        @DisplayName("size() 应该返回 0")
        void size_must_be_zero() {
            assertEquals(0, stack.size());
        }
    }

    @Nested
    @DisplayName("当有新元素被 push 进栈后")
    class AfterPushing {

        String anElement = "an element";

        @BeforeEach
        void pushAnElement() {
            stack = new Stack<>();
            stack.push(anElement);
        }

        @Test
        @DisplayName("isEmpty() 应该返回 false")
        @Tag("slow") // 假设这个测试场景准备比较耗时
        void is_not_empty() {
            assertFalse(stack.isEmpty());
        }

        @Test
        @DisplayName("pop() 应该返回 push 进去的那个元素")
        @Tag("fast")
        void return_element_when_popped() {
            assertEquals(anElement, stack.pop());
        }

        @Test
        @DisplayName("pop() 后，栈应该变为空")
        @Tag("fast")
        void become_empty_after_pop() {
            stack.pop();
            assertTrue(stack.isEmpty());
        }
    }
}

import static org.assertj.core.api.Assertions.assertThat;

package com.example.assertj;

import org.junit.jupiter.api.Test;
import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;

class AssertJShowcaseTest {

    @Test
    void collection_assertions_showcase() {
        List<String> fellowship = List.of("Frodo", "Sam", "Pippin");

        // 像一句话一样，从左到右阅读即可
        assertThat(fellowship).hasSize(3)
                              .contains("Sam")
                              .doesNotContain("Sauron");
        
        // 验证包含且仅包含指定元素，且顺序必须完全一致
        assertThat(fellowship).containsExactly("Frodo", "Sam", "Pippin");
    }

    @Test
    void string_assertions_showcase() {
        String text = "Hello, World!";
        assertThat(text).isEqualToIgnoringCase("hello, world!")
                        .startsWith("Hello")
                        .endsWith("!")
                        .contains("World");
    }

    @Test
    void exception_assertions_showcase() {
        // 优雅地验证某段代码是否抛出了预期的异常
        assertThatThrownBy(() -> {
            Integer.parseInt("not a number");
        })
        .isInstanceOf(NumberFormatException.class) // 验证异常类型
        .hasMessageContaining("not a number");      // 验证异常信息
    }
    
    @Test
    void custom_error_message_showcase() {
        String role = "guest";
        // 使用.as()方法，可以为断言添加业务描述，一旦失败，错误报告将更加清晰
        assertThat(role).as("新注册用户的默认角色应该是'USER'")
                        .isEqualTo("USER");
        // 失败时会输出: [新注册用户的默认角色应该是'USER'] expected: "USER" but was: "guest"
    }
}

// SUT: RegistrationService.java
public class RegistrationService {
    private final UserRepository userRepository;
    private final NotificationService notificationService;

    public RegistrationService(UserRepository userRepository, NotificationService notificationService) {
        this.userRepository = userRepository;
        this.notificationService = notificationService;
    }

    public boolean registerUser(String username, String email) {
        if (userRepository.existsByUsername(username)) {
            return false; // 用户已存在，注册失败
        }
        User newUser = new User(username, email);
        userRepository.save(newUser);
        notificationService.sendWelcomeEmail(email);
        return true;
    }
}

// 依赖项接口
public interface UserRepository {
    boolean existsByUsername(String username);
    void save(User user);
}
public interface NotificationService {
    void sendWelcomeEmail(String email);
}
public class User { /* ... */ }

@ExtendWith(MockitoExtension.class)
class RegistrationServiceTest {

    @Mock // 1. 创建一个UserRepository的“模拟”对象
    private UserRepository userRepository;

    @Mock // 2. 创建一个NotificationService的“模拟”对象
    private NotificationService notificationService;

    @InjectMocks // 3. 创建一个真实的RegistrationService实例，并将上面的两个mock对象注入进去
    private RegistrationService registrationService;
    
    // 接下来我们将在这里编写测试方法...
}

@Test
@DisplayName("当用户名不存在时，应注册成功并发送邮件")
void test_register_user_success() {
    // === 2. 设定行为 (Stubbing) - 这是 Arrange 阶段的核心 ===
    // 规定：当调用userRepository的existsByUsername方法并传入"newUser"时，返回false
    when(userRepository.existsByUsername("newUser")).thenReturn(false);

    // === Act ===
    boolean result = registrationService.registerUser("newUser", "new@example.com");

    // === Assert (使用AssertJ) ===
    assertThat(result).isTrue();

    // 接下来是第三步：验证交互
}

@Test
@DisplayName("当用户名不存在时，应注册成功并发送邮件")
void test_register_user_success() {
    // === Arrange & Stubbing ===
    when(userRepository.existsByUsername("newUser")).thenReturn(false);

    // === Act ===
    boolean result = registrationService.registerUser("newUser", "new@example.com");

    // === Assert (返回值) ===
    assertThat(result).isTrue();

    // === 3. 验证交互 (Verification) ===
    // 验证：userRepository的save方法被【恰好调用了1次】
    verify(userRepository, times(1)).save(any(User.class));
    // 验证：notificationService的sendWelcomeEmail方法被【恰好调用了1次】，且参数正确
    verify(notificationService).sendWelcomeEmail("new@example.com");
}

// 正确：一个匹配器，一个具体值用eq()包裹
when(service.updateUser(eq(1L), any(UserDTO.class))).thenReturn(true);

// 错误：混合使用匹配器和原始值
// when(service.updateUser(1L, any(UserDTO.class))).thenReturn(true); // 这会抛出异常！

@Test
@DisplayName("注册成功时，保存的User对象用户名应正确")
void test_user_details_on_save() {
    // Arrange
    when(userRepository.existsByUsername("testUser")).thenReturn(false);
    
    // 1. 创建一个User类型的参数捕获器
    ArgumentCaptor<User> userCaptor = ArgumentCaptor.forClass(User.class);

    // Act
    registrationService.registerUser("testUser", "test@example.com");

    // 2. 在验证时，使用.capture()来捕获传入的参数
    verify(userRepository).save(userCaptor.capture());

    // 3. 从捕获器中获取值并进行断言
    User savedUser = userCaptor.getValue();
    assertThat(savedUser.getUsername()).isEqualTo("testUser");
    assertThat(savedUser.getEmail()).isEqualTo("test@example.com");
}