package com.example.demo;

import com.alibaba.fastjson2.JSON;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.AfterEach;
import static org.junit.jupiter.api.Assertions.*;

import com.example.demo.draft.demo043.util.FormatUtil;

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

import lombok.extern.slf4j.Slf4j;

/**
 * FormatUtil工具类测试类
 * 
 * <p>本测试类对FormatUtil中的所有方法进行全面的单元测试，确保每个方法的功能正确性。</p>
 * 
 * <p><b>测试策略：</b></p>
 * <ul>
 *   <li>每个方法对应多个测试用例，覆盖所有分支情况</li>
 *   <li>每个测试用例独立测试一个特定场景</li>
 *   <li>包含正常情况、边界情况、异常情况的测试</li>
 *   <li>使用详细的文档注释说明每个测试用例的目的</li>
 * </ul>
 * 
 * <p><b>测试覆盖范围：</b></p>
 * <ul>
 *   <li>时间格式化模块测试</li>
 *   <li>字符串处理模块测试</li>
 *   <li>坐标系转换模块测试</li>
 *   <li>极值/边界值检查处理模块测试</li>
 *   <li>数据KV映射处理模块测试</li>
 * </ul>
 * 
 * @author demo043项目组
 * @version 1.0.0
 * @since 2024年
 */
@SuppressWarnings("all")
@Slf4j
@DisplayName("FormatUtil工具类测试")
public class FormatUtilTest {
    
    private Map<String, Object> params;
    
    /**
     * 每个测试方法执行前的初始化操作
     */
    @BeforeEach
    void setUp() {
        params = new HashMap<>();
    }
    
    /**
     * 每个测试方法执行后的清理操作
     */
    @AfterEach
    void tearDown() {
        params.clear();
    }

    // ==================== 时间格式化模块测试 ====================
    
    /**
     * 测试formatTime方法 - 正常时间格式转换
     * 
     * <p><b>测试目的：</b>验证formatTime方法能够正确进行时间格式转换</p>
     * <p><b>测试场景：</b>从"yyyy-MM-dd HH:mm:ss"格式转换为"yyyy/MM/dd"格式</p>
     * <p><b>预期结果：</b>转换后的时间格式正确</p>
     */
    @Test
    @DisplayName("formatTime方法测试 - 正常格式转换 - 【已验证】")
    void testFormatTime_NormalConversion() {
        System.out.println();
        log.info("========== 时间格式化模块测试 - 正常格式转换 ==========");
        
        // 输入参数
        String inputTime = "2024-01-15 14:30:25";
        params.put("fromFormat", "yyyy-MM-dd HH:mm:ss");
        params.put("toFormat", "yyyy/MM/dd");
        
        log.info("输入参数:");
        log.info("  - 时间字符串: {}", inputTime);
        log.info("  - 源格式: {}", params.get("fromFormat"));
        log.info("  - 目标格式: {}", params.get("toFormat"));

        // 执行测试
        Object result = FormatUtil.formatTime(inputTime, params);

        // 断言验证
        String expectedResult = "2024/01/15";
        log.info("预期结果: {}", expectedResult);
        log.info("实际结果: {}", result);
        assertEquals(expectedResult, result);
        log.info("✓ 测试通过 - 格式转换结果正确");
    }
    
    /**
     * 测试formatTime方法 - 边界情况：空值处理
     * 
     * <p><b>测试目的：</b>验证formatTime方法对空值的容错处理</p>
     * <p><b>测试场景：</b>输入时间为空字符串</p>
     * <p><b>预期结果：</b>返回空字符串或默认值</p>
     */
    @Test
    @DisplayName("formatTime方法测试 - 空值处理 - 【已验证】")
    void testFormatTime_EmptyInput() {
        System.out.println();
        log.info("========== 时间格式化模块测试 - 空值处理 ==========");
        
        // 输入参数
        String inputTime = "";
        params.put("fromFormat", "yyyy-MM-dd");
        params.put("toFormat", "yyyy/MM/dd");
        
        log.info("输入参数:");
        log.info("  - 时间字符串: '{}' (空字符串)", inputTime);
        log.info("  - 源格式: {}", params.get("fromFormat"));
        log.info("  - 目标格式: {}", params.get("toFormat"));

        // 执行测试
        Object result = FormatUtil.formatTime(inputTime, params);

        // 断言验证
        String expectedResult = "";
        log.info("预期结果: ''，（空字符串）");
        log.info("实际结果: '{}'", result);
        assertNotNull(result);
        assertEquals(expectedResult, result);
        log.info("✓ 测试通过 - 空值处理正确");
    }
    
    /**
     * 测试formatTime方法 - 异常情况：格式不匹配
     * 
     * <p><b>测试目的：</b>验证formatTime方法对格式不匹配情况的处理</p>
     * <p><b>测试场景：</b>时间字符串与格式不匹配</p>
     * <p><b>预期结果：</b>输出原值</p>
     */
    @Test
    @DisplayName("formatTime方法测试 - 格式不匹配")
    void testFormatTime_FormatMismatch() {
        System.out.println();
        log.info("========== 时间格式化模块测试 - 格式不匹配 ==========");
        
        // 输入参数
        String inputTime = "2024 01-15";
        params.put("fromFormat", "yyyy/MM/dd");
        params.put("toFormat", "yyyy-MM-dd");
        
        log.info("输入参数:");
        log.info("  - 时间字符串: {}", inputTime);
        log.info("  - 源格式: {}", params.get("fromFormat"));
        log.info("  - 目标格式: {}", params.get("toFormat"));
        log.info("  - 注意: 时间字符串格式与源格式不匹配");
        
        // 预期结果
        log.info("预期结果: 非空结果（输出原值）");
        
        // 执行测试
        Object result = FormatUtil.formatTime(inputTime, params);
        
        // 实际结果
        log.info("实际结果: {}", result);
        
        // 断言验证
        assertNotNull(result);
        log.info("✓ 测试通过 - 格式不匹配处理正确");
    }
    
    /**
     * 测试extractTimeRange方法 - 正常时间范围提取
     * 
     * <p><b>测试目的：</b>验证extractTimeRange方法能够正确提取时间范围</p>
     * <p><b>测试场景：</b>从时间范围字符串中提取开始时间</p>
     * <p><b>预期结果：</b>正确提取开始时间</p>
     */
    @Test
    @DisplayName("extractTimeRange方法测试 - 正常提取开始时间 - 【已验证】")
    void testExtractTimeRange_ExtractStartTime() {
        System.out.println();
        log.info("========== 时间范围提取模块测试 - 正常提取开始时间 ==========");
        
        // 输入参数
        String inputTimeRange = "2024-01-15 14:30:25 ~ 2024-01-15 16:45:30";
        params.put("type", "start");
        
        log.info("输入参数:");
        log.info("  - 时间范围字符串: {}", inputTimeRange);
        log.info("  - 提取类型: {}", params.get("type"));

        // 执行测试
        Object result = FormatUtil.extractTimeRange(inputTimeRange, params);

        // 断言验证
        String expectedResult = "2024-01-15 14:30:25";
        log.info("预期结果：'{}'", expectedResult);
        log.info("实际结果：'{}'", result);
        assertEquals(expectedResult, result);
        log.info("✓ 测试通过 - 开始时间提取正确");
    }
    
    /**
     * 测试extractTimeRange方法 - 边界情况：无分隔符
     * 
     * <p><b>测试目的：</b>验证extractTimeRange方法对无分隔符情况的处理</p>
     * <p><b>测试场景：</b>时间范围字符串中无分隔符</p>
     * <p><b>预期结果：</b>返回原始字符串</p>
     */
    @Test
    @DisplayName("extractTimeRange方法测试 - 无分隔符处理 - 【已验证】")
    void testExtractTimeRange_NoSeparator() {
        System.out.println();
        log.info("========== 时间范围提取模块测试 - 无分隔符处理 ==========");
        
        // 输入参数
        String inputTimeRange = "2024-01-15 14:30:25";
        params.put("type", "start");
        
        log.info("输入参数:");
        log.info("  - 时间范围字符串: {}", inputTimeRange);
        log.info("  - 提取类型: {}", params.get("type"));
        log.info("  - 注意: 时间范围字符串中无分隔符");
        
        // 预期结果
        log.info("预期结果: 非空结果（原始字符串或错误信息）");
        
        // 执行测试
        Object result = FormatUtil.extractTimeRange(inputTimeRange, params);

        // 断言验证
        String expectedResult = "2024-01-15 14:30:25";
        log.info("预期结果: '{}'", expectedResult);
        log.info("实际结果: '{}'", result);
        assertNotNull(result);
        assertEquals(expectedResult, result);

        log.info("✓ 测试通过 - 无分隔符处理正确");
    }
    
    /**
     * 测试dynamicTimeFormat方法 - 标准格式识别
     * 
     * <p><b>测试目的：</b>验证dynamicTimeFormat方法能够识别标准时间格式</p>
     * <p><b>测试场景：</b>输入标准ISO格式时间</p>
     * <p><b>预计结果：</b>正确识别并转换为目标格式</p>
     */
    @Test
    @DisplayName("dynamicTimeFormat方法测试 - 标准格式识别")
    void testDynamicTimeFormat_StandardFormat() {
        System.out.println();
        log.info("========== 动态时间格式化模块测试 - 标准格式识别 ==========");
        
        // 输入参数
        String inputTime = "2024-01-15T14:30:25Z";
        params.put("targetFormat", "yyyy-MM-dd HH:mm:ss");
        
        log.info("输入参数:");
        log.info("  - 时间字符串: {}", inputTime);
        log.info("  - 目标格式: {}", params.get("targetFormat"));
        
        // 预期结果
        String expectedResult = "2024-01-15 14:30:25";
        log.info("预期结果: {}", expectedResult);
        
        // 执行测试
        Object result = FormatUtil.dynamicTimeFormat(inputTime, params);
        
        // 实际结果
        log.info("实际结果: {}", result);
        
        // 断言验证
        assertEquals(expectedResult, result);
        log.info("✓ 测试通过 - 标准格式识别正确");
    }
    
    /**
     * 测试dynamicTimeFormat方法 - 中文格式识别
     * 
     * <p><b>测试目的：</b>验证dynamicTimeFormat方法能够识别中文时间格式</p>
     * <p><b>测试场景：</b>输入中文格式时间</p>
     * <p><b>预计结果：</b>正确识别并转换为目标格式</p>
     */
    @Test
    @DisplayName("dynamicTimeFormat方法测试 - 中文格式识别")
    void testDynamicTimeFormat_ChineseFormat() {
        System.out.println();
        log.info("========== 动态时间格式化模块测试 - 中文格式识别 ==========");
        
        // 输入参数
        String inputTime = "2024年01月15日 14时30分25秒";
        params.put("targetFormat", "yyyy-MM-dd HH:mm:ss");
        
        log.info("输入参数:");
        log.info("  - 时间字符串: {}", inputTime);
        log.info("  - 目标格式: {}", params.get("targetFormat"));
        
        // 预期结果
        String expectedResult = "2024-01-15 14:30:25";
        log.info("预期结果: {}", expectedResult);
        
        // 执行测试
        Object result = FormatUtil.dynamicTimeFormat(inputTime, params);
        
        // 实际结果
        log.info("实际结果: {}", result);
        
        // 断言验证
        assertEquals(expectedResult, result);
        log.info("✓ 测试通过 - 中文格式识别正确");
    }
    
    /**
     * 测试validateTimeFormat方法 - 格式验证通过
     * 
     * <p><b>测试目的：</b>验证validateTimeFormat方法能够正确验证时间格式</p>
     * <p><b>测试场景：</b>时间字符串符合指定格式</p>
     * <p><b>预计结果：</b>返回true</p>
     */
    @Test
    @DisplayName("validateTimeFormat方法测试 - 格式验证通过")
    void testValidateTimeFormat_ValidFormat() {
        System.out.println();
        log.info("========== 时间格式验证模块测试 - 格式验证通过 ==========");
        
        // 输入参数
        String inputTime = "2024-01-15 14:30:25";
        String format = "yyyy-MM-dd HH:mm:ss";
        params.put("format", format);
        
        log.info("输入参数:");
        log.info("  - 时间字符串: {}", inputTime);
        log.info("  - 验证格式: {}", format);
        
        // 预期结果
        boolean expectedResult = true;
        log.info("预期结果: {}", expectedResult);
        
        // 执行测试
        Object result = FormatUtil.validateTimeFormat(inputTime, String.valueOf(params.get("format")));
        
        // 实际结果
        log.info("实际结果: {}", result);
        
        // 断言验证
        assertEquals(expectedResult, result);
        log.info("✓ 测试通过 - 格式验证正确");
    }
    
    /**
     * 测试validateTimeFormat方法 - 格式验证失败
     * 
     * <p><b>测试目的：</b>验证validateTimeFormat方法能够检测格式错误</p>
     * <p><b>测试场景：</b>时间字符串不符合指定格式</p>
     * <p><b>预计结果：</b>返回false</p>
     */
    @Test
    @DisplayName("validateTimeFormat方法测试 - 格式验证失败")
    void testValidateTimeFormat_InvalidFormat() {
        System.out.println();
        log.info("========== 时间格式验证模块测试 - 格式验证失败 ==========");
        
        // 输入参数
        String inputTime = "2024/01/15 14:30:25";
        String format = "yyyy-MM-dd HH:mm:ss";
        params.put("format", format);
        
        log.info("输入参数:");
        log.info("  - 时间字符串: {}", inputTime);
        log.info("  - 验证格式: {}", format);
        log.info("  - 注意: 时间字符串格式与验证格式不匹配");
        
        // 预期结果
        boolean expectedResult = false;
        log.info("预期结果: {}", expectedResult);
        
        // 执行测试
        Object result = FormatUtil.validateTimeFormat(inputTime, String.valueOf(params.get("format")));
        
        // 实际结果
        log.info("实际结果: {}", result);
        
        // 断言验证
        assertEquals(expectedResult, result);
        log.info("✓ 测试通过 - 格式验证失败检测正确");
    }
    
    // ==================== 字符串处理模块测试 ====================
    
    /**
     * 测试substring方法 - 正常字符串截取
     * 
     * <p><b>测试目的：</b>验证substring方法能够正确截取字符串</p>
     * <p><b>测试场景：</b>按起始位置和长度截取字符串</p>
     * <p><b>预计结果：</b>截取结果正确</p>
     */
    @Test
    @DisplayName("substring方法测试 - 正常截取")
    void testSubstring_NormalCase() {
        System.out.println();
        log.info("========== 字符串截取模块测试 - 正常截取 ==========");
        
        // 输入参数
        String inputString = "Hello World";
        int start = 6;
        int length = 5;
        params.put("start", start);
        params.put("length", length);
        
        log.info("输入参数:");
        log.info("  - 输入字符串: {}", inputString);
        log.info("  - 起始位置: {}", start);
        log.info("  - 截取长度: {}", length);
        
        // 预期结果
        String expectedResult = "World";
        log.info("预期结果: {}", expectedResult);
        
        // 执行测试
        Object result = FormatUtil.substring(inputString, params);
        
        // 实际结果
        log.info("实际结果: {}", result);
        
        // 断言验证
        assertEquals(expectedResult, result);
        log.info("✓ 测试通过 - 字符串截取正确");
    }
    
    /**
     * 测试substring方法 - 边界情况：起始位置超出范围
     * 
     * <p><b>测试目的：</b>验证substring方法对起始位置超界的处理</p>
     * <p><b>测试场景：</b>起始位置大于字符串长度</p>
     * <p><b>预计结果：</b>返回空字符串或错误信息</p>
     */
    @Test
    @DisplayName("substring方法测试 - 起始位置超界")
    void testSubstring_StartOutOfBounds() {
        System.out.println();
        log.info("========== 字符串截取模块测试 - 起始位置超界 ==========");
        
        // 输入参数
        String inputString = "Hello";
        int start = 10;
        int length = 5;
        params.put("start", start);
        params.put("length", length);
        
        log.info("输入参数:");
        log.info("  - 输入字符串: {}", inputString);
        log.info("  - 起始位置: {}", start);
        log.info("  - 截取长度: {}", length);
        log.info("  - 注意: 起始位置大于字符串长度");
        
        // 预期结果
        log.info("预期结果: 非空结果（空字符串或错误信息）");
        
        // 执行测试
        Object result = FormatUtil.substring(inputString, params);
        
        // 实际结果
        log.info("实际结果: {}", result);
        
        // 断言验证
        assertNotNull(result);
        log.info("✓ 测试通过 - 起始位置超界处理正确");
    }
    
    /**
     * 测试regexReplace方法 - 正则表达式替换
     * 
     * <p><b>测试目的：</b>验证regexReplace方法能够正确进行正则替换</p>
     * <p><b>测试场景：</b>替换字符串中的数字</p>
     * <p><b>预计结果：</b>替换结果正确</p>
     */
    @Test
    @DisplayName("regexReplace方法测试 - 正则替换 - 【已验证】")
    void testRegexReplace_NormalCase() {
        System.out.println();
        log.info("========== 正则表达式替换模块测试 - 正则替换 ==========");
        
        // 输入参数
        String inputString = "abc123def456";
        String regex = "\\d+";
        String replacement = "*";
        params.put("pattern", regex);
        params.put("replacement", replacement);
        
        log.info("输入参数:");
        log.info("  - 输入字符串: {}", inputString);
        log.info("  - 正则表达式: {}", regex);
        log.info("  - 替换字符串: {}", replacement);

        // 执行测试
        Object result = FormatUtil.regexReplace(inputString, params);

        // 断言验证
        String expectedResult = "abc*def*";
        log.info("预期结果: {}", expectedResult);
        log.info("实际结果: {}", result);
        assertEquals(expectedResult, result);
        log.info("✓ 测试通过 - 正则替换正确");
    }

    /**
     * 测试regexReplace方法 - 正则表达式替换
     *
     * <p><b>测试目的：</b>验证regexReplace方法能够正确进行正则替换</p>
     * <p><b>测试场景：</b>替换字符串中的数字</p>
     * <p><b>预计结果：</b>替换结果正确</p>
     */
    @Test
    @DisplayName("regexReplace方法测试 - 三种测试 - 【已验证】")
    void testRegexReplace_NormalCase3() {
        System.out.println();
        log.info("========== 正则表达式替换模块测试 - 正则替换 ==========");

        // 输入参数
        String inputString = "abc123def456";
        String regex = "\\d+";
        String replacement = "*";
        params.put("pattern", regex);
        params.put("replacement", replacement);


        // 测试用例1：数字替换
        Map<String, Object> params1 = new HashMap<>();
        params1.put("pattern", "\\d+");
        params1.put("replacement", "*");
        String result1 = FormatUtil.regexReplace("abc123def456", params1);
        log.info("实际结果 (1): " + result1);
        // 断言验证
        String expectedResult1 = "abc*def*";
        log.info("预期结果：'{}'", expectedResult1);
        log.info("实际结果：'{}'", result1);
        assertEquals(expectedResult1, result1);

        // 测试用例2：分组引用替换
        Map<String, Object> params2 = new HashMap<>();
        params2.put("pattern", "(\\d+)-(\\d+)");
        params2.put("replacement", "$2到$1");
        String result2 = FormatUtil.regexReplace("电话: 123-456", params2);
        log.info("实际结果 (2): " + result2);
        // 断言验证
        String expectedResult2 = "电话: 456到123";
        log.info("预期结果：'{}'", expectedResult2);
        log.info("实际结果：'{}'", result2);
        assertEquals(expectedResult2, result2);

        // 测试用例3：大小写不敏感
        Map<String, Object> params3 = new HashMap<>();
        params3.put("pattern", "hello");
        params3.put("replacement", "HI");
        params3.put("flags", "CASE_INSENSITIVE");
        String result3 = FormatUtil.regexReplace("Hello World", params3);
        log.info("实际结果 (3): " + result3);
        // 断言验证
        String expectedResult3 = "HI World";
        log.info("预期结果：'{}'", expectedResult3);
        log.info("实际结果：'{}'", result3);
        assertEquals(expectedResult3, result3);
        log.info("✓ 测试通过 - 正则替换正确");
    }
    
    /**
     * 测试toUpperCase方法 - 大小写转换
     * 
     * <p><b>测试目的：</b>验证toUpperCase方法能够正确转换为大写</p>
     * <p><b>测试场景：</b>小写字符串转大写</p>
     * <p><b>预计结果：</b>转换结果正确</p>
     */
    @Test
    @DisplayName("toUpperCase方法测试 - 大小写转换")
    void testToUpperCase_NormalCase() {
        System.out.println();
        log.info("========== 字符串大小写转换模块测试 - 大小写转换 ==========");
        
        // 输入参数
        String inputString = "hello world";
        
        log.info("输入参数:");
        log.info("  - 输入字符串: {}", inputString);
        
        // 预期结果
        String expectedResult = "HELLO WORLD";
        log.info("预期结果: {}", expectedResult);
        
        // 执行测试
        Object result = FormatUtil.toUpperCase(inputString, params);
        
        // 实际结果
        log.info("实际结果: {}", result);
        
        // 断言验证
        assertEquals(expectedResult, result);
        log.info("✓ 测试通过 - 大小写转换正确");
    }
    
    /**
     * 测试trim方法 - 去除空格
     * 
     * <p><b>测试目的：</b>验证trim方法能够正确去除首尾空格</p>
     * <p><b>测试场景：</b>字符串前后有空格</p>
     * <p><b>预计结果：</b>去除空格后结果正确</p>
     */
    @Test
    @DisplayName("trim方法测试 - 去除空格 - 【已验证】")
    void testTrim_NormalCase() {
        System.out.println();
        log.info("========== 字符串空格处理模块测试 - 去除空格 ==========");
        
        // 输入参数
        String inputString = "  hello world  ";
        
        log.info("输入参数:");
        log.info("  - 输入字符串: '{}'", inputString);
        log.info("  - 注意: 字符串前后有空格");

        // 执行测试
        Object result = FormatUtil.trim(inputString, params);

        // 断言验证
        String expectedResult = "hello world";
        log.info("预期结果: '{}'", expectedResult);
        log.info("实际结果: '{}'", result);
        assertEquals(expectedResult, result);
        log.info("✓ 测试通过 - 空格去除正确");
    }
    
    /**
     * 测试stealBeamsAndReplacePillars方法 - 基础字符串替换
     * 
     * <p><b>测试目的：</b>验证stealBeamsAndReplacePillars方法能够正确进行字符串替换</p>
     * <p><b>测试场景：</b>使用基础替换功能</p>
     * <p><b>预计结果：</b>替换结果正确</p>
     */
    @Test
    @DisplayName("stealBeamsAndReplacePillars方法测试 - 基础替换")
    void testStealBeamsAndReplacePillars_BasicReplacement() {
        System.out.println();
        log.info("========== 字符串替换模块测试 - 基础替换 ==========");
        
        // 输入参数
        String inputString = "hello world";
        Map<String, String> replacementMap = new HashMap<>();
        replacementMap.put("hello", "hi");
        replacementMap.put("world", "universe");
        
        log.info("输入参数:");
        log.info("  - 输入字符串: {}", inputString);
        log.info("  - 替换映射: {}", replacementMap);
        
        // 预期结果
        String expectedResult = "hi universe";
        log.info("预期结果: {}", expectedResult);
        
        // 执行测试
        String result = FormatUtil.stealBeamsAndReplacePillars(inputString, replacementMap);
        
        // 实际结果
        log.info("实际结果: {}", result);
        
        // 断言验证
        assertEquals(expectedResult, result);
        log.info("✓ 测试通过 - 基础字符串替换正确");
    }
    
    /**
     * 测试stealBeamsAndReplacePillars方法 - 大小写敏感替换
     * 
     * <p><b>测试目的：</b>验证stealBeamsAndReplacePillars方法的大小写敏感功能</p>
     * <p><b>测试场景：</b>大小写敏感模式下的替换</p>
     * <p><b>预计结果：</b>大小写敏感替换结果正确</p>
     */
    @Test
    @DisplayName("stealBeamsAndReplacePillars方法测试 - 大小写敏感 - 【已验证】")
    void testStealBeamsAndReplacePillars_CaseSensitive() {
        System.out.println();
        log.info("========== 字符串替换模块测试 - 大小写敏感替换 ==========");
        
        // 输入参数
        String inputString = "hello world";
        Map<String, String> replacementMap = new HashMap<>();
        replacementMap.put("Hello", "Hi");
        replacementMap.put("world", "universe");
        boolean caseSensitive = true;
        
        log.info("输入参数:");
        log.info("  - 输入字符串: {}", inputString);
        log.info("  - 替换映射: {}", JSON.toJSONString(replacementMap));
        log.info("  - 大小写敏感: {}", caseSensitive);
        log.info("  - 注意: 'Hello'与'hello'大小写不匹配");

        // 执行测试
        String result = FormatUtil.stealBeamsAndReplacePillars(inputString, replacementMap, caseSensitive);

        // 断言验证
        String expectedResult = "hello universe";
        log.info("预期结果：'{}'", expectedResult);
        log.info("实际结果：'{}'", result);
        assertEquals(expectedResult, result);
        log.info("✓ 测试通过 - 大小写敏感替换正确");
    }
    
    /**
     * 测试stealBeamsAndReplacePillars方法 - 整词匹配替换
     * 
     * <p><b>测试目的：</b>验证stealBeamsAndReplacePillars方法的整词匹配功能</p>
     * <p><b>测试场景：</b>整词匹配模式下的替换</p>
     * <p><b>预计结果：</b>整词匹配替换结果正确</p>
     */
    @Test
    @DisplayName("stealBeamsAndReplacePillars方法测试 - 整词匹配")
    void testStealBeamsAndReplacePillars_WholeWord() {
        System.out.println();
        log.info("========== 字符串替换模块测试 - 整词匹配替换 ==========");
        
        // 输入参数
        String inputString = "category cat catfish";
        Map<String, String> replacementMap = new HashMap<>();
        replacementMap.put("cat", "dog");
        boolean caseSensitive = false;
        boolean wholeWord = true;
        
        log.info("输入参数:");
        log.info("  - 输入字符串: {}", inputString);
        log.info("  - 替换映射: {}", replacementMap);
        log.info("  - 大小写敏感: {}", caseSensitive);
        log.info("  - 整词匹配: {}", wholeWord);
        log.info("  - 注意: 只有独立的'cat'会被替换");
        
        // 预期结果
        String expectedResult = "category dog catfish";
        log.info("预期结果: {}", expectedResult);
        
        // 执行测试
        String result = FormatUtil.stealBeamsAndReplacePillars(inputString, replacementMap, caseSensitive, wholeWord);
        
        // 实际结果
        log.info("实际结果: {}", result);
        
        // 断言验证
        assertEquals(expectedResult, result);
        log.info("✓ 测试通过 - 整词匹配替换正确");
    }
    
    // ==================== 坐标系转换模块测试 ====================
    
    /**
     * 测试coordinateConvert方法 - 度分秒转十进制
     * 
     * <p><b>测试目的：</b>验证coordinateConvert方法能够正确转换度分秒为十进制</p>
     * <p><b>测试场景：</b>度分秒格式坐标转十进制</p>
     * <p><b>预计结果：</b>转换结果正确</p>
     */
    @Test
    @DisplayName("coordinateConvert方法测试 - 度分秒转十进制")
    void testCoordinateConvert_DmsToDecimal() {
        System.out.println();
        log.info("========== 坐标系转换模块测试 - 度分秒转十进制 ==========");
        
        // 输入参数
        String coordinate = "116°23'45.67\"";
        params.put("fromType", "dms");
        params.put("toType", "decimal");
        
        log.info("输入参数:");
        log.info("  - 坐标值: {}", coordinate);
        log.info("  - 源格式: {}", params.get("fromType"));
        log.info("  - 目标格式: {}", params.get("toType"));
        log.info("  - 注意: 116°23'45.67\" ≈ 116.396019");
        
        // 预期结果
        log.info("预期结果: 非空转换结果");
        
        // 执行测试
        Object result = FormatUtil.coordinateConvert(coordinate, params);
        
        // 实际结果
        log.info("实际结果: {}", result);
        
        // 断言验证
        assertNotNull(result);
        log.info("✓ 测试通过 - 度分秒转十进制转换正确");
    }
    
    /**
     * 测试coordinateConvert方法 - 十进制转度分秒
     * 
     * <p><b>测试目的：</b>验证coordinateConvert方法能够正确转换十进制为度分秒</p>
     * <p><b>测试场景：</b>十进制坐标转度分秒格式</p>
     * <p><b>预计结果：</b>转换结果正确</p>
     */
    @Test
    @DisplayName("coordinateConvert方法测试 - 十进制转度分秒 - 【已验证】")
    void testCoordinateConvert_DecimalToDms() {
        System.out.println();
        log.info("========== 坐标系转换模块测试 - 十进制转度分秒 ==========");
        
        // 输入参数
        String coordinate = "116.396019";
        params.put("fromFormat", "decimal");
        params.put("toFormat", "dms");
        params.put("precision", "2");

        log.info("输入参数:");
        log.info("  - 坐标值: {}", coordinate);
        log.info("  - 源格式: {}", params.get("fromFormat"));
        log.info("  - 目标格式: {}", params.get("toFormat"));
        log.info("  - 注意: 116.396019 ≈ 116°23'45.67\"");

        // 执行测试
        Object result = FormatUtil.coordinateConvert(coordinate, params);

        // 断言验证
        String expectedResult = "116°23'45.67\"";
        log.info("预期结果：'{}'", expectedResult);
        log.info("实际结果：'{}'", result);
        assertEquals(expectedResult, result);
        log.info("✓ 测试通过 - 十进制转度分秒转换正确");
    }
    
    /**
     * 测试cartesianConvert方法 - 直角坐标转极坐标
     * 
     * <p><b>测试目的：</b>验证cartesianConvert方法能够正确转换直角坐标为极坐标</p>
     * <p><b>测试场景：</b>直角坐标(x,y)转极坐标(r,θ)</p>
     * <p><b>预计结果：</b>转换结果正确</p>
     */
    @Test
    @DisplayName("cartesianConvert方法测试 - 直角坐标转极坐标")
    void testCartesianConvert_RectangularToPolar() {
        System.out.println();
        log.info("========== 坐标系转换模块测试 - 直角坐标转极坐标 ==========");
        
        // 输入参数
        String coordinate = "3,4";
        params.put("x", 3);
        params.put("y", 4);
        params.put("fromType", "rectangular");
        params.put("toType", "polar");
        
        log.info("输入参数:");
        log.info("  - 坐标值: {}", coordinate);
        log.info("  - x坐标: {}", params.get("x"));
        log.info("  - y坐标: {}", params.get("y"));
        log.info("  - 源格式: {}", params.get("fromType"));
        log.info("  - 目标格式: {}", params.get("toType"));
        log.info("  - 注意: (3,4) → r=5, θ≈53.13°");
        
        // 预期结果
        log.info("预期结果: 非空转换结果");
        
        // 执行测试
        Object result = FormatUtil.cartesianConvert(coordinate, params);
        
        // 实际结果
        log.info("实际结果: {}", result);
        
        // 断言验证
        assertNotNull(result);
        log.info("✓ 测试通过 - 直角坐标转极坐标转换正确");
    }
    
    /**
     * 测试normalizeCoordinate方法 - 坐标格式标准化
     * 
     * <p><b>测试目的：</b>验证normalizeCoordinate方法能够标准化坐标格式</p>
     * <p><b>测试场景：</b>统一不同格式的坐标表示</p>
     * <p><b>预计结果：</b>标准化结果正确</p>
     */
    @Test
    @DisplayName("normalizeCoordinate方法测试 - 坐标标准化")
    void testNormalizeCoordinate_NormalCase() {
        System.out.println();
        log.info("========== 坐标系转换模块测试 - 坐标格式标准化 ==========");
        
        // 输入参数
        String coordinate = "116.396019,39.909604";
        params.put("format", "decimal");
        
        log.info("输入参数:");
        log.info("  - 坐标值: {}", coordinate);
        log.info("  - 目标格式: {}", params.get("format"));
        
        // 预期结果
        log.info("预期结果: 非空标准化结果");
        
        // 执行测试
        Object result = FormatUtil.normalizeCoordinate(coordinate, params);
        
        // 实际结果
        log.info("实际结果: {}", result);
        
        // 断言验证
        assertNotNull(result);
        log.info("✓ 测试通过 - 坐标格式标准化正确");
    }
    
    // ==================== 极值/边界值检查处理模块测试 ====================
    
    /**
     * 测试boundaryCheck方法 - 正常范围检查
     * 
     * <p><b>测试目的：</b>验证boundaryCheck方法能够正确检查数值范围</p>
     * <p><b>测试场景：</b>数值在有效范围内</p>
     * <p><b>预计结果：</b>返回原始值</p>
     */
    @Test
    @DisplayName("boundaryCheck方法测试 - 正常范围检查")
    void testBoundaryCheck_WithinRange() {
        System.out.println();
        log.info("========== 极值检查模块测试 - 正常范围检查 ==========");
        
        // 输入参数
        int inputValue = 50;
        params.put("min", 0);
        params.put("max", 100);
        params.put("strategy", "truncate");
        
        log.info("输入参数:");
        log.info("  - 输入值: {}", inputValue);
        log.info("  - 最小值: {}", params.get("min"));
        log.info("  - 最大值: {}", params.get("max"));
        log.info("  - 处理策略: {}", params.get("strategy"));
        
        // 预期结果
        int expectedResult = 50;
        log.info("预期结果: {}", expectedResult);
        
        // 执行测试
        Object result = FormatUtil.boundaryCheck(inputValue, params);
        
        // 实际结果
        log.info("实际结果: {}", result);
        
        // 断言验证
        assertEquals(expectedResult, result);
        log.info("✓ 测试通过 - 正常范围检查正确");
    }
    
    /**
     * 测试boundaryCheck方法 - 超出上限处理
     * 
     * <p><b>测试目的：</b>验证boundaryCheck方法对超出上限的处理</p>
     * <p><b>测试场景：</b>数值大于最大值，使用截断策略</p>
     * <p><b>预计结果：</b>返回最大值</p>
     */
    @Test
    @DisplayName("boundaryCheck方法测试 - 超出上限截断")
    void testBoundaryCheck_AboveMaxTruncate() {
        System.out.println();
        log.info("========== 极值检查模块测试 - 超出上限截断处理 ==========");
        
        // 输入参数
        int inputValue = 150;
        params.put("min", 0);
        params.put("max", 100);
        params.put("strategy", "truncate");
        
        log.info("输入参数:");
        log.info("  - 输入值: {}", inputValue);
        log.info("  - 最小值: {}", params.get("min"));
        log.info("  - 最大值: {}", params.get("max"));
        log.info("  - 处理策略: {}", params.get("strategy"));
        log.info("  - 注意: 输入值150大于最大值100，应截断为100");
        
        // 预期结果
        int expectedResult = 100;
        log.info("预期结果: {}", expectedResult);
        
        // 执行测试
        Object result = FormatUtil.boundaryCheck(inputValue, params);
        
        // 实际结果
        log.info("实际结果: {}", result);
        
        // 断言验证
        assertEquals(expectedResult, result);
        log.info("✓ 测试通过 - 超出上限截断处理正确");
    }
    
    /**
     * 测试boundaryCheck方法 - 超出下限处理
     * 
     * <p><b>测试目的：</b>验证boundaryCheck方法对超出下限的处理</p>
     * <p><b>测试场景：</b>数值小于最小值，使用默认值策略</p>
     * <p><b>预计结果：</b>返回默认值</p>
     */
    @Test
    @DisplayName("boundaryCheck方法测试 - 超出下限默认值")
    void testBoundaryCheck_BelowMinDefault() {
        System.out.println();
        log.info("========== 极值检查模块测试 - 超出下限默认值处理 ==========");
        
        // 输入参数
        int inputValue = -10;
        params.put("min", 0);
        params.put("max", 100);
        params.put("strategy", "default");
        params.put("defaultValue", 0);
        
        log.info("输入参数:");
        log.info("  - 输入值: {}", inputValue);
        log.info("  - 最小值: {}", params.get("min"));
        log.info("  - 最大值: {}", params.get("max"));
        log.info("  - 处理策略: {}", params.get("strategy"));
        log.info("  - 默认值: {}", params.get("defaultValue"));
        log.info("  - 注意: 输入值-10小于最小值0，应返回默认值0");
        
        // 预期结果
        int expectedResult = 0;
        log.info("预期结果: {}", expectedResult);
        
        // 执行测试
        Object result = FormatUtil.boundaryCheck(inputValue, params);
        
        // 实际结果
        log.info("实际结果: {}", result);
        
        // 断言验证
        assertEquals(expectedResult, result);
        log.info("✓ 测试通过 - 超出下限默认值处理正确");
    }
    
    /**
     * 测试boundaryCheck方法 - 异常值检测
     * 
     * <p><b>测试目的：</b>验证boundaryCheck方法能够检测异常值</p>
     * <p><b>测试场景：</b>输入NaN值</p>
     * <p><b>预计结果：</b>返回错误信息或默认值</p>
     */
    @Test
    @DisplayName("boundaryCheck方法测试 - 异常值检测")
    void testBoundaryCheck_NaNValue() {
        System.out.println();
        log.info("========== 极值检查模块测试 - 异常值检测 ==========");
        
        // 输入参数
        double inputValue = Double.NaN;
        params.put("min", 0);
        params.put("max", 100);
        params.put("strategy", "error");
        
        log.info("输入参数:");
        log.info("  - 输入值: {}", inputValue);
        log.info("  - 最小值: {}", params.get("min"));
        log.info("  - 最大值: {}", params.get("max"));
        log.info("  - 处理策略: {}", params.get("strategy"));
        log.info("  - 注意: 输入值为NaN(Not a Number)");
        
        // 预期结果
        log.info("预期结果: 非空结果（错误信息或默认值）");
        
        // 执行测试
        Object result = FormatUtil.boundaryCheck(inputValue, params);
        
        // 实际结果
        log.info("实际结果: {}", result);
        
        // 断言验证
        assertNotNull(result);
        log.info("✓ 测试通过 - 异常值检测正确");
    }
    
    // ==================== 数据KV映射处理模块测试 ====================
    
    /**
     * 测试kvMapping方法 - 键值映射转换
     * 
     * <p><b>测试目的：</b>验证kvMapping方法能够正确进行键值映射</p>
     * <p><b>测试场景：</b>蛇形命名转驼峰命名</p>
     * <p><b>预计结果：</b>转换结果正确</p>
     */
    @Test
    @DisplayName("kvMapping方法测试 - 键名格式转换 - 【验证中】")
    void testKvMapping_KeyFormatConversion() {
        System.out.println();
        log.info("========== 数据KV映射模块测试 - 键名格式转换 ==========");
        
        // 输入参数
        Map<String, Object> inputMap = new HashMap<>();
        inputMap.put("user_name", "张三");
        inputMap.put("user_age", 25);
        params.put("keyFormat", "snake_to_camel");
        
        log.info("输入参数:");
        log.info("  - 输入Map: {}", inputMap);
        log.info("  - 键名格式转换: {}", params.get("keyFormat"));
        log.info("  - 注意: 蛇形命名(user_name)转驼峰命名(userName)");
        
        // 预期结果
        log.info("预期结果: 非空转换结果");
        
        // 执行测试
        Object result = FormatUtil.kvMapping(inputMap, params);
        
        // 实际结果
        log.info("实际结果: {}", result);
        
        // 断言验证
        assertNotNull(result);
        log.info("✓ 测试通过 - 键名格式转换正确");
    }
    
    /**
     * 测试kvMapping方法 - 数据过滤
     * 
     * <p><b>测试目的：</b>验证kvMapping方法能够正确过滤数据</p>
     * <p><b>测试场景：</b>过滤掉值为null的键值对</p>
     * <p><b>预计结果：</b>过滤结果正确</p>
     */
    @Test
    @DisplayName("kvMapping方法测试 - 数据过滤")
    void testKvMapping_DataFiltering() {
        System.out.println();
        log.info("========== 数据KV映射模块测试 - 数据过滤 ==========");
        
        // 输入参数
        Map<String, Object> inputMap = new LinkedHashMap<>();
        inputMap.put("name", "张三");
        inputMap.put("age", 25);
        inputMap.put("address", null);
        params.put("filter", "not_null");
        
        log.info("输入参数:");
        log.info("  - 输入Map: {}", inputMap);
        log.info("  - 过滤条件: {}", params.get("filter"));
        log.info("  - 注意: 过滤掉值为null的键值对");
        
        // 预期结果
        log.info("预期结果: 非空过滤结果");
        
        // 执行测试
        Object result = FormatUtil.kvMapping(inputMap, params);
        
        // 实际结果
        log.info("实际结果: {}", result);
        
        // 断言验证
        assertNotNull(result instanceof Map);
        if(result instanceof Map) {
            boolean flag = false;
        }
        log.info("✓ 测试通过 - 数据过滤正确");
    }
    
    /**
     * 测试kvMapping方法 - 分组排序
     * 
     * <p><b>测试目的：</b>验证kvMapping方法能够正确分组排序数据</p>
     * <p><b>测试场景：</b>按键名升序排序</p>
     * <p><b>预计结果：</b>排序结果正确</p>
     */
    @Test
    @DisplayName("kvMapping方法测试 - 分组排序 - 【已验证】")
    void testKvMapping_GroupingSorting() {
        System.out.println();
        log.info("========== 数据KV映射模块测试 - 分组排序 ==========");
        
        // 输入参数
        Map<String, Object> inputMap = new LinkedHashMap<>();
        inputMap.put("z_key", "value3");
        inputMap.put("a_key", "value1");
        inputMap.put("m_key", "value2");
        params.put("sort", "key_asc");
        
        log.info("输入参数:");
        log.info("  - 输入Map: {}", inputMap);
        log.info("  - 排序方式: {}", params.get("sort"));
        log.info("  - 注意: 按键名升序排序(a_key → m_key → z_key)");
        
        // 预期结果
        log.info("预期结果: 非空排序结果");
        
        // 执行测试
        Object result = FormatUtil.kvMapping(inputMap, params);
        
        // 实际结果
        log.info("实际结果: {}", result);
        
        // 断言验证
        Map<String, Object> expectedResult = new LinkedHashMap<>() {{
            put("a_key", "value1");
            put("m_key", "value2");
            put("z_key", "value3");
        }};
        String expectedResultString = JSON.toJSONString(expectedResult);
        String resultString = JSON.toJSONString(result);
        log.info("预期结果：'{}'", expectedResult);
        log.info("实际结果：'{}'", result);
        assertEquals(expectedResultString, resultString, "排序失败");
        log.info("✓ 测试通过 - 分组排序正确");
    }
    
    /**
     * 测试kvMapping方法 - 输出格式转换
     * 
     * <p><b>测试目的：</b>验证kvMapping方法能够正确转换输出格式</p>
     * <p><b>测试场景：</b>Map转JSON字符串</p>
     * <p><b>预计结果：</b>JSON格式正确</p>
     */
    @Test
    @DisplayName("kvMapping方法测试 - 输出格式转换")
    void testKvMapping_OutputFormat() {
        System.out.println();
        log.info("========== 数据KV映射模块测试 - 输出格式转换 ==========");
        
        // 输入参数
        Map<String, Object> inputMap = new HashMap<>();
        inputMap.put("name", "张三");
        inputMap.put("age", 25);
        params.put("outputFormat", "json");
        
        log.info("输入参数:");
        log.info("  - 输入Map: {}", inputMap);
        log.info("  - 输出格式: {}", params.get("outputFormat"));
        log.info("  - 注意: Map转换为JSON字符串格式");
        
        // 预期结果
        log.info("预期结果: JSON字符串包含'name'和'张三'字段");
        
        // 执行测试
        Object result = FormatUtil.kvMapping(inputMap, params);
        
        // 实际结果
        log.info("实际结果: {}", result);
        
        // 断言验证
        assertNotNull(result);
        assertTrue(result.toString().contains("name") && result.toString().contains("张三"));
        log.info("✓ 测试通过 - 输出格式转换正确");
    }
    
    // ==================== 综合测试用例 ====================
    
    /**
     * 综合测试 - 多方法组合使用
     * 
     * <p><b>测试目的：</b>验证多个方法组合使用的正确性</p>
     * <p><b>测试场景：</b>时间格式化后截取字符串，再进行边界检查</p>
     * <p><b>预计结果：</b>组合处理结果正确</p>
     */
    @Test
    @DisplayName("综合测试 - 多方法组合使用")
    void testMultipleMethods_CombinedUsage() {
        System.out.println();
        log.info("========== 综合测试 - 多方法组合使用 ==========");
        
        log.info("测试流程: 时间格式化 → 字符串截取 → 边界检查");
        
        // 第一步：时间格式化
        log.info("第一步 - 时间格式化:");
        Map<String, Object> timeParams = new HashMap<>();
        timeParams.put("fromFormat", "yyyy-MM-dd HH:mm:ss");
        timeParams.put("toFormat", "yyyy/MM/dd");
        String inputTime = "2024-01-15 14:30:25";
        log.info("  - 输入时间: {}", inputTime);
        log.info("  - 源格式: {}", timeParams.get("fromFormat"));
        log.info("  - 目标格式: {}", timeParams.get("toFormat"));
        
        String formattedTime = (String) FormatUtil.formatTime(inputTime, timeParams);
        log.info("  - 格式化结果: {}", formattedTime);
        
        // 第二步：字符串截取
        log.info("第二步 - 字符串截取:");
        Map<String, Object> substrParams = new HashMap<>();
        substrParams.put("start", 0);
        substrParams.put("length", 4);
        log.info("  - 输入字符串: {}", formattedTime);
        log.info("  - 起始位置: {}", substrParams.get("start"));
        log.info("  - 截取长度: {}", substrParams.get("length"));
        
        String year = (String) FormatUtil.substring(formattedTime, substrParams);
        log.info("  - 截取结果: {}", year);
        
        // 第三步：边界检查
        log.info("第三步 - 边界检查:");
        Map<String, Object> boundaryParams = new HashMap<>();
        boundaryParams.put("min", 2000);
        boundaryParams.put("max", 2100);
        boundaryParams.put("strategy", "truncate");
        log.info("  - 输入值: {}", year);
        log.info("  - 最小值: {}", boundaryParams.get("min"));
        log.info("  - 最大值: {}", boundaryParams.get("max"));
        log.info("  - 处理策略: {}", boundaryParams.get("strategy"));
        
        Object checkedValue = FormatUtil.boundaryCheck(Integer.parseInt(year), boundaryParams);
        log.info("  - 边界检查结果: {}", checkedValue);
        
        // 预期结果
        int expectedResult = 2024;
        log.info("预期结果: {}", expectedResult);
        
        // 断言验证
        assertEquals(expectedResult, checkedValue);
        log.info("✓ 测试通过 - 多方法组合使用正确");
    }
    
    /**
     * 性能测试 - 大量数据处理
     * 
     * <p><b>测试目的：</b>验证方法在处理大量数据时的性能表现</p>
     * <p><b>测试场景：</b>对1000个坐标进行批量转换</p>
     * <p><b>预计结果：</b>所有转换正确完成</p>
     */
    @Test
    @DisplayName("性能测试 - 大量数据处理")
    void testPerformance_LargeDataProcessing() {
        System.out.println();
        log.info("========== 性能测试 - 大量数据处理 ==========");
        
        // 输入参数
        int testCount = 1000;
        log.info("输入参数:");
        log.info("  - 测试数据量: {} 个坐标转换", testCount);
        log.info("  - 源格式: dms");
        log.info("  - 目标格式: decimal");
        log.info("  - 坐标模式: 116.0°23'45.67\" ~ 116.999°23'45.67\"");
        log.info("  - 性能要求: 处理时间 < 5000 ms");
        
        // 开始性能测试
        long startTime = System.currentTimeMillis();
        log.info("开始性能测试...");
        
        for (int i = 0; i < testCount; i++) {
            Map<String, Object> coordParams = new HashMap<>();
            coordParams.put("fromType", "dms");
            coordParams.put("toType", "decimal");
            
            Object result = FormatUtil.coordinateConvert("116." + i + "°23'45.67\"", coordParams);
            assertNotNull(result);
        }
        
        long endTime = System.currentTimeMillis();
        long duration = endTime - startTime;
        
        // 实际结果
        log.info("性能测试结果:");
        log.info("  - 开始时间: {} ms", startTime);
        log.info("  - 结束时间: {} ms", endTime);
        log.info("  - 总耗时: {} ms", duration);
        log.info("  - 平均每个转换耗时: {} ms", (double)duration / testCount);
        
        // 预期结果
        log.info("预期结果: 处理时间 < 5000 ms");
        
        // 断言验证
        assertTrue(duration < 5000, "性能测试应在5秒内完成");
        log.info("✓ 测试通过 - 性能表现符合要求");
    }
    
    /**
     * 默认参数值
     * 
     * <p><b>测试目的：</b>验证方法对无效参数组合的容错能力</p>
     * <p><b>测试场景：</b>提供相互冲突的参数</p>
     * <p><b>预计结果：</b>返回合理的默认值</p>
     */
    @Test
    @DisplayName("formatTime - 默认参数值 - 【已验证】")
    void testErrorHandling_InvalidParameterCombination() {
        System.out.println();
        log.info("========== 默认参数值 ==========");
        
        // 输入参数
        String inputTime = "2024-01-15";
        params.put("fromFormat", "yyyy-MM-dd");
        params.put("toFormat", "HH:mm:ss");
        
        log.info("输入参数:");
        log.info("  - 输入时间: {}", inputTime);
        log.info("  - 源格式: {}", params.get("fromFormat"));
        log.info("  - 目标格式: {}", params.get("toFormat"));
        log.info("  - 注意: 日期格式到时间格式的无效转换");
        
        // 预期结果
        log.info("预期结果: 返回默认值");
        
        // 执行测试
        Object result = FormatUtil.formatTime(inputTime, params);

        // 断言验证
        String expectedResult = "00:00:00";
        log.info("预期结果: {}", expectedResult);
        log.info("实际结果: {}", result);
        assertEquals(expectedResult, result);
        log.info("✓ 测试通过 - 异常处理正确");
    }
    
    /**
     * 边界值测试 - 极值输入
     * 
     * <p><b>测试目的：</b>验证方法对极值输入的处理能力</p>
     * <p><b>测试场景：</b>输入极大/极小值</p>
     * <p><b>预计结果：</b>正确处理或返回错误信息</p>
     */
    @Test
    @DisplayName("边界值测试 - 极值输入")
    void testBoundaryValues_ExtremeInputs() {
        System.out.println();
        log.info("========== 边界值测试 - 极值输入 ==========");
        
        // 输入参数
        double inputValue = Double.MAX_VALUE;
        params.put("min", 0);
        params.put("max", 100);
        params.put("strategy", "error");
        
        log.info("输入参数:");
        log.info("  - 输入值: {} (Double.MAX_VALUE)", inputValue);
        log.info("  - 最小值: {}", params.get("min"));
        log.info("  - 最大值: {}", params.get("max"));
        log.info("  - 处理策略: {}", params.get("strategy"));
        log.info("  - 注意: 极大值超出正常范围");
        
        // 预期结果
        log.info("预期结果: 正确处理或返回错误信息");
        
        // 执行测试
        Object result = FormatUtil.boundaryCheck(inputValue, params);
        
        // 实际结果
        log.info("实际结果: {}", result);
        
        // 断言验证
        assertNotNull(result);
        log.info("✓ 测试通过 - 边界值处理正确");
    }
}