yuejiajun/XMLTransformServer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

测试类

Browse Source
This commit is contained in:
yuejiajun 2025-09-28 15:26:09 +08:00
parent cea42fdfbd
commit 11586563a7
1 changed files with 96 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

174
src/test/java/com/example/demo/FormatUtilTest.java
View File

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