From 11586563a7483148fb31d7c224dedcdbbcfacd9f Mon Sep 17 00:00:00 2001
From: yuejiajun <1530620364@qq.com>
Date: Sun, 28 Sep 2025 15:26:09 +0800
Subject: [PATCH] =?UTF-8?q?=E6=B5=8B=E8=AF=95=E7=B1=BB?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../java/com/example/demo/FormatUtilTest.java | 174 ++++++++++--------
 1 file changed, 96 insertions(+), 78 deletions(-)

diff --git a/src/test/java/com/example/demo/FormatUtilTest.java b/src/test/java/com/example/demo/FormatUtilTest.java
index ad1afcd..0731bed 100644
--- a/src/test/java/com/example/demo/FormatUtilTest.java
+++ b/src/test/java/com/example/demo/FormatUtilTest.java
@@ -74,7 +74,7 @@ public class FormatUtilTest {
      * <p><b>预期结果：</b>转换后的时间格式正确</p>
      */
     @Test
-    @DisplayName("formatTime方法测试 - 正常格式转换 - 【已验证】")
+    @DisplayName("formatTime - 时间，正常格式转换 - 【已验证】")
     void testFormatTime_NormalConversion() {
         System.out.println();
         log.info("========== 时间格式化模块测试 - 正常格式转换 ==========");
@@ -83,20 +83,18 @@ public class FormatUtilTest {
         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);
+        log.info("预期结果: '{}'", expectedResult);
+        log.info("实际结果: '{}'", result);
         assertEquals(expectedResult, result);
+
         log.info("✓ 测试通过 - 格式转换结果正确");
     }
     
@@ -105,10 +103,10 @@ public class FormatUtilTest {
      * 
      * <p><b>测试目的：</b>验证formatTime方法对空值的容错处理</p>
      * <p><b>测试场景：</b>输入时间为空字符串</p>
-     * <p><b>预期结果：</b>返回空字符串或默认值</p>
+     * <p><b>预期结果：</b>返回空字符串</p>
      */
     @Test
-    @DisplayName("formatTime方法测试 - 空值处理 - 【已验证】")
+    @DisplayName("formatTime - 需要格式化时间的获取到空串 - 【已验证】")
     void testFormatTime_EmptyInput() {
         System.out.println();
         log.info("========== 时间格式化模块测试 - 空值处理 ==========");
@@ -117,21 +115,19 @@ public class FormatUtilTest {
         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("✓ 测试通过 - 空值处理正确");
     }
     
@@ -143,7 +139,7 @@ public class FormatUtilTest {
      * <p><b>预期结果：</b>输出原值</p>
      */
     @Test
-    @DisplayName("formatTime方法测试 - 格式不匹配")
+    @DisplayName("formatTime - 格式不匹配")
     void testFormatTime_FormatMismatch() {
         System.out.println();
         log.info("========== 时间格式化模块测试 - 格式不匹配 ==========");
@@ -181,27 +177,39 @@ public class FormatUtilTest {
      * <p><b>预期结果：</b>正确提取开始时间</p>
      */
     @Test
-    @DisplayName("extractTimeRange方法测试 - 正常提取开始时间 - 【已验证】")
+    @DisplayName("extractTimeRange - 时间范围内(t1 ~ t2)，正常提取开始时间 - 【已验证】")
     void testExtractTimeRange_ExtractStartTime() {
         System.out.println();
         log.info("========== 时间范围提取模块测试 - 正常提取开始时间 ==========");
         
         // 输入参数
-        String inputTimeRange = "2024-01-15 14:30:25 ~ 2024-01-15 16:45:30";
+        String inputTimeRange1 = "2024-01-15 14:30:25 ~ 2024-01-15 16:45:30";
         params.put("type", "start");
-        
         log.info("输入参数:");
-        log.info("  - 时间范围字符串: {}", inputTimeRange);
+        log.info("  - 时间范围字符串: {}", inputTimeRange1);
         log.info("  - 提取类型: {}", params.get("type"));
-
         // 执行测试
-        Object result = FormatUtil.extractTimeRange(inputTimeRange, params);
-
+        Object result1 = FormatUtil.extractTimeRange(inputTimeRange1, params);
         // 断言验证
-        String expectedResult = "2024-01-15 14:30:25";
-        log.info("预期结果：'{}'", expectedResult);
-        log.info("实际结果：'{}'", result);
-        assertEquals(expectedResult, result);
+        String expectedResult1 = "2024-01-15 14:30:25";
+        log.info("预期结果：'{}'", expectedResult1);
+        log.info("实际结果：'{}'", result1);
+        assertEquals(expectedResult1, result1);
+
+        // 输入参数
+        String inputTimeRange2 = "2024-01-15 ~ 2024-01-15 ";
+        params.put("type", "start");
+        log.info("输入参数:");
+        log.info("  - 时间范围字符串: {}", inputTimeRange2);
+        log.info("  - 提取类型: {}", params.get("type"));
+        // 执行测试
+        Object result2 = FormatUtil.extractTimeRange(inputTimeRange2, params);
+        // 断言验证
+        String expectedResult2 = "2024-01-15";
+        log.info("预期结果：'{}'", expectedResult2);
+        log.info("实际结果：'{}'", result2);
+        assertEquals(expectedResult2, result2);
+
         log.info("✓ 测试通过 - 开始时间提取正确");
     }
     
@@ -213,7 +221,7 @@ public class FormatUtilTest {
      * <p><b>预期结果：</b>返回原始字符串</p>
      */
     @Test
-    @DisplayName("extractTimeRange方法测试 - 无分隔符处理 - 【已验证】")
+    @DisplayName("extractTimeRange - 无分隔符情况下，获取开始时间 - 【已验证】")
     void testExtractTimeRange_NoSeparator() {
         System.out.println();
         log.info("========== 时间范围提取模块测试 - 无分隔符处理 ==========");
@@ -251,7 +259,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>正确识别并转换为目标格式</p>
      */
     @Test
-    @DisplayName("dynamicTimeFormat方法测试 - 标准格式识别")
+    @DisplayName("dynamicTimeFormat - 标准格式识别")
     void testDynamicTimeFormat_StandardFormat() {
         System.out.println();
         log.info("========== 动态时间格式化模块测试 - 标准格式识别 ==========");
@@ -287,7 +295,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>正确识别并转换为目标格式</p>
      */
     @Test
-    @DisplayName("dynamicTimeFormat方法测试 - 中文格式识别")
+    @DisplayName("dynamicTimeFormat - 中文格式识别")
     void testDynamicTimeFormat_ChineseFormat() {
         System.out.println();
         log.info("========== 动态时间格式化模块测试 - 中文格式识别 ==========");
@@ -323,7 +331,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>返回true</p>
      */
     @Test
-    @DisplayName("validateTimeFormat方法测试 - 格式验证通过")
+    @DisplayName("validateTimeFormat - 格式验证通过")
     void testValidateTimeFormat_ValidFormat() {
         System.out.println();
         log.info("========== 时间格式验证模块测试 - 格式验证通过 ==========");
@@ -360,7 +368,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>返回false</p>
      */
     @Test
-    @DisplayName("validateTimeFormat方法测试 - 格式验证失败")
+    @DisplayName("validateTimeFormat - 格式验证失败")
     void testValidateTimeFormat_InvalidFormat() {
         System.out.println();
         log.info("========== 时间格式验证模块测试 - 格式验证失败 ==========");
@@ -400,7 +408,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>截取结果正确</p>
      */
     @Test
-    @DisplayName("substring方法测试 - 正常截取")
+    @DisplayName("substring - 正常截取")
     void testSubstring_NormalCase() {
         System.out.println();
         log.info("========== 字符串截取模块测试 - 正常截取 ==========");
@@ -440,7 +448,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>返回空字符串或错误信息</p>
      */
     @Test
-    @DisplayName("substring方法测试 - 起始位置超界")
+    @DisplayName("substring - 起始位置超界")
     void testSubstring_StartOutOfBounds() {
         System.out.println();
         log.info("========== 字符串截取模块测试 - 起始位置超界 ==========");
@@ -480,7 +488,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>替换结果正确</p>
      */
     @Test
-    @DisplayName("regexReplace方法测试 - 正则替换 - 【已验证】")
+    @DisplayName("regexReplace - 正则替换 - 【已验证】")
     void testRegexReplace_NormalCase() {
         System.out.println();
         log.info("========== 正则表达式替换模块测试 - 正则替换 ==========");
@@ -516,8 +524,8 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>替换结果正确</p>
      */
     @Test
-    @DisplayName("regexReplace方法测试 - 三种测试 - 【已验证】")
-    void testRegexReplace_NormalCase3() {
+    @DisplayName("regexReplace - 正则替换、分组替换、大小写敏感替换 - 【已验证】")
+    void testRegexReplace_NormalCase4() {
         System.out.println();
         log.info("========== 正则表达式替换模块测试 - 正则替换 ==========");
 
@@ -530,10 +538,11 @@ public class FormatUtilTest {
 
 
         // 测试用例1：数字替换
+        String inputString1 = "abc123def456";
         Map<String, Object> params1 = new HashMap<>();
         params1.put("pattern", "\\d+");
         params1.put("replacement", "*");
-        String result1 = FormatUtil.regexReplace("abc123def456", params1);
+        String result1 = FormatUtil.regexReplace(inputString1, params1);
         log.info("实际结果 (1): " + result1);
         // 断言验证
         String expectedResult1 = "abc*def*";
@@ -542,10 +551,11 @@ public class FormatUtilTest {
         assertEquals(expectedResult1, result1);
 
         // 测试用例2：分组引用替换
+        String inputString2 = "电话: 123-456";
         Map<String, Object> params2 = new HashMap<>();
         params2.put("pattern", "(\\d+)-(\\d+)");
         params2.put("replacement", "$2到$1");
-        String result2 = FormatUtil.regexReplace("电话: 123-456", params2);
+        String result2 = FormatUtil.regexReplace(inputString2, params2);
         log.info("实际结果 (2): " + result2);
         // 断言验证
         String expectedResult2 = "电话: 456到123";
@@ -554,17 +564,32 @@ public class FormatUtilTest {
         assertEquals(expectedResult2, result2);
 
         // 测试用例3：大小写不敏感
+        String inputString3 = "Hello World";
         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);
+        String result3 = FormatUtil.regexReplace(inputString3, params3);
         log.info("实际结果 (3): " + result3);
         // 断言验证
         String expectedResult3 = "HI World";
         log.info("预期结果：'{}'", expectedResult3);
         log.info("实际结果：'{}'", result3);
         assertEquals(expectedResult3, result3);
+
+        // 测试用例4：大小写不敏感
+        String inputString4 = "Hello World";
+        Map<String, Object> params4 = new HashMap<>();
+        params4.put("pattern", "hello");
+        params4.put("replacement", "HI");
+        String result4 = FormatUtil.regexReplace(inputString4, params4);
+        log.info("实际结果 (4): " + result4);
+        // 断言验证
+        String expectedResult4 = "Hello World";
+        log.info("预期结果：'{}'", expectedResult4);
+        log.info("实际结果：'{}'", result4);
+        assertEquals(expectedResult4, result4);
+
         log.info("✓ 测试通过 - 正则替换正确");
     }
     
@@ -576,7 +601,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>转换结果正确</p>
      */
     @Test
-    @DisplayName("toUpperCase方法测试 - 大小写转换")
+    @DisplayName("toUpperCase - 大小写转换")
     void testToUpperCase_NormalCase() {
         System.out.println();
         log.info("========== 字符串大小写转换模块测试 - 大小写转换 ==========");
@@ -610,26 +635,24 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>去除空格后结果正确</p>
      */
     @Test
-    @DisplayName("trim方法测试 - 去除空格 - 【已验证】")
+    @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("✓ 测试通过 - 空格去除正确");
     }
     
@@ -641,7 +664,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>替换结果正确</p>
      */
     @Test
-    @DisplayName("stealBeamsAndReplacePillars方法测试 - 基础替换")
+    @DisplayName("stealBeamsAndReplacePillars - 基础替换")
     void testStealBeamsAndReplacePillars_BasicReplacement() {
         System.out.println();
         log.info("========== 字符串替换模块测试 - 基础替换 ==========");
@@ -679,7 +702,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>大小写敏感替换结果正确</p>
      */
     @Test
-    @DisplayName("stealBeamsAndReplacePillars方法测试 - 大小写敏感 - 【已验证】")
+    @DisplayName("stealBeamsAndReplacePillars - 批量Map替换，大小写敏感 - 【已验证】")
     void testStealBeamsAndReplacePillars_CaseSensitive() {
         System.out.println();
         log.info("========== 字符串替换模块测试 - 大小写敏感替换 ==========");
@@ -716,7 +739,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>整词匹配替换结果正确</p>
      */
     @Test
-    @DisplayName("stealBeamsAndReplacePillars方法测试 - 整词匹配")
+    @DisplayName("stealBeamsAndReplacePillars - 整词匹配")
     void testStealBeamsAndReplacePillars_WholeWord() {
         System.out.println();
         log.info("========== 字符串替换模块测试 - 整词匹配替换 ==========");
@@ -760,7 +783,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>转换结果正确</p>
      */
     @Test
-    @DisplayName("coordinateConvert方法测试 - 度分秒转十进制")
+    @DisplayName("coordinateConvert - 度分秒转十进制")
     void testCoordinateConvert_DmsToDecimal() {
         System.out.println();
         log.info("========== 坐标系转换模块测试 - 度分秒转十进制 ==========");
@@ -798,31 +821,29 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>转换结果正确</p>
      */
     @Test
-    @DisplayName("coordinateConvert方法测试 - 十进制转度分秒 - 【已验证】")
+    @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");
-
+        params.put("fromFormat", "decimal"); // 十进制
+        params.put("toFormat", "dms"); // 度分秒
+        params.put("precision", "2"); // 保留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("✓ 测试通过 - 十进制转度分秒转换正确");
     }
     
@@ -834,7 +855,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>转换结果正确</p>
      */
     @Test
-    @DisplayName("cartesianConvert方法测试 - 直角坐标转极坐标")
+    @DisplayName("cartesianConvert - 直角坐标转极坐标")
     void testCartesianConvert_RectangularToPolar() {
         System.out.println();
         log.info("========== 坐标系转换模块测试 - 直角坐标转极坐标 ==========");
@@ -876,7 +897,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>标准化结果正确</p>
      */
     @Test
-    @DisplayName("normalizeCoordinate方法测试 - 坐标标准化")
+    @DisplayName("normalizeCoordinate - 坐标标准化")
     void testNormalizeCoordinate_NormalCase() {
         System.out.println();
         log.info("========== 坐标系转换模块测试 - 坐标格式标准化 ==========");
@@ -913,7 +934,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>返回原始值</p>
      */
     @Test
-    @DisplayName("boundaryCheck方法测试 - 正常范围检查")
+    @DisplayName("boundaryCheck - 正常范围检查")
     void testBoundaryCheck_WithinRange() {
         System.out.println();
         log.info("========== 极值检查模块测试 - 正常范围检查 ==========");
@@ -953,7 +974,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>返回最大值</p>
      */
     @Test
-    @DisplayName("boundaryCheck方法测试 - 超出上限截断")
+    @DisplayName("boundaryCheck - 超出上限截断")
     void testBoundaryCheck_AboveMaxTruncate() {
         System.out.println();
         log.info("========== 极值检查模块测试 - 超出上限截断处理 ==========");
@@ -994,7 +1015,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>返回默认值</p>
      */
     @Test
-    @DisplayName("boundaryCheck方法测试 - 超出下限默认值")
+    @DisplayName("boundaryCheck - 超出下限默认值")
     void testBoundaryCheck_BelowMinDefault() {
         System.out.println();
         log.info("========== 极值检查模块测试 - 超出下限默认值处理 ==========");
@@ -1037,7 +1058,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>返回错误信息或默认值</p>
      */
     @Test
-    @DisplayName("boundaryCheck方法测试 - 异常值检测")
+    @DisplayName("boundaryCheck - 异常值检测")
     void testBoundaryCheck_NaNValue() {
         System.out.println();
         log.info("========== 极值检查模块测试 - 异常值检测 ==========");
@@ -1079,7 +1100,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>转换结果正确</p>
      */
     @Test
-    @DisplayName("kvMapping方法测试 - 键名格式转换 - 【验证中】")
+    @DisplayName("kvMapping - 键名格式转换 - 【验证中】")
     void testKvMapping_KeyFormatConversion() {
         System.out.println();
         log.info("========== 数据KV映射模块测试 - 键名格式转换 ==========");
@@ -1089,23 +1110,25 @@ public class FormatUtilTest {
         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);
-        
+        Map<String, Object> expectedResult = new HashMap<>();
+        expectedResult.put("userName", "张三");
+        expectedResult.put("userAge", 25);
+        String expectedResultString = JSON.toJSONString(expectedResult);
+        String resultString = JSON.toJSONString(result);
+        log.info("预期结果: {}", expectedResultString);
+        log.info("实际结果: {}", resultString);
         // 断言验证
-        assertNotNull(result);
+        assertEquals(expectedResultString, resultString, "蛇形命名(user_name)转驼峰命名(userName) 失败");
+
         log.info("✓ 测试通过 - 键名格式转换正确");
     }
     
@@ -1117,7 +1140,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>过滤结果正确</p>
      */
     @Test
-    @DisplayName("kvMapping方法测试 - 数据过滤")
+    @DisplayName("kvMapping - 数据过滤")
     void testKvMapping_DataFiltering() {
         System.out.println();
         log.info("========== 数据KV映射模块测试 - 数据过滤 ==========");
@@ -1159,7 +1182,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>排序结果正确</p>
      */
     @Test
-    @DisplayName("kvMapping方法测试 - 分组排序 - 【已验证】")
+    @DisplayName("kvMapping - 对 Map 对象进行分组排序 - 【已验证】")
     void testKvMapping_GroupingSorting() {
         System.out.println();
         log.info("========== 数据KV映射模块测试 - 分组排序 ==========");
@@ -1207,7 +1230,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>JSON格式正确</p>
      */
     @Test
-    @DisplayName("kvMapping方法测试 - 输出格式转换")
+    @DisplayName("kvMapping - 输出格式转换")
     void testKvMapping_OutputFormat() {
         System.out.println();
         log.info("========== 数据KV映射模块测试 - 输出格式转换 ==========");
@@ -1311,7 +1334,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>所有转换正确完成</p>
      */
     @Test
-    @DisplayName("性能测试 - 大量数据处理")
+    @DisplayName("coordinateConvert - 性能测试 - 大量数据处理")
     void testPerformance_LargeDataProcessing() {
         System.out.println();
         log.info("========== 性能测试 - 大量数据处理 ==========");
@@ -1373,24 +1396,19 @@ public class FormatUtilTest {
         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);
+        log.info("预期结果: '{}'", expectedResult);
+        log.info("实际结果: '{}'", result);
         assertEquals(expectedResult, result);
+
         log.info("✓ 测试通过 - 异常处理正确");
     }