easy_flu_utils 0.0.2

Easy to dev flutter

example/main.dart

import '../lib/utils/lexo_rank.dart';

/// LexoRank 算法测试示例
void main() {
  print('=== LexoRank 算法稳定性测试 ===\n');

  // 测试1：基础功能测试
  print('🔍 测试1：基础功能测试');
  testBasicFunctionality();
  
  // 测试2：大量数据生成测试
  print('\n🔍 测试2：大量数据生成测试');
  testMassDataGeneration();
  
  // 测试3：排序一致性验证
  print('\n🔍 测试3：排序一致性验证');
  testSortingConsistency();
  
  // 测试4：边界条件测试
  print('\n🔍 测试4：边界条件测试');
  testEdgeCases();
  
  // 测试5：性能测试
  print('\n🔍 测试5：性能测试');
  testPerformance();

  print('\n✅ 所有测试完成！');
}

/// 测试基础功能
void testBasicFunctionality() {
  // 获取初始排序值
  final initial = LexoRank.initial();
  print('初始排序值: $initial');
  
  // 生成前后排序值
  final before = LexoRank.before(initial);
  final after = LexoRank.after(initial);
  print('前一个排序值: $before');
  print('后一个排序值: $after');
  
  // 生成中间排序值
  final between = LexoRank.between(before, after);
  print('中间排序值: $between');
  
  // 验证排序顺序
  final List<String> ranks = [before, between, initial, after];
  final sortedRanks = List<String>.from(ranks)..sort();
  
  print('原始顺序: $ranks');
  print('排序后顺序: $sortedRanks');
  
  if (listEqual(ranks, sortedRanks)) {
    print('✅ 基础排序功能正常');
  } else {
    print('❌ 基础排序功能异常');
    // 检查是否只是between的问题
    if (before.compareTo(initial) < 0 && initial.compareTo(after) < 0) {
      print('✅ 前后顺序正确，between函数需要调整');
    }
  }
}

/// 测试大量数据生成
void testMassDataGeneration() {
  final scales = [
    LexoDataScale.hundredThousand,
    LexoDataScale.million,
    LexoDataScale.tenMillion,
  ];
  
  for (final scale in scales) {
    print('测试 ${scale.name} (${scale.value}) 数据量级...');
    
    final startTime = DateTime.now();
    
    // 生成小样本用于验证
    final sampleSize = scale.value > 1000000 ? 1000 : 100;
    final ranks = LexoRank.generateDecreasingRanks(scale).take(sampleSize).toList();
    
    final endTime = DateTime.now();
    final duration = endTime.difference(startTime);
    
    // 验证生成的排序值
    final uniqueRanks = ranks.toSet();
    final isUnique = uniqueRanks.length == ranks.length;
    final isDecreasing = isDecreasingOrder(ranks);
    
    print('  生成 ${ranks.length} 个排序值耗时: ${duration.inMilliseconds}ms');
    print('  排序值唯一性: ${isUnique ? "✅" : "❌"}');
    print('  递减顺序正确: ${isDecreasing ? "✅" : "❌"}');
    
    if (ranks.isNotEmpty) {
      print('  首个排序值: ${ranks.first}');
      print('  最后排序值: ${ranks.last}');
    }
  }
}

/// 测试排序一致性
void testSortingConsistency() {
  final testRanks = <String>[];
  
  // 生成一系列排序值
  String current = LexoRank.initial();
  for (int i = 0; i < 100; i++) {
    testRanks.add(current);
    current = LexoRank.after(current);
  }
  
  // 在随机位置插入新的排序值
  final insertPositions = [10, 25, 50, 75, 90];
  for (final pos in insertPositions) {
    if (pos < testRanks.length - 1) {
      final newRank = LexoRank.between(testRanks[pos], testRanks[pos + 1]);
      testRanks.insert(pos + 1, newRank);
    }
  }
  
  // 验证最终排序
  final originalOrder = List<String>.from(testRanks);
  final sortedOrder = List<String>.from(testRanks)..sort();
  
  if (listEqual(originalOrder, sortedOrder)) {
    print('✅ 插入操作后排序一致性保持正确');
  } else {
    print('❌ 插入操作后排序一致性被破坏');
  }
  
  // 验证所有排序值的唯一性
  final uniqueCount = testRanks.toSet().length;
  if (uniqueCount == testRanks.length) {
    print('✅ 所有排序值保持唯一');
  } else {
    print('❌ 发现重复的排序值');
  }
}

/// 测试边界条件
void testEdgeCases() {
  try {
    // 测试空字符串处理
    final beforeEmpty = LexoRank.before('');
    final afterEmpty = LexoRank.after('');
    print('✅ 空字符串处理正常: before="$beforeEmpty", after="$afterEmpty"');
    
    // 测试最小值和最大值
    const maxRank = 'zzzzzz';
    
    final beforeMax = LexoRank.before(maxRank);
    print('✅ 最大值前一位: $beforeMax');
    
    // 测试错误输入
    try {
      LexoRank.between('z00000', '100000'); // 错误的顺序
      print('❌ 应该抛出异常但没有');
    } catch (e) {
      print('✅ 错误输入正确抛出异常: ${e.toString()}');
    }
    
    // 测试排序值验证
    const validRank = 'A1b2C3';
    const invalidRank = 'A1b2C3@';
    
    print('有效排序值验证: ${LexoRank.isValid(validRank) ? "✅" : "❌"}');
    print('无效排序值验证: ${LexoRank.isValid(invalidRank) ? "❌" : "✅"}');
    
  } catch (e) {
    print('❌ 边界条件测试出现异常: $e');
  }
}

/// 性能测试
void testPerformance() {
  print('开始性能基准测试...');
  
  // 测试单个排序值生成性能
  const iterations = 10000;
  String current = LexoRank.initial();
  
  final startTime = DateTime.now();
  for (int i = 0; i < iterations; i++) {
    current = LexoRank.after(current);
  }
  final endTime = DateTime.now();
  
  final totalMs = endTime.difference(startTime).inMilliseconds;
  final avgMicrosPerOp = (totalMs * 1000) / iterations;
  
  print('生成 $iterations 个排序值总耗时: ${totalMs}ms');
  print('平均每次操作耗时: ${avgMicrosPerOp.toStringAsFixed(2)} 微秒');
  
  if (avgMicrosPerOp < 100) {
    print('✅ 性能表现优秀 (< 100 微秒/操作)');
  } else if (avgMicrosPerOp < 1000) {
    print('✅ 性能表现良好 (< 1ms/操作)');
  } else {
    print('⚠️ 性能需要优化 (> 1ms/操作)');
  }
  
  // 测试大量数据排序性能
  print('\n大量数据排序性能测试...');
  final largeDataSet = <String>[];
  current = LexoRank.initial();
  
  final generateStart = DateTime.now();
  for (int i = 0; i < 1000; i++) {
    largeDataSet.add(current);
    current = LexoRank.after(current);
  }
  final generateEnd = DateTime.now();
  
  // 打乱顺序
  largeDataSet.shuffle();
  
  final sortStart = DateTime.now();
  largeDataSet.sort();
  final sortEnd = DateTime.now();
  
  print('生成1000个排序值耗时: ${generateEnd.difference(generateStart).inMilliseconds}ms');
  print('排序1000个排序值耗时: ${sortEnd.difference(sortStart).inMilliseconds}ms');
}

/// 工具函数：检查列表是否相等
bool listEqual(List<String> a, List<String> b) {
  if (a.length != b.length) return false;
  for (int i = 0; i < a.length; i++) {
    if (a[i] != b[i]) return false;
  }
  return true;
}

/// 工具函数：检查列表是否为递减顺序
bool isDecreasingOrder(List<String> ranks) {
  for (int i = 0; i < ranks.length - 1; i++) {
    if (ranks[i].compareTo(ranks[i + 1]) <= 0) {
      return false;
    }
  }
  return true;
}