/**
 * =============================================
 * 时间显示修复 - 完整回归测试脚本
 * =============================================
 * 测试目标: 验证 createdAt 排序修复和 parseDate 本地时区解析
 * 测试环境: 后端 API (localhost:3001)
 * 测试日期: 2026-04-26
 * =============================================
 */

import http from 'http';
import fs from 'fs';
import path from 'path';
import { fileURLToPath } from 'url';

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

const BASE_URL = 'http://localhost:3001';
const USER_ID = 1;

// 测试报告
const report = {
  total: 0,
  passed: 0,
  failed: 0,
  warnings: 0,
  results: [],
  startTime: new Date(),
  endTime: null
};

function log(msg, level = 'INFO') {
  const icon = { INFO: '📝', PASS: '✅', FAIL: '❌', WARN: '⚠️', HEADER: '📋', SEP: '─' };
  const prefix = icon[level] || '📝';
  console.log(`${prefix} ${msg}`);
}

function recordTest(name, status, detail = '') {
  report.total++;
  if (status === 'PASS') {
    report.passed++;
    log(`${name} - PASS${detail ? ' | ' + detail : ''}`, 'PASS');
  } else if (status === 'WARN') {
    report.warnings++;
    log(`${name} - WARN${detail ? ' | ' + detail : ''}`, 'WARN');
  } else {
    report.failed++;
    log(`${name} - FAIL${detail ? ' | ' + detail : ''}`, 'FAIL');
  }
  report.results.push({ name, status, detail });
}

// API 请求封装
function apiRequest(method, path, body = null) {
  return new Promise((resolve, reject) => {
    const url = new URL(path, BASE_URL);
    const options = {
      hostname: url.hostname,
      port: url.port,
      path: url.pathname + url.search,
      method,
      headers: { 'Content-Type': 'application/json' }
    };

    const req = http.request(options, (res) => {
      let data = '';
      res.on('data', (chunk) => (data += chunk));
      res.on('end', () => {
        try {
          resolve({ statusCode: res.statusCode, body: JSON.parse(data) });
        } catch (e) {
          resolve({ statusCode: res.statusCode, body: data });
        }
      });
    });

    req.on('error', reject);
    if (body) req.write(JSON.stringify(body));
    req.end();
  });
}

// 创建记录辅助函数
async function createRecord(type, category, amount, description, date = null) {
  const payload = {
    userId: USER_ID,
    accountId: 3,
    type,
    amount,
    category,
    description,
    date: date || new Date().toISOString().split('T')[0]
  };
  const result = await apiRequest('POST', '/api/records', payload);
  if (result.body.success) {
    return result.body.data;
  } else {
    throw new Error(`创建记录失败: ${result.body.message}`);
  }
}

// 获取记录辅助函数
async function getRecords(params = {}) {
  const query = new URLSearchParams({ userId: USER_ID, ...params });
  const result = await apiRequest('GET', `/api/records?${query}`);
  if (result.body.success) {
    return result.body.data;
  }
  return [];
}

// 删除记录辅助函数
async function deleteRecord(id) {
  await apiRequest('DELETE', `/api/records/${id}`);
}

async function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

// =============================================
// 主测试流程
// =============================================
async function runTests() {
  console.log('\n' + '='.repeat(60));
  console.log('🧪 时间显示修复 - 完整回归测试');
  console.log('='.repeat(60));
  console.log(`测试开始时间: ${new Date().toLocaleString('zh-CN')}`);
  console.log(`后端地址: ${BASE_URL}`);
  console.log(`测试用户: userId=${USER_ID}`);
  console.log('='.repeat(60) + '\n');

  // ==========================================
  // 测试1: 验证后端 parseDate 函数
  // ==========================================
  log('═══════════════════════════════════════════════════════', 'HEADER');
  log('【测试1】验证后端 parseDate 函数对纯日期字符串的解析', 'HEADER');
  log('═══════════════════════════════════════════════════════', 'HEADER');

  // 创建一条记录，使用纯日期字符串
  const now = new Date();
  const dateStr = '2026-04-26';
  const record1 = await createRecord('expense', '餐饮', 10, 'parseDate测试', dateStr);

  const parsedDate = new Date(record1.date);
  const expectedHour = 0; // 应该解析为当天 00:00 北京时间
  const actualHour = parsedDate.getHours();

  log(`输入日期字符串: "${dateStr}"`, 'INFO');
  log(`解析结果: ${parsedDate.toLocaleString('zh-CN')}`, 'INFO');
  log(`解析结果 ISO: ${parsedDate.toISOString()}`, 'INFO');
  log(`本地时区小时: ${actualHour}:00`, 'INFO');

  if (actualHour === expectedHour) {
    recordTest('parseDate 解析纯日期为本地时区 00:00', 'PASS',
      `解析为 ${parsedDate.toLocaleString('zh-CN')} (北京时间 00:00，非 UTC 00:00)`);
  } else {
    recordTest('parseDate 解析纯日期为本地时区 00:00', 'FAIL',
      `期望 00:00，实际 ${actualHour}:00`);
  }

  // 验证 createdAt 为实际创建时间
  const createdAt = new Date(record1.createdAt);
  const createdAtDiff = Math.abs(createdAt.getTime() - now.getTime());
  
  log(`记录创建时间 (createdAt): ${createdAt.toLocaleString('zh-CN')}`, 'INFO');
  log(`创建时间差: ${createdAtDiff}ms`, 'INFO');

  if (createdAtDiff < 5000) {
    recordTest('createdAt 反映实际创建时间', 'PASS',
      `与当前时间差 ${createdAtDiff}ms < 5s`);
  } else {
    recordTest('createdAt 反映实际创建时间', 'FAIL',
      `与当前时间差 ${createdAtDiff}ms > 5s`);
  }

  await deleteRecord(record1.id);

  // ==========================================
  // 测试2: 验证后端 API 返回的 createdAt 字段
  // ==========================================
  log('\n═══════════════════════════════════════════════════════', 'HEADER');
  log('【测试2】验证后端 API 返回的 createdAt 字段是否正确', 'HEADER');
  log('═══════════════════════════════════════════════════════', 'HEADER');

  const beforeCreate = new Date();
  await sleep(100);
  const record2 = await createRecord('expense', '交通', 20, 'createdAt验证');
  const afterCreate = new Date();

  const apiCreatedAt = new Date(record2.createdAt);

  log(`创建前时间: ${beforeCreate.toLocaleString('zh-CN')}`, 'INFO');
  log(`API返回 createdAt: ${apiCreatedAt.toLocaleString('zh-CN')}`, 'INFO');
  log(`创建后时间: ${afterCreate.toLocaleString('zh-CN')}`, 'INFO');

  const isWithinRange = apiCreatedAt >= beforeCreate && apiCreatedAt <= afterCreate;
  
  if (isWithinRange) {
    recordTest('API 返回的 createdAt 在创建时间范围内', 'PASS',
      `${apiCreatedAt.toLocaleString('zh-CN')} 在 [${beforeCreate.toLocaleString('zh-CN')}, ${afterCreate.toLocaleString('zh-CN')}] 内`);
  } else {
    recordTest('API 返回的 createdAt 在创建时间范围内', 'FAIL',
      `createdAt 不在预期时间范围内`);
  }

  // 验证 createdAt 包含时分秒
  const hasTimeComponent = record2.createdAt.includes(':');
  if (hasTimeComponent) {
    recordTest('createdAt 包含时分秒信息', 'PASS', `值: ${record2.createdAt}`);
  } else {
    recordTest('createdAt 包含时分秒信息', 'FAIL', `值: ${record2.createdAt}`);
  }

  await deleteRecord(record2.id);

  // ==========================================
  // 测试3: 验证后端排序逻辑 (orderBy: { createdAt: 'desc' })
  // ==========================================
  log('\n═══════════════════════════════════════════════════════', 'HEADER');
  log('【测试3】验证后端排序逻辑 (orderBy: createdAt desc)', 'HEADER');
  log('═══════════════════════════════════════════════════════', 'HEADER');

  // 清空现有记录，确保测试环境干净
  const existingRecords = await getRecords();
  for (const r of existingRecords) {
    await deleteRecord(r.id);
  }
  log(`已清理 ${existingRecords.length} 条现有记录`, 'INFO');

  // 创建3条同一天但不同时间的记录
  const records = [];
  for (let i = 0; i < 3; i++) {
    const r = await createRecord('expense', '餐饮', 10 + i, `同天记录${i + 1}`);
    records.push(r);
    log(`创建记录 ${i + 1}: ID=${r.id}, createdAt=${new Date(r.createdAt).toLocaleTimeString('zh-CN')}`, 'INFO');
    await sleep(500); // 确保 createdAt 有差异
  }

  // 获取排序后的记录
  const sortedRecords = await getRecords();

  log(`\n后端返回的排序顺序:`, 'INFO');
  sortedRecords.forEach((r, i) => {
    log(`  [${i + 1}] ${r.category} ¥${r.amount} ${r.description} | createdAt=${new Date(r.createdAt).toLocaleTimeString('zh-CN')}`, 'INFO');
  });

  // 验证最新的记录在最前面
  const firstRecord = sortedRecords[0];
  const lastRecord = sortedRecords[sortedRecords.length - 1];

  if (firstRecord && firstRecord.description === '同天记录3') {
    recordTest('最新创建的记录排在第一位', 'PASS', `ID=${firstRecord.id}`);
  } else {
    recordTest('最新创建的记录排在第一位', 'FAIL',
      `期望"同天记录3"，实际"${firstRecord?.description}"`);
  }

  // 验证排序是严格降序
  let isStrictDescending = true;
  for (let i = 0; i < sortedRecords.length - 1; i++) {
    const t1 = new Date(sortedRecords[i].createdAt).getTime();
    const t2 = new Date(sortedRecords[i + 1].createdAt).getTime();
    if (t1 < t2) {
      isStrictDescending = false;
      break;
    }
  }

  if (isStrictDescending) {
    recordTest('后端排序为严格降序', 'PASS', `${sortedRecords.length} 条记录排序正确`);
  } else {
    recordTest('后端排序为严格降序', 'FAIL', '排序出现异常');
  }

  // ==========================================
  // 测试4: 验证前端 Dashboard 排序逻辑
  // ==========================================
  log('\n═══════════════════════════════════════════════════════', 'HEADER');
  log('【测试4】验证前端 Dashboard 使用 createdAt 排序', 'HEADER');
  log('═══════════════════════════════════════════════════════', 'HEADER');

  // 读取前端代码验证排序逻辑
  const dashboardPath = path.join(__dirname, '..', 'frontend', 'src', 'pages', 'Dashboard', 'index.tsx');

  if (fs.existsSync(dashboardPath)) {
    const dashboardCode = fs.readFileSync(dashboardPath, 'utf-8');

    // 检查是否使用 createdAt 排序
    const hasCreatedAtSort = dashboardCode.includes('.sort((a, b) => new Date(b.createdAt)');
    const hasDateSort = dashboardCode.includes('.sort((a, b) => new Date(b.date)') && !hasCreatedAtSort;

    if (hasCreatedAtSort) {
      recordTest('Dashboard 使用 createdAt 排序', 'PASS', '代码使用 new Date(b.createdAt) 排序');
    } else if (hasDateSort) {
      recordTest('Dashboard 使用 createdAt 排序', 'FAIL', '代码仍使用 new Date(b.date) 排序');
    } else {
      recordTest('Dashboard 使用 createdAt 排序', 'WARN', '未能识别排序逻辑，请手动确认');
    }

    // 检查 formatRecordTime 函数
    const hasFormatRecordTime = dashboardCode.includes('const formatRecordTime');
    const usesCreatedAtForTime = dashboardCode.includes('new Date(record.createdAt)');

    if (hasFormatRecordTime && usesCreatedAtForTime) {
      recordTest('Dashboard 时间格式化使用 createdAt', 'PASS', 'formatRecordTime 使用 record.createdAt');
    } else {
      recordTest('Dashboard 时间格式化使用 createdAt', 'FAIL', '时间格式化未使用 createdAt');
    }

    // 检查时间显示逻辑
    const showsHHMMForToday = dashboardCode.includes("createdAt.getHours()") && dashboardCode.includes("createdAt.getMinutes()");
    if (showsHHMMForToday) {
      recordTest('Dashboard 今天显示 HH:MM 格式', 'PASS', '使用 getHours() 和 getMinutes() 格式化');
    } else {
      recordTest('Dashboard 今天显示 HH:MM 格式', 'FAIL', '未找到 HH:MM 格式化逻辑');
    }

    const showsYesterday = dashboardCode.includes("'昨天'") || dashboardCode.includes('"昨天"');
    if (showsYesterday) {
      recordTest('Dashboard 昨天显示"昨天"文本', 'PASS', '包含"昨天"显示逻辑');
    } else {
      recordTest('Dashboard 昨天显示"昨天"文本', 'WARN', '未找到"昨天"显示逻辑');
    }
  } else {
    recordTest('Dashboard 文件存在性', 'FAIL', `文件不存在: ${dashboardPath}`);
  }

  // ==========================================
  // 测试5: 验证前端 Record 页面排序逻辑
  // ==========================================
  log('\n═══════════════════════════════════════════════════════', 'HEADER');
  log('【测试5】验证前端 Record 页面使用 createdAt 排序', 'HEADER');
  log('═══════════════════════════════════════════════════════', 'HEADER');

  const recordPath = path.join(__dirname, '..', 'frontend', 'src', 'pages', 'Record', 'index.tsx');

  if (fs.existsSync(recordPath)) {
    const recordCode = fs.readFileSync(recordPath, 'utf-8');

    // 检查排序逻辑
    const hasCreatedAtSort = recordCode.includes('.sort((a, b) => new Date(b.createdAt)');
    const hasDateSort = recordCode.includes('.sort((a, b) => new Date(b.date)') && !hasCreatedAtSort;

    if (hasCreatedAtSort) {
      recordTest('Record 页面使用 createdAt 排序', 'PASS', '代码使用 new Date(b.createdAt) 排序');
    } else if (hasDateSort) {
      recordTest('Record 页面使用 createdAt 排序', 'FAIL', '代码仍使用 new Date(b.date) 排序');
    } else {
      recordTest('Record 页面使用 createdAt 排序', 'WARN', '未能识别排序逻辑');
    }

    // 检查 formatTime 函数
    const hasFormatTime = recordCode.includes('const formatTime');
    const usesCreatedAtForTime = recordCode.includes('new Date(record.createdAt)');

    if (hasFormatTime && usesCreatedAtForTime) {
      recordTest('Record 页面时间格式化使用 createdAt', 'PASS', 'formatTime 使用 record.createdAt');
    } else {
      recordTest('Record 页面时间格式化使用 createdAt', 'FAIL', '时间格式化未使用 createdAt');
    }

    // 检查今天显示 HH:MM
    const showsHHMM = recordCode.includes("hour: '2-digit'") && recordCode.includes("minute: '2-digit'");
    if (showsHHMM) {
      recordTest('Record 页面今天显示 HH:MM 格式', 'PASS', '使用 toLocaleTimeString 格式化');
    } else {
      recordTest('Record 页面今天显示 HH:MM 格式', 'FAIL', '未找到 HH:MM 格式化逻辑');
    }

    // 检查昨天显示
    const showsYesterday = recordCode.includes("'昨天'") || recordCode.includes('"昨天"');
    if (showsYesterday) {
      recordTest('Record 页面昨天显示"昨天"文本', 'PASS', '包含"昨天"显示逻辑');
    } else {
      recordTest('Record 页面昨天显示"昨天"文本', 'WARN', '未找到"昨天"显示逻辑');
    }

    // 检查过滤后再排序
    const filterThenSort = recordCode.includes('.filter(') && recordCode.includes('.sort(');
    if (filterThenSort) {
      recordTest('Record 页面先过滤再排序', 'PASS', '排序在过滤后执行');
    } else {
      recordTest('Record 页面先过滤再排序', 'WARN', '过滤和排序顺序需确认');
    }
  } else {
    recordTest('Record 文件存在性', 'FAIL', `文件不存在: ${recordPath}`);
  }

  // ==========================================
  // 测试6: 验证同一天多条记录的排序
  // ==========================================
  log('\n═══════════════════════════════════════════════════════', 'HEADER');
  log('【测试6】验证同一天添加多条记录的排序稳定性', 'HEADER');
  log('═══════════════════════════════════════════════════════', 'HEADER');

  // 当前记录应该已经是按 createdAt 降序（来自测试3）
  // 再添加2条记录，验证最新始终在最前

  const extra1 = await createRecord('expense', '购物', 50, '额外记录1');
  log(`创建额外记录1: ID=${extra1.id}`, 'INFO');
  await sleep(500);

  const extra2 = await createRecord('income', '兼职', 100, '额外记录2');
  log(`创建额外记录2: ID=${extra2.id}`, 'INFO');
  await sleep(500);

  const recordsAfterExtra = await getRecords();

  log(`\n添加额外记录后的排序:`, 'INFO');
  recordsAfterExtra.forEach((r, i) => {
    log(`  [${i + 1}] ${r.type === 'income' ? '+' : '-'}¥${r.amount} ${r.category} ${r.description} | ${new Date(r.createdAt).toLocaleTimeString('zh-CN')}`, 'INFO');
  });

  const latestRecord = recordsAfterExtra[0];
  if (latestRecord && latestRecord.id === extra2.id) {
    recordTest('最新添加的记录始终在最前面', 'PASS', `最新记录: "${latestRecord.description}"`);
  } else {
    recordTest('最新添加的记录始终在最前面', 'FAIL',
      `期望"额外记录2"在最前，实际"${latestRecord?.description}"`);
  }

  // 验证支出筛选后的排序
  const expenseRecords = await getRecords({ type: 'expense' });
  let expenseSorted = true;
  for (let i = 0; i < expenseRecords.length - 1; i++) {
    const t1 = new Date(expenseRecords[i].createdAt).getTime();
    const t2 = new Date(expenseRecords[i + 1].createdAt).getTime();
    if (t1 < t2) {
      expenseSorted = false;
      break;
    }
  }

  if (expenseSorted) {
    recordTest('支出筛选后仍保持 createdAt 降序', 'PASS', `${expenseRecords.length} 条支出记录排序正确`);
  } else {
    recordTest('支出筛选后仍保持 createdAt 降序', 'FAIL', '支出排序异常');
  }

  // 验证收入筛选后的排序
  const incomeRecords = await getRecords({ type: 'income' });
  let incomeSorted = true;
  for (let i = 0; i < incomeRecords.length - 1; i++) {
    const t1 = new Date(incomeRecords[i].createdAt).getTime();
    const t2 = new Date(incomeRecords[i + 1].createdAt).getTime();
    if (t1 < t2) {
      incomeSorted = false;
      break;
    }
  }

  if (incomeSorted) {
    recordTest('收入筛选后仍保持 createdAt 降序', 'PASS', `${incomeRecords.length} 条收入记录排序正确`);
  } else {
    recordTest('收入筛选后仍保持 createdAt 降序', 'FAIL', '收入排序异常');
  }

  // ==========================================
  // 测试7: 验证前端时间显示逻辑 (模拟)
  // ==========================================
  log('\n═══════════════════════════════════════════════════════', 'HEADER');
  log('【测试7】验证前端时间显示格式 (模拟前端逻辑)', 'HEADER');
  log('═══════════════════════════════════════════════════════', 'HEADER');

  // 模拟前端 formatRecordTime 逻辑 (Dashboard)
  function simulateDashboardFormatTime(record) {
    const createdAt = new Date(record.createdAt);
    const now = new Date();
    const today = new Date(now.getFullYear(), now.getMonth(), now.getDate()).getTime();
    const recordDay = new Date(createdAt.getFullYear(), createdAt.getMonth(), createdAt.getDate()).getTime();
    const diffDays = Math.floor((today - recordDay) / (1000 * 60 * 60 * 24));

    if (diffDays === 0) {
      return `${createdAt.getHours().toString().padStart(2, '0')}:${createdAt.getMinutes().toString().padStart(2, '0')}`;
    } else if (diffDays === 1) {
      return '昨天';
    } else if (diffDays <= 7) {
      return `${diffDays}天前`;
    } else {
      return `${createdAt.getMonth() + 1}月${createdAt.getDate()}日`;
    }
  }

  // 模拟前端 formatTime 逻辑 (Record)
  function simulateRecordFormatTime(record) {
    const createdAt = new Date(record.createdAt);
    const today = new Date();
    const todayStr = new Date(today.getFullYear(), today.getMonth(), today.getDate()).toDateString();
    const recordDay = new Date(createdAt.getFullYear(), createdAt.getMonth(), createdAt.getDate()).toDateString();

    if (todayStr === recordDay) {
      return createdAt.toLocaleTimeString('zh-CN', { hour: '2-digit', minute: '2-digit' });
    }

    const yesterday = new Date(today);
    yesterday.setDate(yesterday.getDate() - 1);
    const yesterdayStr = new Date(yesterday.getFullYear(), yesterday.getMonth(), yesterday.getDate()).toDateString();
    if (yesterdayStr === recordDay) {
      return '昨天';
    }

    return createdAt.toLocaleDateString('zh-CN', { month: 'short', day: 'numeric' });
  }

  // 使用现有记录测试时间显示
  const allRecords = await getRecords();

  if (allRecords.length > 0) {
    const todayRecord = allRecords.find(r => {
      const created = new Date(r.createdAt);
      const today = new Date();
      return created.getFullYear() === today.getFullYear() &&
             created.getMonth() === today.getMonth() &&
             created.getDate() === today.getDate();
    });

    if (todayRecord) {
      const dashTime = simulateDashboardFormatTime(todayRecord);
      const recordTime = simulateRecordFormatTime(todayRecord);

      log(`今天创建的记录: "${todayRecord.description}"`, 'INFO');
      log(`  Dashboard 显示: "${dashTime}"`, 'INFO');
      log(`  Record 显示: "${recordTime}"`, 'INFO');

      // 验证不是 08:00
      if (dashTime !== '08:00') {
        recordTest('Dashboard 今天记录不显示 08:00', 'PASS', `显示: "${dashTime}"`);
      } else {
        recordTest('Dashboard 今天记录不显示 08:00', 'FAIL', `仍显示 "08:00"`);
      }

      if (recordTime !== '08:00') {
        recordTest('Record 页面今天记录不显示 08:00', 'PASS', `显示: "${recordTime}"`);
      } else {
        recordTest('Record 页面今天记录不显示 08:00', 'FAIL', `仍显示 "08:00"`);
      }

      // 验证格式为 HH:MM
      const dashTimeRegex = /^\d{2}:\d{2}$/;
      if (dashTimeRegex.test(dashTime)) {
        recordTest('Dashboard 时间格式为 HH:MM', 'PASS', `格式正确: "${dashTime}"`);
      } else {
        recordTest('Dashboard 时间格式为 HH:MM', 'FAIL', `格式不正确: "${dashTime}"`);
      }
    } else {
      recordTest('今天记录时间显示验证', 'WARN', '当前没有今天的记录，跳过此测试');
    }
  } else {
    recordTest('时间显示验证', 'WARN', '无记录可验证');
  }

  // ==========================================
  // 测试8: 清理测试数据
  // ==========================================
  log('\n═══════════════════════════════════════════════════════', 'HEADER');
  log('【测试8】清理测试数据', 'HEADER');
  log('═══════════════════════════════════════════════════════', 'HEADER');

  const finalRecords = await getRecords();
  for (const r of finalRecords) {
    await deleteRecord(r.id);
  }
  log(`已清理 ${finalRecords.length} 条测试记录`, 'INFO');
  recordTest('测试数据清理完成', 'PASS', `清理 ${finalRecords.length} 条记录`);

  // ==========================================
  // 生成测试报告
  // ==========================================
  report.endTime = new Date();
  const duration = report.endTime - report.startTime;

  console.log('\n' + '='.repeat(60));
  console.log('📊 测试报告');
  console.log('='.repeat(60));
  console.log(`测试总数: ${report.total}`);
  console.log(`通过: ${report.passed}`);
  console.log(`失败: ${report.failed}`);
  console.log(`警告: ${report.warnings}`);
  console.log(`通过率: ${((report.passed / report.total) * 100).toFixed(1)}%`);
  console.log(`耗时: ${duration}ms`);
  console.log('='.repeat(60));

  console.log('\n📋 测试结果明细:');
  console.log('-'.repeat(60));
  report.results.forEach((r, i) => {
    const icon = r.status === 'PASS' ? '✅' : r.status === 'WARN' ? '⚠️' : '❌';
    console.log(`  ${icon} [${i + 1}] ${r.name}${r.detail ? ' | ' + r.detail : ''}`);
  });

  console.log('\n' + '='.repeat(60));
  if (report.failed === 0) {
    console.log('🎉 全部测试通过！时间显示修复验证成功！');
  } else {
    console.log(`❌ ${report.failed} 项测试失败，请检查修复！`);
  }
  console.log('='.repeat(60) + '\n');

  return report;
}

// 执行测试
runTests().catch(err => {
  console.error('测试执行异常:', err);
  process.exit(1);
});