1436 lines
53 KiB
Java
1436 lines
53 KiB
Java
package com.example.demo;
|
||
|
||
import com.alibaba.fastjson2.JSON;
|
||
import org.junit.jupiter.api.Test;
|
||
import org.junit.jupiter.api.DisplayName;
|
||
import org.junit.jupiter.api.BeforeEach;
|
||
import org.junit.jupiter.api.AfterEach;
|
||
import static org.junit.jupiter.api.Assertions.*;
|
||
|
||
import com.example.demo.draft.demo043.util.FormatUtil;
|
||
|
||
import java.util.HashMap;
|
||
import java.util.LinkedHashMap;
|
||
import java.util.Map;
|
||
|
||
import lombok.extern.slf4j.Slf4j;
|
||
|
||
/**
|
||
* FormatUtil工具类测试类
|
||
*
|
||
* <p>本测试类对FormatUtil中的所有方法进行全面的单元测试，确保每个方法的功能正确性。</p>
|
||
*
|
||
* <p><b>测试策略：</b></p>
|
||
* <ul>
|
||
* <li>每个方法对应多个测试用例，覆盖所有分支情况</li>
|
||
* <li>每个测试用例独立测试一个特定场景</li>
|
||
* <li>包含正常情况、边界情况、异常情况的测试</li>
|
||
* <li>使用详细的文档注释说明每个测试用例的目的</li>
|
||
* </ul>
|
||
*
|
||
* <p><b>测试覆盖范围：</b></p>
|
||
* <ul>
|
||
* <li>时间格式化模块测试</li>
|
||
* <li>字符串处理模块测试</li>
|
||
* <li>坐标系转换模块测试</li>
|
||
* <li>极值/边界值检查处理模块测试</li>
|
||
* <li>数据KV映射处理模块测试</li>
|
||
* </ul>
|
||
*
|
||
* @author demo043项目组
|
||
* @version 1.0.0
|
||
* @since 2024年
|
||
*/
|
||
@SuppressWarnings("all")
|
||
@Slf4j
|
||
@DisplayName("FormatUtil工具类测试")
|
||
public class FormatUtilTest {
|
||
|
||
private Map<String, Object> params;
|
||
|
||
/**
|
||
* 每个测试方法执行前的初始化操作
|
||
*/
|
||
@BeforeEach
|
||
void setUp() {
|
||
params = new HashMap<>();
|
||
}
|
||
|
||
/**
|
||
* 每个测试方法执行后的清理操作
|
||
*/
|
||
@AfterEach
|
||
void tearDown() {
|
||
params.clear();
|
||
}
|
||
|
||
// ==================== 时间格式化模块测试 ====================
|
||
|
||
/**
|
||
* 测试formatTime方法 - 正常时间格式转换
|
||
*
|
||
* <p><b>测试目的：</b>验证formatTime方法能够正确进行时间格式转换</p>
|
||
* <p><b>测试场景：</b>从"yyyy-MM-dd HH:mm:ss"格式转换为"yyyy/MM/dd"格式</p>
|
||
* <p><b>预期结果：</b>转换后的时间格式正确</p>
|
||
*/
|
||
@Test
|
||
@DisplayName("formatTime方法测试 - 正常格式转换 - 【已验证】")
|
||
void testFormatTime_NormalConversion() {
|
||
System.out.println();
|
||
log.info("========== 时间格式化模块测试 - 正常格式转换 ==========");
|
||
|
||
// 输入参数
|
||
String inputTime = "2024-01-15 14:30:25";
|
||
params.put("fromFormat", "yyyy-MM-dd HH:mm:ss");
|
||
params.put("toFormat", "yyyy/MM/dd");
|
||
|
||
log.info("输入参数:");
|
||
log.info(" - 时间字符串: {}", inputTime);
|
||
log.info(" - 源格式: {}", params.get("fromFormat"));
|
||
log.info(" - 目标格式: {}", params.get("toFormat"));
|
||
|
||
// 执行测试
|
||
Object result = FormatUtil.formatTime(inputTime, params);
|
||
|
||
// 断言验证
|
||
String expectedResult = "2024/01/15";
|
||
log.info("预期结果: {}", expectedResult);
|
||
log.info("实际结果: {}", result);
|
||
assertEquals(expectedResult, result);
|
||
log.info("✓ 测试通过 - 格式转换结果正确");
|
||
}
|
||
|
||
/**
|
||
* 测试formatTime方法 - 边界情况：空值处理
|
||
*
|
||
* <p><b>测试目的：</b>验证formatTime方法对空值的容错处理</p>
|
||
* <p><b>测试场景：</b>输入时间为空字符串</p>
|
||
* <p><b>预期结果：</b>返回空字符串或默认值</p>
|
||
*/
|
||
@Test
|
||
@DisplayName("formatTime方法测试 - 空值处理 - 【已验证】")
|
||
void testFormatTime_EmptyInput() {
|
||
System.out.println();
|
||
log.info("========== 时间格式化模块测试 - 空值处理 ==========");
|
||
|
||
// 输入参数
|
||
String inputTime = "";
|
||
params.put("fromFormat", "yyyy-MM-dd");
|
||
params.put("toFormat", "yyyy/MM/dd");
|
||
|
||
log.info("输入参数:");
|
||
log.info(" - 时间字符串: '{}' (空字符串)", inputTime);
|
||
log.info(" - 源格式: {}", params.get("fromFormat"));
|
||
log.info(" - 目标格式: {}", params.get("toFormat"));
|
||
|
||
// 执行测试
|
||
Object result = FormatUtil.formatTime(inputTime, params);
|
||
|
||
// 断言验证
|
||
String expectedResult = "";
|
||
log.info("预期结果: ''，（空字符串）");
|
||
log.info("实际结果: '{}'", result);
|
||
assertNotNull(result);
|
||
assertEquals(expectedResult, result);
|
||
log.info("✓ 测试通过 - 空值处理正确");
|
||
}
|
||
|
||
/**
|
||
* 测试formatTime方法 - 异常情况：格式不匹配
|
||
*
|
||
* <p><b>测试目的：</b>验证formatTime方法对格式不匹配情况的处理</p>
|
||
* <p><b>测试场景：</b>时间字符串与格式不匹配</p>
|
||
* <p><b>预期结果：</b>输出原值</p>
|
||
*/
|
||
@Test
|
||
@DisplayName("formatTime方法测试 - 格式不匹配")
|
||
void testFormatTime_FormatMismatch() {
|
||
System.out.println();
|
||
log.info("========== 时间格式化模块测试 - 格式不匹配 ==========");
|
||
|
||
// 输入参数
|
||
String inputTime = "2024 01-15";
|
||
params.put("fromFormat", "yyyy/MM/dd");
|
||
params.put("toFormat", "yyyy-MM-dd");
|
||
|
||
log.info("输入参数:");
|
||
log.info(" - 时间字符串: {}", inputTime);
|
||
log.info(" - 源格式: {}", params.get("fromFormat"));
|
||
log.info(" - 目标格式: {}", params.get("toFormat"));
|
||
log.info(" - 注意: 时间字符串格式与源格式不匹配");
|
||
|
||
// 预期结果
|
||
log.info("预期结果: 非空结果（输出原值）");
|
||
|
||
// 执行测试
|
||
Object result = FormatUtil.formatTime(inputTime, params);
|
||
|
||
// 实际结果
|
||
log.info("实际结果: {}", result);
|
||
|
||
// 断言验证
|
||
assertNotNull(result);
|
||
log.info("✓ 测试通过 - 格式不匹配处理正确");
|
||
}
|
||
|
||
/**
|
||
* 测试extractTimeRange方法 - 正常时间范围提取
|
||
*
|
||
* <p><b>测试目的：</b>验证extractTimeRange方法能够正确提取时间范围</p>
|
||
* <p><b>测试场景：</b>从时间范围字符串中提取开始时间</p>
|
||
* <p><b>预期结果：</b>正确提取开始时间</p>
|
||
*/
|
||
@Test
|
||
@DisplayName("extractTimeRange方法测试 - 正常提取开始时间 - 【已验证】")
|
||
void testExtractTimeRange_ExtractStartTime() {
|
||
System.out.println();
|
||
log.info("========== 时间范围提取模块测试 - 正常提取开始时间 ==========");
|
||
|
||
// 输入参数
|
||
String inputTimeRange = "2024-01-15 14:30:25 ~ 2024-01-15 16:45:30";
|
||
params.put("type", "start");
|
||
|
||
log.info("输入参数:");
|
||
log.info(" - 时间范围字符串: {}", inputTimeRange);
|
||
log.info(" - 提取类型: {}", params.get("type"));
|
||
|
||
// 执行测试
|
||
Object result = FormatUtil.extractTimeRange(inputTimeRange, params);
|
||
|
||
// 断言验证
|
||
String expectedResult = "2024-01-15 14:30:25";
|
||
log.info("预期结果：'{}'", expectedResult);
|
||
log.info("实际结果：'{}'", result);
|
||
assertEquals(expectedResult, result);
|
||
log.info("✓ 测试通过 - 开始时间提取正确");
|
||
}
|
||
|
||
/**
|
||
* 测试extractTimeRange方法 - 边界情况：无分隔符
|
||
*
|
||
* <p><b>测试目的：</b>验证extractTimeRange方法对无分隔符情况的处理</p>
|
||
* <p><b>测试场景：</b>时间范围字符串中无分隔符</p>
|
||
* <p><b>预期结果：</b>返回原始字符串</p>
|
||
*/
|
||
@Test
|
||
@DisplayName("extractTimeRange方法测试 - 无分隔符处理 - 【已验证】")
|
||
void testExtractTimeRange_NoSeparator() {
|
||
System.out.println();
|
||
log.info("========== 时间范围提取模块测试 - 无分隔符处理 ==========");
|
||
|
||
// 输入参数
|
||
String inputTimeRange = "2024-01-15 14:30:25";
|
||
params.put("type", "start");
|
||
|
||
log.info("输入参数:");
|
||
log.info(" - 时间范围字符串: {}", inputTimeRange);
|
||
log.info(" - 提取类型: {}", params.get("type"));
|
||
log.info(" - 注意: 时间范围字符串中无分隔符");
|
||
|
||
// 预期结果
|
||
log.info("预期结果: 非空结果（原始字符串或错误信息）");
|
||
|
||
// 执行测试
|
||
Object result = FormatUtil.extractTimeRange(inputTimeRange, params);
|
||
|
||
// 断言验证
|
||
String expectedResult = "2024-01-15 14:30:25";
|
||
log.info("预期结果: '{}'", expectedResult);
|
||
log.info("实际结果: '{}'", result);
|
||
assertNotNull(result);
|
||
assertEquals(expectedResult, result);
|
||
|
||
log.info("✓ 测试通过 - 无分隔符处理正确");
|
||
}
|
||
|
||
/**
|
||
* 测试dynamicTimeFormat方法 - 标准格式识别
|
||
*
|
||
* <p><b>测试目的：</b>验证dynamicTimeFormat方法能够识别标准时间格式</p>
|
||
* <p><b>测试场景：</b>输入标准ISO格式时间</p>
|
||
* <p><b>预计结果：</b>正确识别并转换为目标格式</p>
|
||
*/
|
||
@Test
|
||
@DisplayName("dynamicTimeFormat方法测试 - 标准格式识别")
|
||
void testDynamicTimeFormat_StandardFormat() {
|
||
System.out.println();
|
||
log.info("========== 动态时间格式化模块测试 - 标准格式识别 ==========");
|
||
|
||
// 输入参数
|
||
String inputTime = "2024-01-15T14:30:25Z";
|
||
params.put("targetFormat", "yyyy-MM-dd HH:mm:ss");
|
||
|
||
log.info("输入参数:");
|
||
log.info(" - 时间字符串: {}", inputTime);
|
||
log.info(" - 目标格式: {}", params.get("targetFormat"));
|
||
|
||
// 预期结果
|
||
String expectedResult = "2024-01-15 14:30:25";
|
||
log.info("预期结果: {}", expectedResult);
|
||
|
||
// 执行测试
|
||
Object result = FormatUtil.dynamicTimeFormat(inputTime, params);
|
||
|
||
// 实际结果
|
||
log.info("实际结果: {}", result);
|
||
|
||
// 断言验证
|
||
assertEquals(expectedResult, result);
|
||
log.info("✓ 测试通过 - 标准格式识别正确");
|
||
}
|
||
|
||
/**
|
||
* 测试dynamicTimeFormat方法 - 中文格式识别
|
||
*
|
||
* <p><b>测试目的：</b>验证dynamicTimeFormat方法能够识别中文时间格式</p>
|
||
* <p><b>测试场景：</b>输入中文格式时间</p>
|
||
* <p><b>预计结果：</b>正确识别并转换为目标格式</p>
|
||
*/
|
||
@Test
|
||
@DisplayName("dynamicTimeFormat方法测试 - 中文格式识别")
|
||
void testDynamicTimeFormat_ChineseFormat() {
|
||
System.out.println();
|
||
log.info("========== 动态时间格式化模块测试 - 中文格式识别 ==========");
|
||
|
||
// 输入参数
|
||
String inputTime = "2024年01月15日 14时30分25秒";
|
||
params.put("targetFormat", "yyyy-MM-dd HH:mm:ss");
|
||
|
||
log.info("输入参数:");
|
||
log.info(" - 时间字符串: {}", inputTime);
|
||
log.info(" - 目标格式: {}", params.get("targetFormat"));
|
||
|
||
// 预期结果
|
||
String expectedResult = "2024-01-15 14:30:25";
|
||
log.info("预期结果: {}", expectedResult);
|
||
|
||
// 执行测试
|
||
Object result = FormatUtil.dynamicTimeFormat(inputTime, params);
|
||
|
||
// 实际结果
|
||
log.info("实际结果: {}", result);
|
||
|
||
// 断言验证
|
||
assertEquals(expectedResult, result);
|
||
log.info("✓ 测试通过 - 中文格式识别正确");
|
||
}
|
||
|
||
/**
|
||
* 测试validateTimeFormat方法 - 格式验证通过
|
||
*
|
||
* <p><b>测试目的：</b>验证validateTimeFormat方法能够正确验证时间格式</p>
|
||
* <p><b>测试场景：</b>时间字符串符合指定格式</p>
|
||
* <p><b>预计结果：</b>返回true</p>
|
||
*/
|
||
@Test
|
||
@DisplayName("validateTimeFormat方法测试 - 格式验证通过")
|
||
void testValidateTimeFormat_ValidFormat() {
|
||
System.out.println();
|
||
log.info("========== 时间格式验证模块测试 - 格式验证通过 ==========");
|
||
|
||
// 输入参数
|
||
String inputTime = "2024-01-15 14:30:25";
|
||
String format = "yyyy-MM-dd HH:mm:ss";
|
||
params.put("format", format);
|
||
|
||
log.info("输入参数:");
|
||
log.info(" - 时间字符串: {}", inputTime);
|
||
log.info(" - 验证格式: {}", format);
|
||
|
||
// 预期结果
|
||
boolean expectedResult = true;
|
||
log.info("预期结果: {}", expectedResult);
|
||
|
||
// 执行测试
|
||
Object result = FormatUtil.validateTimeFormat(inputTime, String.valueOf(params.get("format")));
|
||
|
||
// 实际结果
|
||
log.info("实际结果: {}", result);
|
||
|
||
// 断言验证
|
||
assertEquals(expectedResult, result);
|
||
log.info("✓ 测试通过 - 格式验证正确");
|
||
}
|
||
|
||
/**
|
||
* 测试validateTimeFormat方法 - 格式验证失败
|
||
*
|
||
* <p><b>测试目的：</b>验证validateTimeFormat方法能够检测格式错误</p>
|
||
* <p><b>测试场景：</b>时间字符串不符合指定格式</p>
|
||
* <p><b>预计结果：</b>返回false</p>
|
||
*/
|
||
@Test
|
||
@DisplayName("validateTimeFormat方法测试 - 格式验证失败")
|
||
void testValidateTimeFormat_InvalidFormat() {
|
||
System.out.println();
|
||
log.info("========== 时间格式验证模块测试 - 格式验证失败 ==========");
|
||
|
||
// 输入参数
|
||
String inputTime = "2024/01/15 14:30:25";
|
||
String format = "yyyy-MM-dd HH:mm:ss";
|
||
params.put("format", format);
|
||
|
||
log.info("输入参数:");
|
||
log.info(" - 时间字符串: {}", inputTime);
|
||
log.info(" - 验证格式: {}", format);
|
||
log.info(" - 注意: 时间字符串格式与验证格式不匹配");
|
||
|
||
// 预期结果
|
||
boolean expectedResult = false;
|
||
log.info("预期结果: {}", expectedResult);
|
||
|
||
// 执行测试
|
||
Object result = FormatUtil.validateTimeFormat(inputTime, String.valueOf(params.get("format")));
|
||
|
||
// 实际结果
|
||
log.info("实际结果: {}", result);
|
||
|
||
// 断言验证
|
||
assertEquals(expectedResult, result);
|
||
log.info("✓ 测试通过 - 格式验证失败检测正确");
|
||
}
|
||
|
||
// ==================== 字符串处理模块测试 ====================
|
||
|
||
/**
|
||
* 测试substring方法 - 正常字符串截取
|
||
*
|
||
* <p><b>测试目的：</b>验证substring方法能够正确截取字符串</p>
|
||
* <p><b>测试场景：</b>按起始位置和长度截取字符串</p>
|
||
* <p><b>预计结果：</b>截取结果正确</p>
|
||
*/
|
||
@Test
|
||
@DisplayName("substring方法测试 - 正常截取")
|
||
void testSubstring_NormalCase() {
|
||
System.out.println();
|
||
log.info("========== 字符串截取模块测试 - 正常截取 ==========");
|
||
|
||
// 输入参数
|
||
String inputString = "Hello World";
|
||
int start = 6;
|
||
int length = 5;
|
||
params.put("start", start);
|
||
params.put("length", length);
|
||
|
||
log.info("输入参数:");
|
||
log.info(" - 输入字符串: {}", inputString);
|
||
log.info(" - 起始位置: {}", start);
|
||
log.info(" - 截取长度: {}", length);
|
||
|
||
// 预期结果
|
||
String expectedResult = "World";
|
||
log.info("预期结果: {}", expectedResult);
|
||
|
||
// 执行测试
|
||
Object result = FormatUtil.substring(inputString, params);
|
||
|
||
// 实际结果
|
||
log.info("实际结果: {}", result);
|
||
|
||
// 断言验证
|
||
assertEquals(expectedResult, result);
|
||
log.info("✓ 测试通过 - 字符串截取正确");
|
||
}
|
||
|
||
/**
|
||
* 测试substring方法 - 边界情况：起始位置超出范围
|
||
*
|
||
* <p><b>测试目的：</b>验证substring方法对起始位置超界的处理</p>
|
||
* <p><b>测试场景：</b>起始位置大于字符串长度</p>
|
||
* <p><b>预计结果：</b>返回空字符串或错误信息</p>
|
||
*/
|
||
@Test
|
||
@DisplayName("substring方法测试 - 起始位置超界")
|
||
void testSubstring_StartOutOfBounds() {
|
||
System.out.println();
|
||
log.info("========== 字符串截取模块测试 - 起始位置超界 ==========");
|
||
|
||
// 输入参数
|
||
String inputString = "Hello";
|
||
int start = 10;
|
||
int length = 5;
|
||
params.put("start", start);
|
||
params.put("length", length);
|
||
|
||
log.info("输入参数:");
|
||
log.info(" - 输入字符串: {}", inputString);
|
||
log.info(" - 起始位置: {}", start);
|
||
log.info(" - 截取长度: {}", length);
|
||
log.info(" - 注意: 起始位置大于字符串长度");
|
||
|
||
// 预期结果
|
||
log.info("预期结果: 非空结果（空字符串或错误信息）");
|
||
|
||
// 执行测试
|
||
Object result = FormatUtil.substring(inputString, params);
|
||
|
||
// 实际结果
|
||
log.info("实际结果: {}", result);
|
||
|
||
// 断言验证
|
||
assertNotNull(result);
|
||
log.info("✓ 测试通过 - 起始位置超界处理正确");
|
||
}
|
||
|
||
/**
|
||
* 测试regexReplace方法 - 正则表达式替换
|
||
*
|
||
* <p><b>测试目的：</b>验证regexReplace方法能够正确进行正则替换</p>
|
||
* <p><b>测试场景：</b>替换字符串中的数字</p>
|
||
* <p><b>预计结果：</b>替换结果正确</p>
|
||
*/
|
||
@Test
|
||
@DisplayName("regexReplace方法测试 - 正则替换 - 【已验证】")
|
||
void testRegexReplace_NormalCase() {
|
||
System.out.println();
|
||
log.info("========== 正则表达式替换模块测试 - 正则替换 ==========");
|
||
|
||
// 输入参数
|
||
String inputString = "abc123def456";
|
||
String regex = "\\d+";
|
||
String replacement = "*";
|
||
params.put("pattern", regex);
|
||
params.put("replacement", replacement);
|
||
|
||
log.info("输入参数:");
|
||
log.info(" - 输入字符串: {}", inputString);
|
||
log.info(" - 正则表达式: {}", regex);
|
||
log.info(" - 替换字符串: {}", replacement);
|
||
|
||
// 执行测试
|
||
Object result = FormatUtil.regexReplace(inputString, params);
|
||
|
||
// 断言验证
|
||
String expectedResult = "abc*def*";
|
||
log.info("预期结果: {}", expectedResult);
|
||
log.info("实际结果: {}", result);
|
||
assertEquals(expectedResult, result);
|
||
log.info("✓ 测试通过 - 正则替换正确");
|
||
}
|
||
|
||
/**
|
||
* 测试regexReplace方法 - 正则表达式替换
|
||
*
|
||
* <p><b>测试目的：</b>验证regexReplace方法能够正确进行正则替换</p>
|
||
* <p><b>测试场景：</b>替换字符串中的数字</p>
|
||
* <p><b>预计结果：</b>替换结果正确</p>
|
||
*/
|
||
@Test
|
||
@DisplayName("regexReplace方法测试 - 三种测试 - 【已验证】")
|
||
void testRegexReplace_NormalCase3() {
|
||
System.out.println();
|
||
log.info("========== 正则表达式替换模块测试 - 正则替换 ==========");
|
||
|
||
// 输入参数
|
||
String inputString = "abc123def456";
|
||
String regex = "\\d+";
|
||
String replacement = "*";
|
||
params.put("pattern", regex);
|
||
params.put("replacement", replacement);
|
||
|
||
|
||
// 测试用例1：数字替换
|
||
Map<String, Object> params1 = new HashMap<>();
|
||
params1.put("pattern", "\\d+");
|
||
params1.put("replacement", "*");
|
||
String result1 = FormatUtil.regexReplace("abc123def456", params1);
|
||
log.info("实际结果 (1): " + result1);
|
||
// 断言验证
|
||
String expectedResult1 = "abc*def*";
|
||
log.info("预期结果：'{}'", expectedResult1);
|
||
log.info("实际结果：'{}'", result1);
|
||
assertEquals(expectedResult1, result1);
|
||
|
||
// 测试用例2：分组引用替换
|
||
Map<String, Object> params2 = new HashMap<>();
|
||
params2.put("pattern", "(\\d+)-(\\d+)");
|
||
params2.put("replacement", "$2到$1");
|
||
String result2 = FormatUtil.regexReplace("电话: 123-456", params2);
|
||
log.info("实际结果 (2): " + result2);
|
||
// 断言验证
|
||
String expectedResult2 = "电话: 456到123";
|
||
log.info("预期结果：'{}'", expectedResult2);
|
||
log.info("实际结果：'{}'", result2);
|
||
assertEquals(expectedResult2, result2);
|
||
|
||
// 测试用例3：大小写不敏感
|
||
Map<String, Object> params3 = new HashMap<>();
|
||
params3.put("pattern", "hello");
|
||
params3.put("replacement", "HI");
|
||
params3.put("flags", "CASE_INSENSITIVE");
|
||
String result3 = FormatUtil.regexReplace("Hello World", params3);
|
||
log.info("实际结果 (3): " + result3);
|
||
// 断言验证
|
||
String expectedResult3 = "HI World";
|
||
log.info("预期结果：'{}'", expectedResult3);
|
||
log.info("实际结果：'{}'", result3);
|
||
assertEquals(expectedResult3, result3);
|
||
log.info("✓ 测试通过 - 正则替换正确");
|
||
}
|
||
|
||
/**
|
||
* 测试toUpperCase方法 - 大小写转换
|
||
*
|
||
* <p><b>测试目的：</b>验证toUpperCase方法能够正确转换为大写</p>
|
||
* <p><b>测试场景：</b>小写字符串转大写</p>
|
||
* <p><b>预计结果：</b>转换结果正确</p>
|
||
*/
|
||
@Test
|
||
@DisplayName("toUpperCase方法测试 - 大小写转换")
|
||
void testToUpperCase_NormalCase() {
|
||
System.out.println();
|
||
log.info("========== 字符串大小写转换模块测试 - 大小写转换 ==========");
|
||
|
||
// 输入参数
|
||
String inputString = "hello world";
|
||
|
||
log.info("输入参数:");
|
||
log.info(" - 输入字符串: {}", inputString);
|
||
|
||
// 预期结果
|
||
String expectedResult = "HELLO WORLD";
|
||
log.info("预期结果: {}", expectedResult);
|
||
|
||
// 执行测试
|
||
Object result = FormatUtil.toUpperCase(inputString, params);
|
||
|
||
// 实际结果
|
||
log.info("实际结果: {}", result);
|
||
|
||
// 断言验证
|
||
assertEquals(expectedResult, result);
|
||
log.info("✓ 测试通过 - 大小写转换正确");
|
||
}
|
||
|
||
/**
|
||
* 测试trim方法 - 去除空格
|
||
*
|
||
* <p><b>测试目的：</b>验证trim方法能够正确去除首尾空格</p>
|
||
* <p><b>测试场景：</b>字符串前后有空格</p>
|
||
* <p><b>预计结果：</b>去除空格后结果正确</p>
|
||
*/
|
||
@Test
|
||
@DisplayName("trim方法测试 - 去除空格 - 【已验证】")
|
||
void testTrim_NormalCase() {
|
||
System.out.println();
|
||
log.info("========== 字符串空格处理模块测试 - 去除空格 ==========");
|
||
|
||
// 输入参数
|
||
String inputString = " hello world ";
|
||
|
||
log.info("输入参数:");
|
||
log.info(" - 输入字符串: '{}'", inputString);
|
||
log.info(" - 注意: 字符串前后有空格");
|
||
|
||
// 执行测试
|
||
Object result = FormatUtil.trim(inputString, params);
|
||
|
||
// 断言验证
|
||
String expectedResult = "hello world";
|
||
log.info("预期结果: '{}'", expectedResult);
|
||
log.info("实际结果: '{}'", result);
|
||
assertEquals(expectedResult, result);
|
||
log.info("✓ 测试通过 - 空格去除正确");
|
||
}
|
||
|
||
/**
|
||
* 测试stealBeamsAndReplacePillars方法 - 基础字符串替换
|
||
*
|
||
* <p><b>测试目的：</b>验证stealBeamsAndReplacePillars方法能够正确进行字符串替换</p>
|
||
* <p><b>测试场景：</b>使用基础替换功能</p>
|
||
* <p><b>预计结果：</b>替换结果正确</p>
|
||
*/
|
||
@Test
|
||
@DisplayName("stealBeamsAndReplacePillars方法测试 - 基础替换")
|
||
void testStealBeamsAndReplacePillars_BasicReplacement() {
|
||
System.out.println();
|
||
log.info("========== 字符串替换模块测试 - 基础替换 ==========");
|
||
|
||
// 输入参数
|
||
String inputString = "hello world";
|
||
Map<String, String> replacementMap = new HashMap<>();
|
||
replacementMap.put("hello", "hi");
|
||
replacementMap.put("world", "universe");
|
||
|
||
log.info("输入参数:");
|
||
log.info(" - 输入字符串: {}", inputString);
|
||
log.info(" - 替换映射: {}", replacementMap);
|
||
|
||
// 预期结果
|
||
String expectedResult = "hi universe";
|
||
log.info("预期结果: {}", expectedResult);
|
||
|
||
// 执行测试
|
||
String result = FormatUtil.stealBeamsAndReplacePillars(inputString, replacementMap);
|
||
|
||
// 实际结果
|
||
log.info("实际结果: {}", result);
|
||
|
||
// 断言验证
|
||
assertEquals(expectedResult, result);
|
||
log.info("✓ 测试通过 - 基础字符串替换正确");
|
||
}
|
||
|
||
/**
|
||
* 测试stealBeamsAndReplacePillars方法 - 大小写敏感替换
|
||
*
|
||
* <p><b>测试目的：</b>验证stealBeamsAndReplacePillars方法的大小写敏感功能</p>
|
||
* <p><b>测试场景：</b>大小写敏感模式下的替换</p>
|
||
* <p><b>预计结果：</b>大小写敏感替换结果正确</p>
|
||
*/
|
||
@Test
|
||
@DisplayName("stealBeamsAndReplacePillars方法测试 - 大小写敏感 - 【已验证】")
|
||
void testStealBeamsAndReplacePillars_CaseSensitive() {
|
||
System.out.println();
|
||
log.info("========== 字符串替换模块测试 - 大小写敏感替换 ==========");
|
||
|
||
// 输入参数
|
||
String inputString = "hello world";
|
||
Map<String, String> replacementMap = new HashMap<>();
|
||
replacementMap.put("Hello", "Hi");
|
||
replacementMap.put("world", "universe");
|
||
boolean caseSensitive = true;
|
||
|
||
log.info("输入参数:");
|
||
log.info(" - 输入字符串: {}", inputString);
|
||
log.info(" - 替换映射: {}", JSON.toJSONString(replacementMap));
|
||
log.info(" - 大小写敏感: {}", caseSensitive);
|
||
log.info(" - 注意: 'Hello'与'hello'大小写不匹配");
|
||
|
||
// 执行测试
|
||
String result = FormatUtil.stealBeamsAndReplacePillars(inputString, replacementMap, caseSensitive);
|
||
|
||
// 断言验证
|
||
String expectedResult = "hello universe";
|
||
log.info("预期结果：'{}'", expectedResult);
|
||
log.info("实际结果：'{}'", result);
|
||
assertEquals(expectedResult, result);
|
||
log.info("✓ 测试通过 - 大小写敏感替换正确");
|
||
}
|
||
|
||
/**
|
||
* 测试stealBeamsAndReplacePillars方法 - 整词匹配替换
|
||
*
|
||
* <p><b>测试目的：</b>验证stealBeamsAndReplacePillars方法的整词匹配功能</p>
|
||
* <p><b>测试场景：</b>整词匹配模式下的替换</p>
|
||
* <p><b>预计结果：</b>整词匹配替换结果正确</p>
|
||
*/
|
||
@Test
|
||
@DisplayName("stealBeamsAndReplacePillars方法测试 - 整词匹配")
|
||
void testStealBeamsAndReplacePillars_WholeWord() {
|
||
System.out.println();
|
||
log.info("========== 字符串替换模块测试 - 整词匹配替换 ==========");
|
||
|
||
// 输入参数
|
||
String inputString = "category cat catfish";
|
||
Map<String, String> replacementMap = new HashMap<>();
|
||
replacementMap.put("cat", "dog");
|
||
boolean caseSensitive = false;
|
||
boolean wholeWord = true;
|
||
|
||
log.info("输入参数:");
|
||
log.info(" - 输入字符串: {}", inputString);
|
||
log.info(" - 替换映射: {}", replacementMap);
|
||
log.info(" - 大小写敏感: {}", caseSensitive);
|
||
log.info(" - 整词匹配: {}", wholeWord);
|
||
log.info(" - 注意: 只有独立的'cat'会被替换");
|
||
|
||
// 预期结果
|
||
String expectedResult = "category dog catfish";
|
||
log.info("预期结果: {}", expectedResult);
|
||
|
||
// 执行测试
|
||
String result = FormatUtil.stealBeamsAndReplacePillars(inputString, replacementMap, caseSensitive, wholeWord);
|
||
|
||
// 实际结果
|
||
log.info("实际结果: {}", result);
|
||
|
||
// 断言验证
|
||
assertEquals(expectedResult, result);
|
||
log.info("✓ 测试通过 - 整词匹配替换正确");
|
||
}
|
||
|
||
// ==================== 坐标系转换模块测试 ====================
|
||
|
||
/**
|
||
* 测试coordinateConvert方法 - 度分秒转十进制
|
||
*
|
||
* <p><b>测试目的：</b>验证coordinateConvert方法能够正确转换度分秒为十进制</p>
|
||
* <p><b>测试场景：</b>度分秒格式坐标转十进制</p>
|
||
* <p><b>预计结果：</b>转换结果正确</p>
|
||
*/
|
||
@Test
|
||
@DisplayName("coordinateConvert方法测试 - 度分秒转十进制")
|
||
void testCoordinateConvert_DmsToDecimal() {
|
||
System.out.println();
|
||
log.info("========== 坐标系转换模块测试 - 度分秒转十进制 ==========");
|
||
|
||
// 输入参数
|
||
String coordinate = "116°23'45.67\"";
|
||
params.put("fromType", "dms");
|
||
params.put("toType", "decimal");
|
||
|
||
log.info("输入参数:");
|
||
log.info(" - 坐标值: {}", coordinate);
|
||
log.info(" - 源格式: {}", params.get("fromType"));
|
||
log.info(" - 目标格式: {}", params.get("toType"));
|
||
log.info(" - 注意: 116°23'45.67\" ≈ 116.396019");
|
||
|
||
// 预期结果
|
||
log.info("预期结果: 非空转换结果");
|
||
|
||
// 执行测试
|
||
Object result = FormatUtil.coordinateConvert(coordinate, params);
|
||
|
||
// 实际结果
|
||
log.info("实际结果: {}", result);
|
||
|
||
// 断言验证
|
||
assertNotNull(result);
|
||
log.info("✓ 测试通过 - 度分秒转十进制转换正确");
|
||
}
|
||
|
||
/**
|
||
* 测试coordinateConvert方法 - 十进制转度分秒
|
||
*
|
||
* <p><b>测试目的：</b>验证coordinateConvert方法能够正确转换十进制为度分秒</p>
|
||
* <p><b>测试场景：</b>十进制坐标转度分秒格式</p>
|
||
* <p><b>预计结果：</b>转换结果正确</p>
|
||
*/
|
||
@Test
|
||
@DisplayName("coordinateConvert方法测试 - 十进制转度分秒 - 【已验证】")
|
||
void testCoordinateConvert_DecimalToDms() {
|
||
System.out.println();
|
||
log.info("========== 坐标系转换模块测试 - 十进制转度分秒 ==========");
|
||
|
||
// 输入参数
|
||
String coordinate = "116.396019";
|
||
params.put("fromFormat", "decimal");
|
||
params.put("toFormat", "dms");
|
||
params.put("precision", "2");
|
||
|
||
log.info("输入参数:");
|
||
log.info(" - 坐标值: {}", coordinate);
|
||
log.info(" - 源格式: {}", params.get("fromFormat"));
|
||
log.info(" - 目标格式: {}", params.get("toFormat"));
|
||
log.info(" - 注意: 116.396019 ≈ 116°23'45.67\"");
|
||
|
||
// 执行测试
|
||
Object result = FormatUtil.coordinateConvert(coordinate, params);
|
||
|
||
// 断言验证
|
||
String expectedResult = "116°23'45.67\"";
|
||
log.info("预期结果：'{}'", expectedResult);
|
||
log.info("实际结果：'{}'", result);
|
||
assertEquals(expectedResult, result);
|
||
log.info("✓ 测试通过 - 十进制转度分秒转换正确");
|
||
}
|
||
|
||
/**
|
||
* 测试cartesianConvert方法 - 直角坐标转极坐标
|
||
*
|
||
* <p><b>测试目的：</b>验证cartesianConvert方法能够正确转换直角坐标为极坐标</p>
|
||
* <p><b>测试场景：</b>直角坐标(x,y)转极坐标(r,θ)</p>
|
||
* <p><b>预计结果：</b>转换结果正确</p>
|
||
*/
|
||
@Test
|
||
@DisplayName("cartesianConvert方法测试 - 直角坐标转极坐标")
|
||
void testCartesianConvert_RectangularToPolar() {
|
||
System.out.println();
|
||
log.info("========== 坐标系转换模块测试 - 直角坐标转极坐标 ==========");
|
||
|
||
// 输入参数
|
||
String coordinate = "3,4";
|
||
params.put("x", 3);
|
||
params.put("y", 4);
|
||
params.put("fromType", "rectangular");
|
||
params.put("toType", "polar");
|
||
|
||
log.info("输入参数:");
|
||
log.info(" - 坐标值: {}", coordinate);
|
||
log.info(" - x坐标: {}", params.get("x"));
|
||
log.info(" - y坐标: {}", params.get("y"));
|
||
log.info(" - 源格式: {}", params.get("fromType"));
|
||
log.info(" - 目标格式: {}", params.get("toType"));
|
||
log.info(" - 注意: (3,4) → r=5, θ≈53.13°");
|
||
|
||
// 预期结果
|
||
log.info("预期结果: 非空转换结果");
|
||
|
||
// 执行测试
|
||
Object result = FormatUtil.cartesianConvert(coordinate, params);
|
||
|
||
// 实际结果
|
||
log.info("实际结果: {}", result);
|
||
|
||
// 断言验证
|
||
assertNotNull(result);
|
||
log.info("✓ 测试通过 - 直角坐标转极坐标转换正确");
|
||
}
|
||
|
||
/**
|
||
* 测试normalizeCoordinate方法 - 坐标格式标准化
|
||
*
|
||
* <p><b>测试目的：</b>验证normalizeCoordinate方法能够标准化坐标格式</p>
|
||
* <p><b>测试场景：</b>统一不同格式的坐标表示</p>
|
||
* <p><b>预计结果：</b>标准化结果正确</p>
|
||
*/
|
||
@Test
|
||
@DisplayName("normalizeCoordinate方法测试 - 坐标标准化")
|
||
void testNormalizeCoordinate_NormalCase() {
|
||
System.out.println();
|
||
log.info("========== 坐标系转换模块测试 - 坐标格式标准化 ==========");
|
||
|
||
// 输入参数
|
||
String coordinate = "116.396019,39.909604";
|
||
params.put("format", "decimal");
|
||
|
||
log.info("输入参数:");
|
||
log.info(" - 坐标值: {}", coordinate);
|
||
log.info(" - 目标格式: {}", params.get("format"));
|
||
|
||
// 预期结果
|
||
log.info("预期结果: 非空标准化结果");
|
||
|
||
// 执行测试
|
||
Object result = FormatUtil.normalizeCoordinate(coordinate, params);
|
||
|
||
// 实际结果
|
||
log.info("实际结果: {}", result);
|
||
|
||
// 断言验证
|
||
assertNotNull(result);
|
||
log.info("✓ 测试通过 - 坐标格式标准化正确");
|
||
}
|
||
|
||
// ==================== 极值/边界值检查处理模块测试 ====================
|
||
|
||
/**
|
||
* 测试boundaryCheck方法 - 正常范围检查
|
||
*
|
||
* <p><b>测试目的：</b>验证boundaryCheck方法能够正确检查数值范围</p>
|
||
* <p><b>测试场景：</b>数值在有效范围内</p>
|
||
* <p><b>预计结果：</b>返回原始值</p>
|
||
*/
|
||
@Test
|
||
@DisplayName("boundaryCheck方法测试 - 正常范围检查")
|
||
void testBoundaryCheck_WithinRange() {
|
||
System.out.println();
|
||
log.info("========== 极值检查模块测试 - 正常范围检查 ==========");
|
||
|
||
// 输入参数
|
||
int inputValue = 50;
|
||
params.put("min", 0);
|
||
params.put("max", 100);
|
||
params.put("strategy", "truncate");
|
||
|
||
log.info("输入参数:");
|
||
log.info(" - 输入值: {}", inputValue);
|
||
log.info(" - 最小值: {}", params.get("min"));
|
||
log.info(" - 最大值: {}", params.get("max"));
|
||
log.info(" - 处理策略: {}", params.get("strategy"));
|
||
|
||
// 预期结果
|
||
int expectedResult = 50;
|
||
log.info("预期结果: {}", expectedResult);
|
||
|
||
// 执行测试
|
||
Object result = FormatUtil.boundaryCheck(inputValue, params);
|
||
|
||
// 实际结果
|
||
log.info("实际结果: {}", result);
|
||
|
||
// 断言验证
|
||
assertEquals(expectedResult, result);
|
||
log.info("✓ 测试通过 - 正常范围检查正确");
|
||
}
|
||
|
||
/**
|
||
* 测试boundaryCheck方法 - 超出上限处理
|
||
*
|
||
* <p><b>测试目的：</b>验证boundaryCheck方法对超出上限的处理</p>
|
||
* <p><b>测试场景：</b>数值大于最大值，使用截断策略</p>
|
||
* <p><b>预计结果：</b>返回最大值</p>
|
||
*/
|
||
@Test
|
||
@DisplayName("boundaryCheck方法测试 - 超出上限截断")
|
||
void testBoundaryCheck_AboveMaxTruncate() {
|
||
System.out.println();
|
||
log.info("========== 极值检查模块测试 - 超出上限截断处理 ==========");
|
||
|
||
// 输入参数
|
||
int inputValue = 150;
|
||
params.put("min", 0);
|
||
params.put("max", 100);
|
||
params.put("strategy", "truncate");
|
||
|
||
log.info("输入参数:");
|
||
log.info(" - 输入值: {}", inputValue);
|
||
log.info(" - 最小值: {}", params.get("min"));
|
||
log.info(" - 最大值: {}", params.get("max"));
|
||
log.info(" - 处理策略: {}", params.get("strategy"));
|
||
log.info(" - 注意: 输入值150大于最大值100，应截断为100");
|
||
|
||
// 预期结果
|
||
int expectedResult = 100;
|
||
log.info("预期结果: {}", expectedResult);
|
||
|
||
// 执行测试
|
||
Object result = FormatUtil.boundaryCheck(inputValue, params);
|
||
|
||
// 实际结果
|
||
log.info("实际结果: {}", result);
|
||
|
||
// 断言验证
|
||
assertEquals(expectedResult, result);
|
||
log.info("✓ 测试通过 - 超出上限截断处理正确");
|
||
}
|
||
|
||
/**
|
||
* 测试boundaryCheck方法 - 超出下限处理
|
||
*
|
||
* <p><b>测试目的：</b>验证boundaryCheck方法对超出下限的处理</p>
|
||
* <p><b>测试场景：</b>数值小于最小值，使用默认值策略</p>
|
||
* <p><b>预计结果：</b>返回默认值</p>
|
||
*/
|
||
@Test
|
||
@DisplayName("boundaryCheck方法测试 - 超出下限默认值")
|
||
void testBoundaryCheck_BelowMinDefault() {
|
||
System.out.println();
|
||
log.info("========== 极值检查模块测试 - 超出下限默认值处理 ==========");
|
||
|
||
// 输入参数
|
||
int inputValue = -10;
|
||
params.put("min", 0);
|
||
params.put("max", 100);
|
||
params.put("strategy", "default");
|
||
params.put("defaultValue", 0);
|
||
|
||
log.info("输入参数:");
|
||
log.info(" - 输入值: {}", inputValue);
|
||
log.info(" - 最小值: {}", params.get("min"));
|
||
log.info(" - 最大值: {}", params.get("max"));
|
||
log.info(" - 处理策略: {}", params.get("strategy"));
|
||
log.info(" - 默认值: {}", params.get("defaultValue"));
|
||
log.info(" - 注意: 输入值-10小于最小值0，应返回默认值0");
|
||
|
||
// 预期结果
|
||
int expectedResult = 0;
|
||
log.info("预期结果: {}", expectedResult);
|
||
|
||
// 执行测试
|
||
Object result = FormatUtil.boundaryCheck(inputValue, params);
|
||
|
||
// 实际结果
|
||
log.info("实际结果: {}", result);
|
||
|
||
// 断言验证
|
||
assertEquals(expectedResult, result);
|
||
log.info("✓ 测试通过 - 超出下限默认值处理正确");
|
||
}
|
||
|
||
/**
|
||
* 测试boundaryCheck方法 - 异常值检测
|
||
*
|
||
* <p><b>测试目的：</b>验证boundaryCheck方法能够检测异常值</p>
|
||
* <p><b>测试场景：</b>输入NaN值</p>
|
||
* <p><b>预计结果：</b>返回错误信息或默认值</p>
|
||
*/
|
||
@Test
|
||
@DisplayName("boundaryCheck方法测试 - 异常值检测")
|
||
void testBoundaryCheck_NaNValue() {
|
||
System.out.println();
|
||
log.info("========== 极值检查模块测试 - 异常值检测 ==========");
|
||
|
||
// 输入参数
|
||
double inputValue = Double.NaN;
|
||
params.put("min", 0);
|
||
params.put("max", 100);
|
||
params.put("strategy", "error");
|
||
|
||
log.info("输入参数:");
|
||
log.info(" - 输入值: {}", inputValue);
|
||
log.info(" - 最小值: {}", params.get("min"));
|
||
log.info(" - 最大值: {}", params.get("max"));
|
||
log.info(" - 处理策略: {}", params.get("strategy"));
|
||
log.info(" - 注意: 输入值为NaN(Not a Number)");
|
||
|
||
// 预期结果
|
||
log.info("预期结果: 非空结果（错误信息或默认值）");
|
||
|
||
// 执行测试
|
||
Object result = FormatUtil.boundaryCheck(inputValue, params);
|
||
|
||
// 实际结果
|
||
log.info("实际结果: {}", result);
|
||
|
||
// 断言验证
|
||
assertNotNull(result);
|
||
log.info("✓ 测试通过 - 异常值检测正确");
|
||
}
|
||
|
||
// ==================== 数据KV映射处理模块测试 ====================
|
||
|
||
/**
|
||
* 测试kvMapping方法 - 键值映射转换
|
||
*
|
||
* <p><b>测试目的：</b>验证kvMapping方法能够正确进行键值映射</p>
|
||
* <p><b>测试场景：</b>蛇形命名转驼峰命名</p>
|
||
* <p><b>预计结果：</b>转换结果正确</p>
|
||
*/
|
||
@Test
|
||
@DisplayName("kvMapping方法测试 - 键名格式转换 - 【验证中】")
|
||
void testKvMapping_KeyFormatConversion() {
|
||
System.out.println();
|
||
log.info("========== 数据KV映射模块测试 - 键名格式转换 ==========");
|
||
|
||
// 输入参数
|
||
Map<String, Object> inputMap = new HashMap<>();
|
||
inputMap.put("user_name", "张三");
|
||
inputMap.put("user_age", 25);
|
||
params.put("keyFormat", "snake_to_camel");
|
||
|
||
log.info("输入参数:");
|
||
log.info(" - 输入Map: {}", inputMap);
|
||
log.info(" - 键名格式转换: {}", params.get("keyFormat"));
|
||
log.info(" - 注意: 蛇形命名(user_name)转驼峰命名(userName)");
|
||
|
||
// 预期结果
|
||
log.info("预期结果: 非空转换结果");
|
||
|
||
// 执行测试
|
||
Object result = FormatUtil.kvMapping(inputMap, params);
|
||
|
||
// 实际结果
|
||
log.info("实际结果: {}", result);
|
||
|
||
// 断言验证
|
||
assertNotNull(result);
|
||
log.info("✓ 测试通过 - 键名格式转换正确");
|
||
}
|
||
|
||
/**
|
||
* 测试kvMapping方法 - 数据过滤
|
||
*
|
||
* <p><b>测试目的：</b>验证kvMapping方法能够正确过滤数据</p>
|
||
* <p><b>测试场景：</b>过滤掉值为null的键值对</p>
|
||
* <p><b>预计结果：</b>过滤结果正确</p>
|
||
*/
|
||
@Test
|
||
@DisplayName("kvMapping方法测试 - 数据过滤")
|
||
void testKvMapping_DataFiltering() {
|
||
System.out.println();
|
||
log.info("========== 数据KV映射模块测试 - 数据过滤 ==========");
|
||
|
||
// 输入参数
|
||
Map<String, Object> inputMap = new LinkedHashMap<>();
|
||
inputMap.put("name", "张三");
|
||
inputMap.put("age", 25);
|
||
inputMap.put("address", null);
|
||
params.put("filter", "not_null");
|
||
|
||
log.info("输入参数:");
|
||
log.info(" - 输入Map: {}", inputMap);
|
||
log.info(" - 过滤条件: {}", params.get("filter"));
|
||
log.info(" - 注意: 过滤掉值为null的键值对");
|
||
|
||
// 预期结果
|
||
log.info("预期结果: 非空过滤结果");
|
||
|
||
// 执行测试
|
||
Object result = FormatUtil.kvMapping(inputMap, params);
|
||
|
||
// 实际结果
|
||
log.info("实际结果: {}", result);
|
||
|
||
// 断言验证
|
||
assertNotNull(result instanceof Map);
|
||
if(result instanceof Map) {
|
||
boolean flag = false;
|
||
}
|
||
log.info("✓ 测试通过 - 数据过滤正确");
|
||
}
|
||
|
||
/**
|
||
* 测试kvMapping方法 - 分组排序
|
||
*
|
||
* <p><b>测试目的：</b>验证kvMapping方法能够正确分组排序数据</p>
|
||
* <p><b>测试场景：</b>按键名升序排序</p>
|
||
* <p><b>预计结果：</b>排序结果正确</p>
|
||
*/
|
||
@Test
|
||
@DisplayName("kvMapping方法测试 - 分组排序 - 【已验证】")
|
||
void testKvMapping_GroupingSorting() {
|
||
System.out.println();
|
||
log.info("========== 数据KV映射模块测试 - 分组排序 ==========");
|
||
|
||
// 输入参数
|
||
Map<String, Object> inputMap = new LinkedHashMap<>();
|
||
inputMap.put("z_key", "value3");
|
||
inputMap.put("a_key", "value1");
|
||
inputMap.put("m_key", "value2");
|
||
params.put("sort", "key_asc");
|
||
|
||
log.info("输入参数:");
|
||
log.info(" - 输入Map: {}", inputMap);
|
||
log.info(" - 排序方式: {}", params.get("sort"));
|
||
log.info(" - 注意: 按键名升序排序(a_key → m_key → z_key)");
|
||
|
||
// 预期结果
|
||
log.info("预期结果: 非空排序结果");
|
||
|
||
// 执行测试
|
||
Object result = FormatUtil.kvMapping(inputMap, params);
|
||
|
||
// 实际结果
|
||
log.info("实际结果: {}", result);
|
||
|
||
// 断言验证
|
||
Map<String, Object> expectedResult = new LinkedHashMap<>() {{
|
||
put("a_key", "value1");
|
||
put("m_key", "value2");
|
||
put("z_key", "value3");
|
||
}};
|
||
String expectedResultString = JSON.toJSONString(expectedResult);
|
||
String resultString = JSON.toJSONString(result);
|
||
log.info("预期结果：'{}'", expectedResult);
|
||
log.info("实际结果：'{}'", result);
|
||
assertEquals(expectedResultString, resultString, "排序失败");
|
||
log.info("✓ 测试通过 - 分组排序正确");
|
||
}
|
||
|
||
/**
|
||
* 测试kvMapping方法 - 输出格式转换
|
||
*
|
||
* <p><b>测试目的：</b>验证kvMapping方法能够正确转换输出格式</p>
|
||
* <p><b>测试场景：</b>Map转JSON字符串</p>
|
||
* <p><b>预计结果：</b>JSON格式正确</p>
|
||
*/
|
||
@Test
|
||
@DisplayName("kvMapping方法测试 - 输出格式转换")
|
||
void testKvMapping_OutputFormat() {
|
||
System.out.println();
|
||
log.info("========== 数据KV映射模块测试 - 输出格式转换 ==========");
|
||
|
||
// 输入参数
|
||
Map<String, Object> inputMap = new HashMap<>();
|
||
inputMap.put("name", "张三");
|
||
inputMap.put("age", 25);
|
||
params.put("outputFormat", "json");
|
||
|
||
log.info("输入参数:");
|
||
log.info(" - 输入Map: {}", inputMap);
|
||
log.info(" - 输出格式: {}", params.get("outputFormat"));
|
||
log.info(" - 注意: Map转换为JSON字符串格式");
|
||
|
||
// 预期结果
|
||
log.info("预期结果: JSON字符串包含'name'和'张三'字段");
|
||
|
||
// 执行测试
|
||
Object result = FormatUtil.kvMapping(inputMap, params);
|
||
|
||
// 实际结果
|
||
log.info("实际结果: {}", result);
|
||
|
||
// 断言验证
|
||
assertNotNull(result);
|
||
assertTrue(result.toString().contains("name") && result.toString().contains("张三"));
|
||
log.info("✓ 测试通过 - 输出格式转换正确");
|
||
}
|
||
|
||
// ==================== 综合测试用例 ====================
|
||
|
||
/**
|
||
* 综合测试 - 多方法组合使用
|
||
*
|
||
* <p><b>测试目的：</b>验证多个方法组合使用的正确性</p>
|
||
* <p><b>测试场景：</b>时间格式化后截取字符串，再进行边界检查</p>
|
||
* <p><b>预计结果：</b>组合处理结果正确</p>
|
||
*/
|
||
@Test
|
||
@DisplayName("综合测试 - 多方法组合使用")
|
||
void testMultipleMethods_CombinedUsage() {
|
||
System.out.println();
|
||
log.info("========== 综合测试 - 多方法组合使用 ==========");
|
||
|
||
log.info("测试流程: 时间格式化 → 字符串截取 → 边界检查");
|
||
|
||
// 第一步：时间格式化
|
||
log.info("第一步 - 时间格式化:");
|
||
Map<String, Object> timeParams = new HashMap<>();
|
||
timeParams.put("fromFormat", "yyyy-MM-dd HH:mm:ss");
|
||
timeParams.put("toFormat", "yyyy/MM/dd");
|
||
String inputTime = "2024-01-15 14:30:25";
|
||
log.info(" - 输入时间: {}", inputTime);
|
||
log.info(" - 源格式: {}", timeParams.get("fromFormat"));
|
||
log.info(" - 目标格式: {}", timeParams.get("toFormat"));
|
||
|
||
String formattedTime = (String) FormatUtil.formatTime(inputTime, timeParams);
|
||
log.info(" - 格式化结果: {}", formattedTime);
|
||
|
||
// 第二步：字符串截取
|
||
log.info("第二步 - 字符串截取:");
|
||
Map<String, Object> substrParams = new HashMap<>();
|
||
substrParams.put("start", 0);
|
||
substrParams.put("length", 4);
|
||
log.info(" - 输入字符串: {}", formattedTime);
|
||
log.info(" - 起始位置: {}", substrParams.get("start"));
|
||
log.info(" - 截取长度: {}", substrParams.get("length"));
|
||
|
||
String year = (String) FormatUtil.substring(formattedTime, substrParams);
|
||
log.info(" - 截取结果: {}", year);
|
||
|
||
// 第三步：边界检查
|
||
log.info("第三步 - 边界检查:");
|
||
Map<String, Object> boundaryParams = new HashMap<>();
|
||
boundaryParams.put("min", 2000);
|
||
boundaryParams.put("max", 2100);
|
||
boundaryParams.put("strategy", "truncate");
|
||
log.info(" - 输入值: {}", year);
|
||
log.info(" - 最小值: {}", boundaryParams.get("min"));
|
||
log.info(" - 最大值: {}", boundaryParams.get("max"));
|
||
log.info(" - 处理策略: {}", boundaryParams.get("strategy"));
|
||
|
||
Object checkedValue = FormatUtil.boundaryCheck(Integer.parseInt(year), boundaryParams);
|
||
log.info(" - 边界检查结果: {}", checkedValue);
|
||
|
||
// 预期结果
|
||
int expectedResult = 2024;
|
||
log.info("预期结果: {}", expectedResult);
|
||
|
||
// 断言验证
|
||
assertEquals(expectedResult, checkedValue);
|
||
log.info("✓ 测试通过 - 多方法组合使用正确");
|
||
}
|
||
|
||
/**
|
||
* 性能测试 - 大量数据处理
|
||
*
|
||
* <p><b>测试目的：</b>验证方法在处理大量数据时的性能表现</p>
|
||
* <p><b>测试场景：</b>对1000个坐标进行批量转换</p>
|
||
* <p><b>预计结果：</b>所有转换正确完成</p>
|
||
*/
|
||
@Test
|
||
@DisplayName("性能测试 - 大量数据处理")
|
||
void testPerformance_LargeDataProcessing() {
|
||
System.out.println();
|
||
log.info("========== 性能测试 - 大量数据处理 ==========");
|
||
|
||
// 输入参数
|
||
int testCount = 1000;
|
||
log.info("输入参数:");
|
||
log.info(" - 测试数据量: {} 个坐标转换", testCount);
|
||
log.info(" - 源格式: dms");
|
||
log.info(" - 目标格式: decimal");
|
||
log.info(" - 坐标模式: 116.0°23'45.67\" ~ 116.999°23'45.67\"");
|
||
log.info(" - 性能要求: 处理时间 < 5000 ms");
|
||
|
||
// 开始性能测试
|
||
long startTime = System.currentTimeMillis();
|
||
log.info("开始性能测试...");
|
||
|
||
for (int i = 0; i < testCount; i++) {
|
||
Map<String, Object> coordParams = new HashMap<>();
|
||
coordParams.put("fromType", "dms");
|
||
coordParams.put("toType", "decimal");
|
||
|
||
Object result = FormatUtil.coordinateConvert("116." + i + "°23'45.67\"", coordParams);
|
||
assertNotNull(result);
|
||
}
|
||
|
||
long endTime = System.currentTimeMillis();
|
||
long duration = endTime - startTime;
|
||
|
||
// 实际结果
|
||
log.info("性能测试结果:");
|
||
log.info(" - 开始时间: {} ms", startTime);
|
||
log.info(" - 结束时间: {} ms", endTime);
|
||
log.info(" - 总耗时: {} ms", duration);
|
||
log.info(" - 平均每个转换耗时: {} ms", (double)duration / testCount);
|
||
|
||
// 预期结果
|
||
log.info("预期结果: 处理时间 < 5000 ms");
|
||
|
||
// 断言验证
|
||
assertTrue(duration < 5000, "性能测试应在5秒内完成");
|
||
log.info("✓ 测试通过 - 性能表现符合要求");
|
||
}
|
||
|
||
/**
|
||
* 默认参数值
|
||
*
|
||
* <p><b>测试目的：</b>验证方法对无效参数组合的容错能力</p>
|
||
* <p><b>测试场景：</b>提供相互冲突的参数</p>
|
||
* <p><b>预计结果：</b>返回合理的默认值</p>
|
||
*/
|
||
@Test
|
||
@DisplayName("formatTime - 默认参数值 - 【已验证】")
|
||
void testErrorHandling_InvalidParameterCombination() {
|
||
System.out.println();
|
||
log.info("========== 默认参数值 ==========");
|
||
|
||
// 输入参数
|
||
String inputTime = "2024-01-15";
|
||
params.put("fromFormat", "yyyy-MM-dd");
|
||
params.put("toFormat", "HH:mm:ss");
|
||
|
||
log.info("输入参数:");
|
||
log.info(" - 输入时间: {}", inputTime);
|
||
log.info(" - 源格式: {}", params.get("fromFormat"));
|
||
log.info(" - 目标格式: {}", params.get("toFormat"));
|
||
log.info(" - 注意: 日期格式到时间格式的无效转换");
|
||
|
||
// 预期结果
|
||
log.info("预期结果: 返回默认值");
|
||
|
||
// 执行测试
|
||
Object result = FormatUtil.formatTime(inputTime, params);
|
||
|
||
// 断言验证
|
||
String expectedResult = "00:00:00";
|
||
log.info("预期结果: {}", expectedResult);
|
||
log.info("实际结果: {}", result);
|
||
assertEquals(expectedResult, result);
|
||
log.info("✓ 测试通过 - 异常处理正确");
|
||
}
|
||
|
||
/**
|
||
* 边界值测试 - 极值输入
|
||
*
|
||
* <p><b>测试目的：</b>验证方法对极值输入的处理能力</p>
|
||
* <p><b>测试场景：</b>输入极大/极小值</p>
|
||
* <p><b>预计结果：</b>正确处理或返回错误信息</p>
|
||
*/
|
||
@Test
|
||
@DisplayName("边界值测试 - 极值输入")
|
||
void testBoundaryValues_ExtremeInputs() {
|
||
System.out.println();
|
||
log.info("========== 边界值测试 - 极值输入 ==========");
|
||
|
||
// 输入参数
|
||
double inputValue = Double.MAX_VALUE;
|
||
params.put("min", 0);
|
||
params.put("max", 100);
|
||
params.put("strategy", "error");
|
||
|
||
log.info("输入参数:");
|
||
log.info(" - 输入值: {} (Double.MAX_VALUE)", inputValue);
|
||
log.info(" - 最小值: {}", params.get("min"));
|
||
log.info(" - 最大值: {}", params.get("max"));
|
||
log.info(" - 处理策略: {}", params.get("strategy"));
|
||
log.info(" - 注意: 极大值超出正常范围");
|
||
|
||
// 预期结果
|
||
log.info("预期结果: 正确处理或返回错误信息");
|
||
|
||
// 执行测试
|
||
Object result = FormatUtil.boundaryCheck(inputValue, params);
|
||
|
||
// 实际结果
|
||
log.info("实际结果: {}", result);
|
||
|
||
// 断言验证
|
||
assertNotNull(result);
|
||
log.info("✓ 测试通过 - 边界值处理正确");
|
||
}
|
||
} |