diff --git a/src/main/java/com/example/demo/draft/demo043/util/FormatUtil.java b/src/main/java/com/example/demo/draft/demo043/util/FormatUtil.java index f85d03d..87be656 100644 --- a/src/main/java/com/example/demo/draft/demo043/util/FormatUtil.java +++ b/src/main/java/com/example/demo/draft/demo043/util/FormatUtil.java @@ -164,21 +164,26 @@ public class FormatUtil { * @return 截取后的字符串 */ public static String substring(String str, Map params) { - if (str == null) return null; - - int start = params.containsKey("start") ? Integer.parseInt(params.get("start").toString()) : 0; - - if (params.containsKey("end")) { - int end = Integer.parseInt(params.get("end").toString()); - if (end > str.length()) end = str.length(); - if (start > end) start = 0; - return str.substring(start, end); - } else if (params.containsKey("length")) { - int length = Integer.parseInt(params.get("length").toString()); - if (start + length > str.length()) length = str.length() - start; - return str.substring(start, start + length); - } else { - return str.substring(start); + try { + if (str == null) return null; + + int start = params.containsKey("start") ? Integer.parseInt(params.get("start").toString()) : 0; + + if (params.containsKey("end")) { + int end = Integer.parseInt(params.get("end").toString()); + if (end > str.length()) end = str.length(); + if (start > end) start = 0; + return str.substring(start, end); + } else if (params.containsKey("length")) { + int length = Integer.parseInt(params.get("length").toString()); + if (start + length > str.length()) length = str.length() - start; + return str.substring(start, start + length); + } else { + return str.substring(start); + } + } catch (Exception e) { + log.warn("str 截取失败，{}", str, e); + return ""; } } @@ -1380,7 +1385,7 @@ public class FormatUtil { String strategy = params.containsKey("strategy") ? params.get("strategy").toString() : "clamp"; switch (strategy) { - case "clamp": + case "clamp", "truncate": if (value < min) return min; if (value > max) return max; return value; diff --git a/src/test/java/com/example/demo/FormatUtilTest.java b/src/test/java/com/example/demo/FormatUtilTest.java index 90e6657..420b5fa 100644 --- a/src/test/java/com/example/demo/FormatUtilTest.java +++ b/src/test/java/com/example/demo/FormatUtilTest.java @@ -78,22 +78,24 @@ public class FormatUtilTest { 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); + + try { + // 输入参数 + 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); + } catch (OutOfMemoryError ignore) {} log.info("✅ 测试通过 - 格式转换结果正确"); } @@ -106,27 +108,29 @@ public class FormatUtilTest { *

预期结果：返回空字符串

*/ @Test - @DisplayName("formatTime - 需要格式化时间的获取到空串 - 【已验证】") + @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); + + try { + // 输入参数 + 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); + } catch (OutOfMemoryError ignore) {} log.info("✅ 测试通过 - 空值处理正确"); } @@ -139,33 +143,30 @@ public class FormatUtilTest { *

预期结果：输出原值

*/ @Test - @DisplayName("formatTime - 格式不匹配") + @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); + + try { + // 输入参数 + 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(" - 注意: 时间字符串格式与源格式不匹配"); + // 执行测试 + Object result = FormatUtil.formatTime(inputTime, params); + // 断言验证 + String expectedResult = "2024 01-15"; + log.info("预期结果: '{}'", expectedResult); + log.info("实际结果: '{}'", result); + assertEquals(expectedResult, result); + } catch (OutOfMemoryError ignore) {} + log.info("✅ 测试通过 - 格式不匹配处理正确"); } @@ -177,38 +178,42 @@ public class FormatUtilTest { *

预期结果：正确提取开始时间

*/ @Test - @DisplayName("extractTimeRange - 时间范围内(t1 ~ t2)，正常提取开始时间 - 【已验证】") + @DisplayName("extractTimeRange - 时间，时间范围内(t1 ~ t2)，正常提取开始时间 - 【已验证】") void testExtractTimeRange_ExtractStartTime() { System.out.println(); log.info("========== 时间范围提取模块测试 - 正常提取开始时间 =========="); - - // 输入参数 - String inputTimeRange1 = "2024-01-15 14:30:25 ~ 2024-01-15 16:45:30"; - params.put("type", "start"); - log.info("输入参数:"); - log.info(" - 时间范围字符串: {}", inputTimeRange1); - log.info(" - 提取类型: {}", params.get("type")); - // 执行测试 - Object result1 = FormatUtil.extractTimeRange(inputTimeRange1, params); - // 断言验证 - 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); + try { + // 输入参数 + String inputTimeRange1 = "2024-01-15 14:30:25 ~ 2024-01-15 16:45:30"; + params.put("type", "start"); + log.info("输入参数:"); + log.info(" - 时间范围字符串: {}", inputTimeRange1); + log.info(" - 提取类型: {}", params.get("type")); + // 执行测试 + Object result1 = FormatUtil.extractTimeRange(inputTimeRange1, params); + // 断言验证 + String expectedResult1 = "2024-01-15 14:30:25"; + log.info("预期结果：'{}'", expectedResult1); + log.info("实际结果：'{}'", result1); + assertEquals(expectedResult1, result1); + } catch (OutOfMemoryError ignore) {} + + try { + // 输入参数 + 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); + } catch (OutOfMemoryError ignore) {} log.info("✅ 测试通过 - 开始时间提取正确"); } @@ -221,32 +226,28 @@ public class FormatUtilTest { *

预期结果：返回原始字符串

*/ @Test - @DisplayName("extractTimeRange - 无分隔符情况下，获取开始时间 - 【已验证】") + @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); + try { + // 输入参数 + String inputTimeRange = "2024-01-15 14:30:25"; + params.put("type", "start"); + log.info("输入参数:"); + log.info(" - 时间范围字符串: {}", inputTimeRange); + log.info(" - 提取类型: {}", params.get("type")); + 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); + } catch (OutOfMemoryError ignore) {} log.info("✅ 测试通过 - 无分隔符处理正确"); } @@ -259,15 +260,15 @@ public class FormatUtilTest { *

预计结果：正确识别并转换为目标格式

*/ @Test - @DisplayName("dynamicTimeFormat - 标准格式识别") + @DisplayName("dynamicTimeFormat - 时间，动态格式，标准格式识别 - 【已验证】") void testDynamicTimeFormat_StandardFormat() { System.out.println(); log.info("========== 动态时间格式化模块测试 - 标准格式识别 =========="); - - // 输入参数 + try { System.out.println(); log.info("========== 格式1 =========="); + // 输入参数 String inputTime = "2024-01-15T14:30:25Z"; params.put("targetFormat", "yyyy-MM-dd HH:mm:ss"); log.info("输入参数:"); @@ -280,12 +281,12 @@ public class FormatUtilTest { log.info("预期结果: '{}'", expectedResult); log.info("实际结果: '{}'", result); assertEquals(expectedResult, result); - } catch (Exception ignore) {} + } catch (OutOfMemoryError ignore) {} - // 输入参数 try { System.out.println(); log.info("========== 格式2 =========="); + // 输入参数 String inputTime = "2024-01-15_14:30:25"; params.put("targetFormat", "yyyy-MM-dd HH:mm:ss"); log.info("输入参数:"); @@ -298,12 +299,12 @@ public class FormatUtilTest { log.info("预期结果: '{}'", expectedResult); log.info("实际结果: '{}'", result); assertEquals(expectedResult, result); - } catch (NoClassDefFoundError ignore) {} + } catch (OutOfMemoryError ignore) {} - // 输入参数 try { System.out.println(); log.info("========== 格式3 =========="); + // 输入参数 String inputTime = "2024/01/15 14:30:25"; params.put("targetFormat", "yyyy-MM-dd HH:mm:ss"); log.info("输入参数:"); @@ -316,12 +317,12 @@ public class FormatUtilTest { log.info("预期结果: '{}'", expectedResult); log.info("实际结果: '{}'", result); assertEquals(expectedResult, result); - } catch (NoClassDefFoundError ignore) {} + } catch (OutOfMemoryError ignore) {} - // 输入参数 try { System.out.println(); log.info("========== 格式4 =========="); + // 输入参数 String inputTime = "2025年09月30日 11时55分"; params.put("targetFormat", "yyyy-MM-dd HH:mm:ss"); log.info("输入参数:"); @@ -334,12 +335,12 @@ public class FormatUtilTest { log.info("预期结果: '{}'", expectedResult); log.info("实际结果: '{}'", result); assertEquals(expectedResult, result); - } catch (NoClassDefFoundError ignore) {} + } catch (OutOfMemoryError ignore) {} - // 输入参数 try { System.out.println(); log.info("========== 格式5 =========="); + // 输入参数 String inputTime = "2025年09月29日 11:55:22"; params.put("targetFormat", "yyyy-MM-dd HH:mm:ss"); log.info("输入参数:"); @@ -352,12 +353,12 @@ public class FormatUtilTest { log.info("预期结果: '{}'", expectedResult); log.info("实际结果: '{}'", result); assertEquals(expectedResult, result); - } catch (NoClassDefFoundError ignore) {} + } catch (OutOfMemoryError ignore) {} - // 输入参数 try { System.out.println(); log.info("========== 格式6 =========="); + // 输入参数 String inputTime = "2025年9月29日 11:55:22"; params.put("targetFormat", "yyyy-MM-dd HH:mm:ss"); log.info("输入参数:"); @@ -370,12 +371,12 @@ public class FormatUtilTest { log.info("预期结果: '{}'", expectedResult); log.info("实际结果: '{}'", result); assertEquals(expectedResult, result); - } catch (NoClassDefFoundError ignore) {} + } catch (OutOfMemoryError ignore) {} - // 输入参数 try { System.out.println(); log.info("========== 格式7 =========="); + // 输入参数 String inputTime = "14:30 01/15/2024"; params.put("targetFormat", "yyyy-MM-dd HH:mm:ss"); log.info("输入参数:"); @@ -388,7 +389,7 @@ public class FormatUtilTest { log.info("预期结果: '{}'", expectedResult); log.info("实际结果: '{}'", result); assertEquals(expectedResult, result); - } catch (NoClassDefFoundError ignore) {} + } catch (OutOfMemoryError ignore) {} log.info("✅ 测试通过 - 标准格式识别正确"); } @@ -401,31 +402,27 @@ public class FormatUtilTest { *

预计结果：正确识别并转换为目标格式

*/ @Test - @DisplayName("dynamicTimeFormat - 中文格式识别") + @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); + + try { + // 输入参数 + 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")); + // 执行测试 + Object result = FormatUtil.dynamicTimeFormat(inputTime, params); + // 断言验证 + String expectedResult = "2024-01-15 14:30:25"; + log.info("预期结果: '{}'", expectedResult); + log.info("实际结果: '{}'", result); + assertEquals(expectedResult, result); + } catch (OutOfMemoryError ignore) {} + log.info("✅ 测试通过 - 中文格式识别正确"); } @@ -437,32 +434,28 @@ public class FormatUtilTest { *

预计结果：返回true

*/ @Test - @DisplayName("validateTimeFormat - 格式验证通过") + @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); + + try { + // 输入参数 + 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); + // 执行测试 + Object result = FormatUtil.validateTimeFormat(inputTime, String.valueOf(params.get("format"))); + // 断言验证 + boolean expectedResult = true; + log.info("预期结果: {}", expectedResult); + log.info("实际结果: {}", result); + assertEquals(expectedResult, result); + } catch (OutOfMemoryError ignore) {} + log.info("✅ 测试通过 - 格式验证正确"); } @@ -474,33 +467,29 @@ public class FormatUtilTest { *

预计结果：返回false

*/ @Test - @DisplayName("validateTimeFormat - 格式验证失败") + @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); + + try { + // 输入参数 + 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(" - 注意: 时间字符串格式与验证格式不匹配"); + // 执行测试 + Object result = FormatUtil.validateTimeFormat(inputTime, String.valueOf(params.get("format"))); + // 断言验证 + boolean expectedResult = false; + log.info("预期结果: '{}'", expectedResult); + log.info("实际结果: '{}'", result); + assertEquals(expectedResult, result); + } catch (OutOfMemoryError ignore) {} + log.info("✅ 测试通过 - 格式验证失败检测正确"); } @@ -514,35 +503,31 @@ public class FormatUtilTest { *

预计结果：截取结果正确

*/ @Test - @DisplayName("substring - 正常截取") + @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); + + try { + // 输入参数 + 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); + // 执行测试 + Object result = FormatUtil.substring(inputString, params); + // 断言验证 + String expectedResult = "World"; + log.info("预期结果: '{}'", expectedResult); + log.info("实际结果: '{}'", result); + assertEquals(expectedResult, result); + } catch (OutOfMemoryError ignore) {} + log.info("✅ 测试通过 - 字符串截取正确"); } @@ -554,35 +539,32 @@ public class FormatUtilTest { *

预计结果：返回空字符串或错误信息

*/ @Test - @DisplayName("substring - 起始位置超界 - 【验证中】") + @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); + + try { + // 输入参数 + 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(" - 注意: 起始位置大于字符串长度"); + // 执行测试 + Object result = FormatUtil.substring(inputString, params); + // 断言验证 + String expectedResult = ""; + log.info("预期结果: '{}'", expectedResult); + log.info("实际结果: '{}'", result); + assertEquals(expectedResult, result); + } catch (OutOfMemoryError ignore) {} + log.info("✅ 测试通过 - 起始位置超界处理正确"); } @@ -594,31 +576,31 @@ public class FormatUtilTest { *

预计结果：替换结果正确

*/ @Test - @DisplayName("regexReplace - 正则替换 - 【已验证】") + @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); + try { + // 输入参数 + 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); + } catch (OutOfMemoryError ignore) {} - // 断言验证 - String expectedResult = "abc*def*"; - log.info("预期结果: {}", expectedResult); - log.info("实际结果: {}", result); - assertEquals(expectedResult, result); log.info("✅ 测试通过 - 正则替换正确"); } @@ -630,71 +612,71 @@ public class FormatUtilTest { *

预计结果：替换结果正确

*/ @Test - @DisplayName("regexReplace - 正则替换、分组替换、大小写敏感替换 - 【已验证】") + @DisplayName("regexReplace - 字符串，正则替换、分组替换、大小写敏感替换 - 【已验证】") void testRegexReplace_NormalCase4() { System.out.println(); log.info("========== 正则表达式替换模块测试 - 正则替换 =========="); - // 输入参数 - String inputString = "abc123def456"; - String regex = "\\d+"; - String replacement = "*"; - params.put("pattern", regex); - params.put("replacement", replacement); + try { + // 测试用例1：数字替换 + String inputString1 = "abc123def456"; + Map params1 = new HashMap<>(); + params1.put("pattern", "\\d+"); + params1.put("replacement", "*"); + String result1 = FormatUtil.regexReplace(inputString1, params1); + log.info("实际结果 (1): " + result1); + // 断言验证 + String expectedResult1 = "abc*def*"; + log.info("预期结果：'{}'", expectedResult1); + log.info("实际结果：'{}'", result1); + assertEquals(expectedResult1, result1); + } catch (OutOfMemoryError ignore) {} + try { + // 测试用例2：分组引用替换 + String inputString2 = "电话: 123-456"; + Map params2 = new HashMap<>(); + params2.put("pattern", "(\\d+)-(\\d+)"); + params2.put("replacement", "$2到$1"); + String result2 = FormatUtil.regexReplace(inputString2, params2); + log.info("实际结果 (2): " + result2); + // 断言验证 + String expectedResult2 = "电话: 456到123"; + log.info("预期结果：'{}'", expectedResult2); + log.info("实际结果：'{}'", result2); + assertEquals(expectedResult2, result2); + } catch (OutOfMemoryError ignore) {} - // 测试用例1：数字替换 - String inputString1 = "abc123def456"; - Map params1 = new HashMap<>(); - params1.put("pattern", "\\d+"); - params1.put("replacement", "*"); - String result1 = FormatUtil.regexReplace(inputString1, params1); - log.info("实际结果 (1): " + result1); - // 断言验证 - String expectedResult1 = "abc*def*"; - log.info("预期结果：'{}'", expectedResult1); - log.info("实际结果：'{}'", result1); - assertEquals(expectedResult1, result1); + try { + // 测试用例3：大小写不敏感 + String inputString3 = "Hello World"; + Map params3 = new HashMap<>(); + params3.put("pattern", "hello"); + params3.put("replacement", "HI"); + params3.put("flags", "CASE_INSENSITIVE"); + String result3 = FormatUtil.regexReplace(inputString3, params3); + log.info("实际结果 (3): " + result3); + // 断言验证 + String expectedResult3 = "HI World"; + log.info("预期结果：'{}'", expectedResult3); + log.info("实际结果：'{}'", result3); + assertEquals(expectedResult3, result3); + } catch (OutOfMemoryError ignore) {} - // 测试用例2：分组引用替换 - String inputString2 = "电话: 123-456"; - Map params2 = new HashMap<>(); - params2.put("pattern", "(\\d+)-(\\d+)"); - params2.put("replacement", "$2到$1"); - String result2 = FormatUtil.regexReplace(inputString2, params2); - log.info("实际结果 (2): " + result2); - // 断言验证 - String expectedResult2 = "电话: 456到123"; - log.info("预期结果：'{}'", expectedResult2); - log.info("实际结果：'{}'", result2); - assertEquals(expectedResult2, result2); - - // 测试用例3：大小写不敏感 - String inputString3 = "Hello World"; - Map params3 = new HashMap<>(); - params3.put("pattern", "hello"); - params3.put("replacement", "HI"); - params3.put("flags", "CASE_INSENSITIVE"); - 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 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); + try { + // 测试用例4：大小写不敏感 + String inputString4 = "Hello World"; + Map 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); + } catch (OutOfMemoryError ignore) {} log.info("✅ 测试通过 - 正则替换正确"); } @@ -707,29 +689,25 @@ public class FormatUtilTest { *

预计结果：转换结果正确

*/ @Test - @DisplayName("toUpperCase - 大小写转换") + @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); + + try { + // 输入参数 + String inputString = "hello world"; + log.info("输入参数:"); + log.info(" - 输入字符串: {}", inputString); + // 执行测试 + Object result = FormatUtil.toUpperCase(inputString, params); + // 断言验证 + String expectedResult = "HELLO WORLD"; + log.info("预期结果：'{}'", expectedResult); + log.info("实际结果：'{}'", result); + assertEquals(expectedResult, result); + } catch (OutOfMemoryError ignore) {} + log.info("✅ 测试通过 - 大小写转换正确"); } @@ -745,19 +723,22 @@ public class FormatUtilTest { 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); + + try { + // 输入参数 + 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); + } catch (OutOfMemoryError ignore) {} + log.info("✅ 测试通过 - 空格去除正确"); } @@ -770,33 +751,29 @@ public class FormatUtilTest { *

预计结果：替换结果正确

*/ @Test - @DisplayName("stealBeamsAndReplacePillars - 基础替换") + @DisplayName("stealBeamsAndReplacePillars - 字符串，基础替换 - 【已验证】") void testStealBeamsAndReplacePillars_BasicReplacement() { System.out.println(); log.info("========== 字符串替换模块测试 - 基础替换 =========="); - - // 输入参数 - String inputString = "hello world"; - Map 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); + + try { + // 输入参数 + String inputString = "hello world"; + Map replacementMap = new HashMap<>(); + replacementMap.put("hello", "hi"); + replacementMap.put("world", "universe"); + log.info("输入参数:"); + log.info(" - 输入字符串: {}", inputString); + log.info(" - 替换映射: {}", replacementMap); + // 预期结果 + String expectedResult = "hi universe"; + // 执行测试 + String result = FormatUtil.stealBeamsAndReplacePillars(inputString, replacementMap); + log.info("预期结果：'{}'", expectedResult); + log.info("实际结果：'{}'", result); + assertEquals(expectedResult, result); + } catch (OutOfMemoryError ignore) {} + log.info("✅ 测试通过 - 基础字符串替换正确"); } @@ -808,29 +785,32 @@ public class FormatUtilTest { *

预计结果：大小写敏感替换结果正确

*/ @Test - @DisplayName("stealBeamsAndReplacePillars - 批量Map替换，大小写敏感 - 【已验证】") + @DisplayName("stealBeamsAndReplacePillars - Map，批量Map替换，大小写敏感 - 【已验证】") void testStealBeamsAndReplacePillars_CaseSensitive() { System.out.println(); log.info("========== 字符串替换模块测试 - 大小写敏感替换 =========="); - - // 输入参数 - String inputString = "hello world"; - Map 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); + + try { + // 输入参数 + String inputString = "hello world"; + Map 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); + } catch (OutOfMemoryError ignore) {} + log.info("✅ 测试通过 - 大小写敏感替换正确"); } @@ -842,37 +822,33 @@ public class FormatUtilTest { *

预计结果：整词匹配替换结果正确

*/ @Test - @DisplayName("stealBeamsAndReplacePillars - 整词匹配") + @DisplayName("stealBeamsAndReplacePillars - 字符串，整词匹配 - 【已验证】") void testStealBeamsAndReplacePillars_WholeWord() { System.out.println(); log.info("========== 字符串替换模块测试 - 整词匹配替换 =========="); - - // 输入参数 - String inputString = "category cat catfish"; - Map 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); + + try { + // 输入参数 + String inputString = "category cat catfish"; + Map 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 result = FormatUtil.stealBeamsAndReplacePillars(inputString, replacementMap, caseSensitive, wholeWord); + // 断言验证 + String expectedResult = "category dog catfish"; + log.info("预期结果：'{}'", expectedResult); + log.info("实际结果：'{}'", result); + assertEquals(expectedResult, result); + } catch (OutOfMemoryError ignore) {} + log.info("✅ 测试通过 - 整词匹配替换正确"); } @@ -886,27 +862,29 @@ public class FormatUtilTest { *

预计结果：转换结果正确

*/ @Test - @DisplayName("coordinateConvert - 度分秒转十进制") + @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"); - // 执行测试 - Object result = FormatUtil.coordinateConvert(coordinate, params); - // 断言验证 - String expectedResult = "116.396019"; - log.info("预期结果：'{}'", expectedResult); - log.info("实际结果：'{}'", result); - assertEquals(expectedResult, result); + + try { + // 输入参数 + 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"); + // 执行测试 + Object result = FormatUtil.coordinateConvert(coordinate, params); + // 断言验证 + String expectedResult = "116.396019"; + log.info("预期结果：'{}'", expectedResult); + log.info("实际结果：'{}'", result); + assertEquals(expectedResult, result); + } catch (OutOfMemoryError ignore) {} log.info("✅ 测试通过 - 度分秒转十进制转换正确"); } @@ -919,28 +897,30 @@ public class FormatUtilTest { *

预计结果：转换结果正确

*/ @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"); // 保留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); + + try { + // 输入参数 + String coordinate = "116.396019"; + 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); + } catch (OutOfMemoryError ignore) {} log.info("✅ 测试通过 - 十进制转度分秒转换正确"); } @@ -953,37 +933,34 @@ public class FormatUtilTest { *

预计结果：转换结果正确

*/ @Test - @DisplayName("cartesianConvert - 直角坐标转极坐标") + @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); + + try { + // 输入参数 + 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°"); + // 执行测试 + Object result = FormatUtil.cartesianConvert(coordinate, params); + // 断言验证 + String expectedResult = "HELLO WORLD"; + log.info("预期结果：'{}'", expectedResult); + log.info("实际结果：'{}'", result); + assertEquals(expectedResult, result); + } catch (OutOfMemoryError ignore) {} + log.info("✅ 测试通过 - 直角坐标转极坐标转换正确"); } @@ -995,30 +972,27 @@ public class FormatUtilTest { *

预计结果：标准化结果正确

*/ @Test - @DisplayName("normalizeCoordinate - 坐标标准化") + @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); + + try { + // 输入参数 + String coordinate = "116.396019,39.909604"; + params.put("format", "decimal"); + log.info("输入参数:"); + log.info(" - 坐标值: {}", coordinate); + log.info(" - 目标格式: {}", params.get("format")); + // 执行测试 + Object result = FormatUtil.normalizeCoordinate(coordinate, params); + // 断言验证 + String expectedResult = "116.396019"; + log.info("预期结果：'{}'", expectedResult); + log.info("实际结果：'{}'", result); + assertEquals(expectedResult, result); + } catch (OutOfMemoryError ignore) {} + log.info("✅ 测试通过 - 坐标格式标准化正确"); } @@ -1032,35 +1006,31 @@ public class FormatUtilTest { *

预计结果：返回原始值

*/ @Test - @DisplayName("boundaryCheck - 正常范围检查") + @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); + + try { + // 输入参数 + 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")); + // 执行测试 + Object result = FormatUtil.boundaryCheck(inputValue, params); + // 断言验证 + int expectedResult = 50; + log.info("预期结果: '{}'", expectedResult); + log.info("实际结果: '{}'", result); + assertEquals(expectedResult, result); + } catch (OutOfMemoryError ignore) {} + log.info("✅ 测试通过 - 正常范围检查正确"); } @@ -1072,36 +1042,32 @@ public class FormatUtilTest { *

预计结果：返回最大值

*/ @Test - @DisplayName("boundaryCheck - 超出上限截断 - 【验证中】") + @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); + + try { + // 输入参数 + double 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"); + // 执行测试 + Object result = FormatUtil.boundaryCheck(inputValue, params); + // 断言验证 + double expectedResult = 100; + log.info("预期结果: '{}'", expectedResult); + log.info("实际结果: '{}'", result); + assertEquals(expectedResult, result); + } catch (OutOfMemoryError ignore) {} + log.info("✅ 测试通过 - 超出上限截断处理正确"); } @@ -1113,38 +1079,35 @@ public class FormatUtilTest { *

预计结果：返回默认值

*/ @Test - @DisplayName("boundaryCheck - 超出下限默认值") + @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); + + try { + // 输入参数 + 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"); + // 执行测试 + Object result = FormatUtil.boundaryCheck(inputValue, params); + // 断言验证 + int expectedResult = 0; + log.info("预期结果: '{}'", expectedResult); + log.info("实际结果: '{}'", result); + assertEquals(expectedResult, result); + } catch (OutOfMemoryError ignore) {} + + log.info("✅ 测试通过 - 超出下限默认值处理正确"); } @@ -1156,35 +1119,32 @@ public class FormatUtilTest { *

预计结果：返回错误信息或默认值

*/ @Test - @DisplayName("boundaryCheck - 异常值检测") + @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); + try { + 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)"); + // 执行测试 + Object result = FormatUtil.boundaryCheck(inputValue, params); + // 断言验证 + String expectedResult = "NaN"; + log.info("预期结果: '{}'", expectedResult); + log.info("实际结果: '{}'", result); + assertTrue(expectedResult.equals(String.valueOf(result))); + } catch (OutOfMemoryError ignore) {} + log.info("✅ 测试通过 - 异常值检测正确"); } @@ -1198,11 +1158,11 @@ public class FormatUtilTest { *

预计结果：转换结果正确

*/ @Test - @DisplayName("kvMapping - 键名格式转换 - 【已验证】") + @DisplayName("kvMapping - Map，键名格式转换 - 【已验证】") void testKvMapping_KeyFormatConversion() { System.out.println(); log.info("========== 数据KV映射模块测试 - 键名格式转换 =========="); - + // 输入参数 Map inputMap = new HashMap<>(); @@ -1222,104 +1182,111 @@ public class FormatUtilTest { // =================== 短横线命名 (kebab-case) =================== inputMap.put("user-address", "上海市浦东新区"); - // 1. 转成全大写 - System.out.println(); - log.info("========== 转成全大写 =========="); - params.put("keyFormat", "uppercase"); - log.info("输入参数:"); - log.info(" - 输入Map: {}", inputMap); - log.info(" - 键名格式转换: {}", params.get("keyFormat")); - log.info(" - 注意: 短横杠在全大写中，不做处理"); - // 执行测试 - Object result = FormatUtil.kvMapping(inputMap, params); - // 断言验证 - String expectedResultString = """ + try { + // 1. 转成全大写 + System.out.println(); + log.info("========== 转成全大写 =========="); + params.put("keyFormat", "uppercase"); + log.info("输入参数:"); + log.info(" - 输入Map: {}", inputMap); + log.info(" - 键名格式转换: {}", params.get("keyFormat")); + log.info(" - 注意: 短横杠在全大写中，不做处理"); + // 执行测试 + Object result = FormatUtil.kvMapping(inputMap, params); + // 断言验证 + String expectedResultString = """ {"USERROLE":"ADMIN","STATUS":"ACTIVE","USER-ADDRESS":"上海市浦东新区","USER_PASSWORD":"encrypted123","ADDRESS":"北京市朝阳区","PHONE":"13800138000","USER_ID":1001,"USERNAME":"王五","NAME":"李四"} """.trim(); - String resultString = JSON.toJSONString(result); - log.info("预期结果: {}", expectedResultString); - log.info("实际结果: {}", resultString); - assertEquals(expectedResultString, resultString, String.format("转换为全大写%s失败", params.get("keyFormat"))); + String resultString = JSON.toJSONString(result); + log.info("预期结果: {}", expectedResultString); + log.info("实际结果: {}", resultString); + assertEquals(expectedResultString, resultString, String.format("转换为全大写%s失败", params.get("keyFormat"))); + } catch (OutOfMemoryError ignore) {} - // 2. 转成全小写 - System.out.println(); - log.info("========== 转成全小写 =========="); - params.put("keyFormat", "lowercase"); - log.info("输入参数:"); - log.info(" - 输入Map: {}", inputMap); - log.info(" - 键名格式转换: {}", params.get("keyFormat")); - log.info(" - 注意: 短横杠在全小写中，不做处理"); - // 执行测试 - Object result2 = FormatUtil.kvMapping(inputMap, params); - // 断言验证 - String expectedResultString2 = """ + try { + // 2. 转成全小写 + System.out.println(); + log.info("========== 转成全小写 =========="); + params.put("keyFormat", "lowercase"); + log.info("输入参数:"); + log.info(" - 输入Map: {}", inputMap); + log.info(" - 键名格式转换: {}", params.get("keyFormat")); + log.info(" - 注意: 短横杠在全小写中，不做处理"); + // 执行测试 + Object result2 = FormatUtil.kvMapping(inputMap, params); + // 断言验证 + String expectedResultString2 = """ {"user_password":"encrypted123","address":"北京市朝阳区","phone":"13800138000","user_id":1001,"name":"李四","userrole":"ADMIN","user-address":"上海市浦东新区","status":"ACTIVE","username":"王五"} """.trim(); - String resultString2 = JSON.toJSONString(result2); - log.info("预期结果: {}", expectedResultString2); - log.info("实际结果: {}", resultString2); - assertEquals(expectedResultString2, resultString2, String.format("转换为全小写%s失败", params.get("keyFormat"))); + String resultString2 = JSON.toJSONString(result2); + log.info("预期结果: {}", expectedResultString2); + log.info("实际结果: {}", resultString2); + assertEquals(expectedResultString2, resultString2, String.format("转换为全小写%s失败", params.get("keyFormat"))); + } catch (OutOfMemoryError ignore) {} - // 3. 转换为小驼峰命名 - System.out.println(); - log.info("========== 转换为小驼峰命名 =========="); - params.put("keyFormat", "camelcase"); - log.info("输入参数:"); - log.info(" - 输入Map: {}", inputMap); - log.info(" - 键名格式转换: {}", params.get("keyFormat")); - log.info(" - 注意: 所有值都被转为驼峰，不区分当前是否大小写，只判断 [ _ | - | ' '] 下划线、短横杠、空串三种。"); - // 执行测试 - Object result3 = FormatUtil.kvMapping(inputMap, params); - // 断言验证 - String expectedResultString3 = """ + try { + // 3. 转换为小驼峰命名 + System.out.println(); + log.info("========== 转换为小驼峰命名 =========="); + params.put("keyFormat", "camelcase"); + log.info("输入参数:"); + log.info(" - 输入Map: {}", inputMap); + log.info(" - 键名格式转换: {}", params.get("keyFormat")); + log.info(" - 注意: 所有值都被转为驼峰，不区分当前是否大小写，只判断 [ _ | - | ' '] 下划线、短横杠、空串三种。"); + // 执行测试 + Object result3 = FormatUtil.kvMapping(inputMap, params); + // 断言验证 + String expectedResultString3 = """ {"userAddress":"上海市浦东新区","userPassword":"encrypted123","address":"北京市朝阳区","phone":"13800138000","name":"李四","userrole":"ADMIN","userId":1001,"status":"ACTIVE","username":"王五"} """.trim(); - String resultString3 = JSON.toJSONString(result3); - log.info("预期结果: {}", expectedResultString3); - log.info("实际结果: {}", resultString3); - assertEquals(expectedResultString3, resultString3, String.format("转换为小驼峰命名%s失败", params.get("keyFormat"))); + String resultString3 = JSON.toJSONString(result3); + log.info("预期结果: {}", expectedResultString3); + log.info("实际结果: {}", resultString3); + assertEquals(expectedResultString3, resultString3, String.format("转换为小驼峰命名%s失败", params.get("keyFormat"))); + } catch (OutOfMemoryError ignore) {} - - // 4. 转换为蛇形命名 - System.out.println(); - log.info("========== 转换为蛇形命名 =========="); - params.put("keyFormat", "snakecase"); - log.info("输入参数:"); - log.info(" - 输入Map: {}", inputMap); - log.info(" - 键名格式转换: {}", params.get("keyFormat")); - log.info(" - 注意: 短横杠在蛇形命名中，不做处理"); - // 执行测试 - Object result4 = FormatUtil.kvMapping(inputMap, params); - // 断言验证 - String expectedResultString4 = """ + try { + // 4. 转换为蛇形命名 + System.out.println(); + log.info("========== 转换为蛇形命名 =========="); + params.put("keyFormat", "snakecase"); + log.info("输入参数:"); + log.info(" - 输入Map: {}", inputMap); + log.info(" - 键名格式转换: {}", params.get("keyFormat")); + log.info(" - 注意: 短横杠在蛇形命名中，不做处理"); + // 执行测试 + Object result4 = FormatUtil.kvMapping(inputMap, params); + // 断言验证 + String expectedResultString4 = """ {"user_role":"ADMIN","user_password":"encrypted123","address":"北京市朝阳区","phone":"13800138000","user_id":1001,"user_name":"王五","user_address":"上海市浦东新区","name":"李四","status":"ACTIVE"} """.trim(); - String resultString4 = JSON.toJSONString(result4); - log.info("预期结果: {}", expectedResultString4); - log.info("实际结果: {}", resultString4); - assertEquals(expectedResultString4, resultString4, String.format("转换为蛇形命名%s失败", params.get("keyFormat"))); + String resultString4 = JSON.toJSONString(result4); + log.info("预期结果: {}", expectedResultString4); + log.info("实际结果: {}", resultString4); + assertEquals(expectedResultString4, resultString4, String.format("转换为蛇形命名%s失败", params.get("keyFormat"))); + } catch (OutOfMemoryError ignore) {} - - // 5. 转换为短横线命名 - System.out.println(); - log.info("========== 转换为短横线命名 =========="); - params.put("keyFormat", "kebabcase"); - log.info("输入参数:"); - log.info(" - 输入Map: {}", inputMap); - log.info(" - 键名格式转换: {}", params.get("keyFormat")); - log.info(" - 注意: 短横杠在全大写中，不做处理"); - // 执行测试 - Object result5 = FormatUtil.kvMapping(inputMap, params); - // 断言验证 - String expectedResultString5 = """ + try { + // 5. 转换为短横线命名 + System.out.println(); + log.info("========== 转换为短横线命名 =========="); + params.put("keyFormat", "kebabcase"); + log.info("输入参数:"); + log.info(" - 输入Map: {}", inputMap); + log.info(" - 键名格式转换: {}", params.get("keyFormat")); + log.info(" - 注意: 短横杠在全大写中，不做处理"); + // 执行测试 + Object result5 = FormatUtil.kvMapping(inputMap, params); + // 断言验证 + String expectedResultString5 = """ {"user-password":"encrypted123","address":"北京市朝阳区","user-role":"ADMIN","user-name":"王五","phone":"13800138000","user-id":1001,"name":"李四","user-address":"上海市浦东新区","status":"ACTIVE"} """.trim(); - String resultString5 = JSON.toJSONString(result5); - log.info("预期结果: {}", expectedResultString5); - log.info("实际结果: {}", resultString5); - assertEquals(expectedResultString5, resultString5, String.format("转换为短横线命名%s失败", params.get("keyFormat"))); - + String resultString5 = JSON.toJSONString(result5); + log.info("预期结果: {}", expectedResultString5); + log.info("实际结果: {}", resultString5); + assertEquals(expectedResultString5, resultString5, String.format("转换为短横线命名%s失败", params.get("keyFormat"))); + } catch (OutOfMemoryError ignore) {} log.info("✅ 测试通过 - 键名格式转换正确"); } @@ -1332,37 +1299,31 @@ public class FormatUtilTest { *

预计结果：过滤结果正确

*/ @Test - @DisplayName("kvMapping - 数据过滤") + @DisplayName("kvMapping - Map，数据过滤 - 【验证中】") void testKvMapping_DataFiltering() { System.out.println(); log.info("========== 数据KV映射模块测试 - 数据过滤 =========="); - - // 输入参数 - Map 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; - } + + try { + // 输入参数 + Map 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的键值对"); + // 执行测试 + Object result = FormatUtil.kvMapping(inputMap, params); + // 断言验证 + String expectedResult = "{\"name\":\"张三\",\"age\":25}"; + log.info("预期结果: '{}'", expectedResult); + log.info("实际结果: '{}'", result); + assertEquals(expectedResult, result); + } catch (OutOfMemoryError ignore) {} + log.info("✅ 测试通过 - 数据过滤正确"); } @@ -1374,43 +1335,38 @@ public class FormatUtilTest { *

预计结果：排序结果正确

*/ @Test - @DisplayName("kvMapping - 对 Map 对象进行分组排序 - 【已验证】") + @DisplayName("kvMapping - Map，对 Map 对象进行分组排序 - 【已验证】") void testKvMapping_GroupingSorting() { System.out.println(); log.info("========== 数据KV映射模块测试 - 分组排序 =========="); - - // 输入参数 - Map 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 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, "排序失败"); + + try { + // 输入参数 + // 输入参数 + Map 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)"); + // 执行测试 + Object result = FormatUtil.kvMapping(inputMap, params); + // 断言验证 + Map 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, "排序失败"); + } catch (OutOfMemoryError ignore) {} + log.info("✅ 测试通过 - 分组排序正确"); } @@ -1422,34 +1378,32 @@ public class FormatUtilTest { *

预计结果：JSON格式正确

*/ @Test - @DisplayName("kvMapping - 输出格式转换") + @DisplayName("kvMapping - Map，输出格式转换 - 【已验证】") void testKvMapping_OutputFormat() { System.out.println(); log.info("========== 数据KV映射模块测试 - 输出格式转换 =========="); - + // 输入参数 - Map 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("张三")); + try { + Map 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字符串格式"); + // 执行测试 + Object result = FormatUtil.kvMapping(inputMap, params); + // 断言验证 + String expectedResult = "{\"name\": \"张三\", \"age\": 25}"; + log.info("预期结果: '{}'", expectedResult); + log.info("实际结果: '{}'", result); + assertNotNull(result); + assertTrue(result.toString().contains("name") && result.toString().contains("张三")); + assertEquals(expectedResult, result); + } catch (OutOfMemoryError ignore) {} + log.info("✅ 测试通过 - 输出格式转换正确"); } @@ -1463,58 +1417,61 @@ public class FormatUtilTest { *

预计结果：组合处理结果正确

*/ @Test - @DisplayName("boundaryCheck - 综合测试 - 多方法组合使用 - 【验证中】") + @DisplayName("boundaryCheck - 数字，综合测试 - 多方法组合使用 - 【已验证】") void testMultipleMethods_CombinedUsage() { System.out.println(); log.info("========== 综合测试 - 多方法组合使用 =========="); - log.info("测试流程: 时间格式化 → 字符串截取 → 边界检查"); + try { + log.info("测试流程: 时间格式化 → 字符串截取 → 边界检查"); + + // 第一步：时间格式化 + log.info("第一步 - 时间格式化:"); + Map 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 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 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); + } catch (OutOfMemoryError ignore) {} - // 第一步：时间格式化 - log.info("第一步 - 时间格式化:"); - Map 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 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 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("✅ 测试通过 - 多方法组合使用正确"); } @@ -1526,42 +1483,44 @@ public class FormatUtilTest { *

预计结果：所有转换正确完成

*/ @Test - @DisplayName("coordinateConvert - 性能测试 - 大量数据处理 - 【验证中】") + @DisplayName("coordinateConvert - 坐标，性能测试 - 大量数据处理 - 【已验证】") 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 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("预期结果: 处理时间 < 100 ms"); - // 断言验证 - assertTrue(duration < 100, "性能测试应在0.1秒内完成"); + + try { + // 输入参数 + 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 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("预期结果: 处理时间 < 100 ms"); + // 断言验证 + assertTrue(duration < 100, "性能测试应在0.1秒内完成"); + } catch (OutOfMemoryError ignore) {} log.info("✅ 测试通过 - 性能表现符合要求"); } @@ -1574,27 +1533,29 @@ public class FormatUtilTest { *

预计结果：返回合理的默认值

*/ @Test - @DisplayName("formatTime - 默认参数值 - 【已验证】") + @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(" - 注意: 日期格式到时间格式的无效转换"); - // 执行测试 - Object result = FormatUtil.formatTime(inputTime, params); - // 断言验证 - String expectedResult = "00:00:00"; - log.info("预期结果: '{}'", expectedResult); - log.info("实际结果: '{}'", result); - assertEquals(expectedResult, result); + + try { + // 输入参数 + 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(" - 注意: 日期格式到时间格式的无效转换"); + // 执行测试 + Object result = FormatUtil.formatTime(inputTime, params); + // 断言验证 + String expectedResult = "00:00:00"; + log.info("预期结果: '{}'", expectedResult); + log.info("实际结果: '{}'", result); + assertEquals(expectedResult, result); + } catch (OutOfMemoryError ignore) {} log.info("✅ 测试通过 - 异常处理正确"); } @@ -1607,35 +1568,35 @@ public class FormatUtilTest { *

预计结果：正确处理或返回错误信息

*/ @Test - @DisplayName("boundaryCheck - 边界值测试 - 极值输入 - 【验证中】") + @DisplayName("boundaryCheck - 数字，极值输入，抛出异常 - 【已验证】") 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("✅ 测试通过 - 边界值处理正确"); + + try { + // 输入参数 + 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(" - 注意: 极大值超出正常范围"); + // 执行测试 + Object result = FormatUtil.boundaryCheck(inputValue, params); + } catch (RuntimeException result) { + // 断言验证 + String expectedResult = "边界检查失败: 数值 1.7976931348623157E308 超出范围 [0.0, 100.0]"; + log.info("预期结果: '{}'", expectedResult); + log.info("实际结果: '{}'", result.getMessage()); + assertTrue(result.getMessage().contains(expectedResult)); + log.info("✅ 测试通过 - 边界值处理正确"); + return; + } + assertTrue(false); + } } \ No newline at end of file