Flutter测试与调试技术深度解析

import 'package:flutter_test/flutter_test.dart';
import 'package:integration_test/integration_test.dart';
import 'package:mockito/mockito.dart';
import 'package:mockito/annotations.dart';

// 测试配置管理器
class TestConfigurationManager {
  static TestConfigurationManager? _instance;
  static TestConfigurationManager get instance => _instance ??= TestConfigurationManager._();
  
  late final TestConfiguration _config;
  
  TestConfigurationManager._() {
    _config = TestConfiguration();
  }
  
  TestConfiguration get config => _config;
  
  // 设置测试环境
  void setupTestEnvironment({
    bool enableMocking = true,
    bool enableNetworkStubs = true,
    bool enableDatabaseStubs = true,
    Duration defaultTimeout = const Duration(seconds: 30),
  }) {
    _config.enableMocking = enableMocking;
    _config.enableNetworkStubs = enableNetworkStubs;
    _config.enableDatabaseStubs = enableDatabaseStubs;
    _config.defaultTimeout = defaultTimeout;
  }
  
  // 清理测试环境
  void tearDownTestEnvironment() {
    _config.reset();
  }
}

// 测试配置类
class TestConfiguration {
  bool enableMocking = true;
  bool enableNetworkStubs = true;
  bool enableDatabaseStubs = true;
  Duration defaultTimeout = const Duration(seconds: 30);
  
  void reset() {
    enableMocking = true;
    enableNetworkStubs = true;
    enableDatabaseStubs = true;
    defaultTimeout = const Duration(seconds: 30);
  }
}

// 测试工具类
class TestUtils {
  // 等待异步操作完成
  static Future<void> waitForAsync({
    Duration timeout = const Duration(seconds: 5),
    Duration pollInterval = const Duration(milliseconds: 100),
  }) async {
    await Future.delayed(pollInterval);
    await tester.pumpAndSettle(timeout);
  }
  
  // 查找Widget
  static Finder findWidgetByKey(String key) {
    return find.byKey(Key(key));
  }
  
  static Finder findWidgetByType<T extends Widget>() {
    return find.byType(T);
  }
  
  static Finder findWidgetByText(String text) {
    return find.text(text);
  }
  
  // 验证Widget存在
  static void expectWidgetExists(Finder finder) {
    expect(finder, findsOneWidget);
  }
  
  static void expectWidgetNotExists(Finder finder) {
    expect(finder, findsNothing);
  }
  
  static void expectWidgetCount(Finder finder, int count) {
    expect(finder, findsNWidgets(count));
  }
  
  // 模拟用户交互
  static Future<void> tapWidget(WidgetTester tester, Finder finder) async {
    await tester.tap(finder);
    await tester.pumpAndSettle();
  }
  
  static Future<void> enterText(WidgetTester tester, Finder finder, String text) async {
    await tester.enterText(finder, text);
    await tester.pumpAndSettle();
  }
  
  static Future<void> scrollWidget(WidgetTester tester, Finder finder, Offset offset) async {
    await tester.drag(finder, offset);
    await tester.pumpAndSettle();
  }
}

// 被测试的业务逻辑类
class CalculatorService {
  double add(double a, double b) => a + b;
  double subtract(double a, double b) => a - b;
  double multiply(double a, double b) => a * b;
  
  double divide(double a, double b) {
    if (b == 0) {
      throw ArgumentError('Division by zero is not allowed');
    }
    return a / b;
  }
  
  double power(double base, double exponent) {
    return math.pow(base, exponent).toDouble();
  }
  
  List<double> fibonacci(int n) {
    if (n <= 0) return [];
    if (n == 1) return [0];
    if (n == 2) return [0, 1];
    
    final result = [0, 1];
    for (int i = 2; i < n; i++) {
      result.add(result[i - 1] + result[i - 2]);
    }
    return result;
  }
}

// 单元测试
void main() {
  group('CalculatorService Tests', () {
    late CalculatorService calculator;
    
    setUp(() {
      calculator = CalculatorService();
    });
    
    group('Basic Operations', () {
      test('should add two numbers correctly', () {
        // Arrange
        const double a = 5.0;
        const double b = 3.0;
        const double expected = 8.0;
        
        // Act
        final result = calculator.add(a, b);
        
        // Assert
        expect(result, equals(expected));
      });
      
      test('should subtract two numbers correctly', () {
        expect(calculator.subtract(10.0, 4.0), equals(6.0));
      });
      
      test('should multiply two numbers correctly', () {
        expect(calculator.multiply(3.0, 4.0), equals(12.0));
      });
      
      test('should divide two numbers correctly', () {
        expect(calculator.divide(15.0, 3.0), equals(5.0));
      });
      
      test('should throw exception when dividing by zero', () {
        expect(() => calculator.divide(10.0, 0.0), throwsArgumentError);
      });
    });
    
    group('Advanced Operations', () {
      test('should calculate power correctly', () {
        expect(calculator.power(2.0, 3.0), equals(8.0));
        expect(calculator.power(5.0, 0.0), equals(1.0));
        expect(calculator.power(10.0, 2.0), equals(100.0));
      });
      
      test('should generate fibonacci sequence correctly', () {
        expect(calculator.fibonacci(0), equals([]));
        expect(calculator.fibonacci(1), equals([0]));
        expect(calculator.fibonacci(2), equals([0, 1]));
        expect(calculator.fibonacci(5), equals([0, 1, 1, 2, 3]));
        expect(calculator.fibonacci(8), equals([0, 1, 1, 2, 3, 5, 8, 13]));
      });
    });
    
    group('Edge Cases', () {
      test('should handle negative numbers', () {
        expect(calculator.add(-5.0, 3.0), equals(-2.0));
        expect(calculator.multiply(-2.0, -3.0), equals(6.0));
      });
      
      test('should handle decimal numbers', () {
        expect(calculator.add(1.5, 2.3), closeTo(3.8, 0.001));
        expect(calculator.divide(1.0, 3.0), closeTo(0.333, 0.001));
      });
      
      test('should handle large numbers', () {
        const double large1 = 1e10;
        const double large2 = 2e10;
        expect(calculator.add(large1, large2), equals(3e10));
      });
    });
  });
}

// 异步服务类
class DataService {
  final HttpClient _httpClient;
  final DatabaseService _databaseService;
  
  DataService(this._httpClient, this._databaseService);
  
  Future<UserData> fetchUserData(String userId) async {
    try {
      // 首先尝试从缓存获取
      final cachedData = await _databaseService.getUserFromCache(userId);
      if (cachedData != null && !cachedData.isExpired) {
        return cachedData;
      }
      
      // 从网络获取
      final response = await _httpClient.get('/users/$userId');
      if (response.statusCode == 200) {
        final userData = UserData.fromJson(response.data);
        
        // 缓存数据
        await _databaseService.cacheUser(userData);
        
        return userData;
      } else {
        throw DataServiceException('Failed to fetch user data: ${response.statusCode}');
      }
    } catch (e) {
      throw DataServiceException('Error fetching user data: $e');
    }
  }
  
  Future<List<UserData>> fetchUserList({
    int page = 1,
    int pageSize = 20,
    String? searchQuery,
  }) async {
    final queryParams = {
      'page': page.toString(),
      'pageSize': pageSize.toString(),
      if (searchQuery != null) 'search': searchQuery,
    };
    
    final response = await _httpClient.get('/users', queryParams: queryParams);
    
    if (response.statusCode == 200) {
      final List<dynamic> jsonList = response.data['users'];
      return jsonList.map((json) => UserData.fromJson(json)).toList();
    } else {
      throw DataServiceException('Failed to fetch user list: ${response.statusCode}');
    }
  }
  
  Future<void> updateUserData(UserData userData) async {
    final response = await _httpClient.put('/users/${userData.id}', data: userData.toJson());
    
    if (response.statusCode == 200) {
      // 更新缓存
      await _databaseService.cacheUser(userData);
    } else {
      throw DataServiceException('Failed to update user data: ${response.statusCode}');
    }
  }
}

// 用户数据模型
class UserData {
  final String id;
  final String name;
  final String email;
  final DateTime lastUpdated;
  
  UserData({
    required this.id,
    required this.name,
    required this.email,
    required this.lastUpdated,
  });
  
  bool get isExpired {
    final now = DateTime.now();
    return now.difference(lastUpdated).inHours > 24;
  }
  
  factory UserData.fromJson(Map<String, dynamic> json) {
    return UserData(
      id: json['id'],
      name: json['name'],
      email: json['email'],
      lastUpdated: DateTime.parse(json['lastUpdated']),
    );
  }
  
  Map<String, dynamic> toJson() {
    return {
      'id': id,
      'name': name,
      'email': email,
      'lastUpdated': lastUpdated.toIso8601String(),
    };
  }
}

// Mock类生成注解
@GenerateMocks([HttpClient, DatabaseService])
void main() {
  group('DataService Tests', () {
    late DataService dataService;
    late MockHttpClient mockHttpClient;
    late MockDatabaseService mockDatabaseService;
    
    setUp(() {
      mockHttpClient = MockHttpClient();
      mockDatabaseService = MockDatabaseService();
      dataService = DataService(mockHttpClient, mockDatabaseService);
    });
    
    group('fetchUserData', () {
      test('should return cached data when available and not expired', () async {
        // Arrange
        const userId = 'user123';
        final cachedUser = UserData(
          id: userId,
          name: 'John Doe',
          email: 'john@example.com',
          lastUpdated: DateTime.now().subtract(Duration(hours: 1)),
        );
        
        when(mockDatabaseService.getUserFromCache(userId))
            .thenAnswer((_) async => cachedUser);
        
        // Act
        final result = await dataService.fetchUserData(userId);
        
        // Assert
        expect(result, equals(cachedUser));
        verify(mockDatabaseService.getUserFromCache(userId)).called(1);
        verifyNever(mockHttpClient.get(any));
      });
      
      test('should fetch from network when cache is expired', () async {
        // Arrange
        const userId = 'user123';
        final expiredUser = UserData(
          id: userId,
          name: 'John Doe',
          email: 'john@example.com',
          lastUpdated: DateTime.now().subtract(Duration(days: 2)),
        );
        
        final freshUser = UserData(
          id: userId,
          name: 'John Doe Updated',
          email: 'john.updated@example.com',
          lastUpdated: DateTime.now(),
        );
        
        when(mockDatabaseService.getUserFromCache(userId))
            .thenAnswer((_) async => expiredUser);
        
        when(mockHttpClient.get('/users/$userId'))
            .thenAnswer((_) async => HttpResponse(
              statusCode: 200,
              data: freshUser.toJson(),
            ));
        
        when(mockDatabaseService.cacheUser(any))
            .thenAnswer((_) async {});
        
        // Act
        final result = await dataService.fetchUserData(userId);
        
        // Assert
        expect(result.name, equals('John Doe Updated'));
        verify(mockHttpClient.get('/users/$userId')).called(1);
        verify(mockDatabaseService.cacheUser(any)).called(1);
      });
      
      test('should throw exception when network request fails', () async {
        // Arrange
        const userId = 'user123';
        
        when(mockDatabaseService.getUserFromCache(userId))
            .thenAnswer((_) async => null);
        
        when(mockHttpClient.get('/users/$userId'))
            .thenAnswer((_) async => HttpResponse(
              statusCode: 404,
              data: {'error': 'User not found'},
            ));
        
        // Act & Assert
        expect(
          () => dataService.fetchUserData(userId),
          throwsA(isA<DataServiceException>()),
        );
      });
    });
    
    group('fetchUserList', () {
      test('should fetch user list with default parameters', () async {
        // Arrange
        final userList = [
          UserData(
            id: 'user1',
            name: 'User 1',
            email: 'user1@example.com',
            lastUpdated: DateTime.now(),
          ),
          UserData(
            id: 'user2',
            name: 'User 2',
            email: 'user2@example.com',
            lastUpdated: DateTime.now(),
          ),
        ];
        
        when(mockHttpClient.get('/users', queryParams: anyNamed('queryParams')))
            .thenAnswer((_) async => HttpResponse(
              statusCode: 200,
              data: {
                'users': userList.map((user) => user.toJson()).toList(),
              },
            ));
        
        // Act
        final result = await dataService.fetchUserList();
        
        // Assert
        expect(result.length, equals(2));
        expect(result[0].name, equals('User 1'));
        expect(result[1].name, equals('User 2'));
      });
      
      test('should fetch user list with search query', () async {
        // Arrange
        const searchQuery = 'john';
        final expectedQueryParams = {
          'page': '1',
          'pageSize': '20',
          'search': searchQuery,
        };
        
        when(mockHttpClient.get('/users', queryParams: expectedQueryParams))
            .thenAnswer((_) async => HttpResponse(
              statusCode: 200,
              data: {'users': []},
            ));
        
        // Act
        await dataService.fetchUserList(searchQuery: searchQuery);
        
        // Assert
        verify(mockHttpClient.get('/users', queryParams: expectedQueryParams)).called(1);
      });
    });
    
    group('updateUserData', () {
      test('should update user data successfully', () async {
        // Arrange
        final userData = UserData(
          id: 'user123',
          name: 'Updated Name',
          email: 'updated@example.com',
          lastUpdated: DateTime.now(),
        );
        
        when(mockHttpClient.put('/users/${userData.id}', data: userData.toJson()))
            .thenAnswer((_) async => HttpResponse(statusCode: 200, data: {}));
        
        when(mockDatabaseService.cacheUser(userData))
            .thenAnswer((_) async {});
        
        // Act
        await dataService.updateUserData(userData);
        
        // Assert
        verify(mockHttpClient.put('/users/${userData.id}', data: userData.toJson())).called(1);
        verify(mockDatabaseService.cacheUser(userData)).called(1);
      });
      
      test('should throw exception when update fails', () async {
        // Arrange
        final userData = UserData(
          id: 'user123',
          name: 'Updated Name',
          email: 'updated@example.com',
          lastUpdated: DateTime.now(),
        );
        
        when(mockHttpClient.put('/users/${userData.id}', data: userData.toJson()))
            .thenAnswer((_) async => HttpResponse(
              statusCode: 500,
              data: {'error': 'Internal server error'},
            ));
        
        // Act & Assert
        expect(
          () => dataService.updateUserData(userData),
          throwsA(isA<DataServiceException>()),
        );
        
        verifyNever(mockDatabaseService.cacheUser(any));
      });
    });
  });
}

// HTTP响应模型
class HttpResponse {
  final int statusCode;
  final dynamic data;
  
  HttpResponse({required this.statusCode, required this.data});
}

// 异常类
class DataServiceException implements Exception {
  final String message;
  
  DataServiceException(this.message);
  
  @override
  String toString() => 'DataServiceException: $message';
}

// 抽象类定义（用于Mock）
abstract class HttpClient {
  Future<HttpResponse> get(String path, {Map<String, String>? queryParams});
  Future<HttpResponse> put(String path, {dynamic data});
}

abstract class DatabaseService {
  Future<UserData?> getUserFromCache(String userId);
  Future<void> cacheUser(UserData userData);
}

// 被测试的Widget
class CounterWidget extends StatefulWidget {
  final int initialValue;
  final ValueChanged<int>? onValueChanged;
  
  const CounterWidget({
    Key? key,
    this.initialValue = 0,
    this.onValueChanged,
  }) : super(key: key);
  
  @override
  State<CounterWidget> createState() => _CounterWidgetState();
}

class _CounterWidgetState extends State<CounterWidget> {
  late int _counter;
  
  @override
  void initState() {
    super.initState();
    _counter = widget.initialValue;
  }
  
  void _increment() {
    setState(() {
      _counter++;
    });
    widget.onValueChanged?.call(_counter);
  }
  
  void _decrement() {
    setState(() {
      _counter--;
    });
    widget.onValueChanged?.call(_counter);
  }
  
  void _reset() {
    setState(() {
      _counter = widget.initialValue;
    });
    widget.onValueChanged?.call(_counter);
  }
  
  @override
  Widget build(BuildContext context) {
    return Column(
      mainAxisAlignment: MainAxisAlignment.center,
      children: [
        Text(
          'Counter Value',
          key: const Key('counter_label'),
          style: Theme.of(context).textTheme.headlineSmall,
        ),
        const SizedBox(height: 16),
        Text(
          '$_counter',
          key: const Key('counter_value'),
          style: Theme.of(context).textTheme.headlineLarge,
        ),
        const SizedBox(height: 24),
        Row(
          mainAxisAlignment: MainAxisAlignment.spaceEvenly,
          children: [
            ElevatedButton(
              key: const Key('decrement_button'),
              onPressed: _decrement,
              child: const Icon(Icons.remove),
            ),
            ElevatedButton(
              key: const Key('reset_button'),
              onPressed: _reset,
              child: const Icon(Icons.refresh),
            ),
            ElevatedButton(
              key: const Key('increment_button'),
              onPressed: _increment,
              child: const Icon(Icons.add),
            ),
          ],
        ),
      ],
    );
  }
}

// Widget测试
void main() {
  group('CounterWidget Tests', () {
    testWidgets('should display initial value', (WidgetTester tester) async {
      // Arrange
      const initialValue = 5;
      
      // Act
      await tester.pumpWidget(
        MaterialApp(
          home: Scaffold(
            body: CounterWidget(initialValue: initialValue),
          ),
        ),
      );
      
      // Assert
      expect(find.byKey(const Key('counter_value')), findsOneWidget);
      expect(find.text('$initialValue'), findsOneWidget);
      expect(find.text('Counter Value'), findsOneWidget);
    });
    
    testWidgets('should increment counter when increment button is tapped', (WidgetTester tester) async {
      // Arrange
      await tester.pumpWidget(
        MaterialApp(
          home: Scaffold(
            body: CounterWidget(initialValue: 0),
          ),
        ),
      );
      
      // Act
      await tester.tap(find.byKey(const Key('increment_button')));
      await tester.pump();
      
      // Assert
      expect(find.text('1'), findsOneWidget);
      expect(find.text('0'), findsNothing);
    });
    
    testWidgets('should decrement counter when decrement button is tapped', (WidgetTester tester) async {
      // Arrange
      await tester.pumpWidget(
        MaterialApp(
          home: Scaffold(
            body: CounterWidget(initialValue: 5),
          ),
        ),
      );
      
      // Act
      await tester.tap(find.byKey(const Key('decrement_button')));
      await tester.pump();
      
      // Assert
      expect(find.text('4'), findsOneWidget);
      expect(find.text('5'), findsNothing);
    });
    
    testWidgets('should reset counter when reset button is tapped', (WidgetTester tester) async {
      // Arrange
      const initialValue = 10;
      await tester.pumpWidget(
        MaterialApp(
          home: Scaffold(
            body: CounterWidget(initialValue: initialValue),
          ),
        ),
      );
      
      // Modify counter value
      await tester.tap(find.byKey(const Key('increment_button')));
      await tester.pump();
      expect(find.text('11'), findsOneWidget);
      
      // Act
      await tester.tap(find.byKey(const Key('reset_button')));
      await tester.pump();
      
      // Assert
      expect(find.text('$initialValue'), findsOneWidget);
      expect(find.text('11'), findsNothing);
    });
    
    testWidgets('should call onValueChanged callback when value changes', (WidgetTester tester) async {
      // Arrange
      int? callbackValue;
      
      await tester.pumpWidget(
        MaterialApp(
          home: Scaffold(
            body: CounterWidget(
              initialValue: 0,
              onValueChanged: (value) {
                callbackValue = value;
              },
            ),
          ),
        ),
      );
      
      // Act
      await tester.tap(find.byKey(const Key('increment_button')));
      await tester.pump();
      
      // Assert
      expect(callbackValue, equals(1));
    });
    
    testWidgets('should handle multiple rapid taps', (WidgetTester tester) async {
      // Arrange
      await tester.pumpWidget(
        MaterialApp(
          home: Scaffold(
            body: CounterWidget(initialValue: 0),
          ),
        ),
      );
      
      // Act
      for (int i = 0; i < 5; i++) {
        await tester.tap(find.byKey(const Key('increment_button')));
        await tester.pump();
      }
      
      // Assert
      expect(find.text('5'), findsOneWidget);
    });
    
    testWidgets('should display correct theme styles', (WidgetTester tester) async {
      // Arrange
      await tester.pumpWidget(
        MaterialApp(
          theme: ThemeData(
            textTheme: const TextTheme(
              headlineSmall: TextStyle(fontSize: 20, color: Colors.blue),
              headlineLarge: TextStyle(fontSize: 32, color: Colors.red),
            ),
          ),
          home: Scaffold(
            body: CounterWidget(initialValue: 0),
          ),
        ),
      );
      
      // Act & Assert
      final labelWidget = tester.widget<Text>(find.byKey(const Key('counter_label')));
      final valueWidget = tester.widget<Text>(find.byKey(const Key('counter_value')));
      
      expect(labelWidget.style?.fontSize, equals(20));
      expect(labelWidget.style?.color, equals(Colors.blue));
      expect(valueWidget.style?.fontSize, equals(32));
      expect(valueWidget.style?.color, equals(Colors.red));
    });
  });
}

// 复杂的用户列表Widget
class UserListWidget extends StatefulWidget {
  final UserListController controller;
  
  const UserListWidget({Key? key, required this.controller}) : super(key: key);
  
  @override
  State<UserListWidget> createState() => _UserListWidgetState();
}

class _UserListWidgetState extends State<UserListWidget> {
  final ScrollController _scrollController = ScrollController();
  final TextEditingController _searchController = TextEditingController();
  
  @override
  void initState() {
    super.initState();
    _scrollController.addListener(_onScroll);
    widget.controller.loadUsers();
  }
  
  @override
  void dispose() {
    _scrollController.dispose();
    _searchController.dispose();
    super.dispose();
  }
  
  void _onScroll() {
    if (_scrollController.position.pixels >= _scrollController.position.maxScrollExtent * 0.8) {
      widget.controller.loadMoreUsers();
    }
  }
  
  void _onSearchChanged(String query) {
    widget.controller.searchUsers(query);
  }
  
  @override
  Widget build(BuildContext context) {
    return Column(
      children: [
        Padding(
          padding: const EdgeInsets.all(16.0),
          child: TextField(
            key: const Key('search_field'),
            controller: _searchController,
            decoration: const InputDecoration(
              hintText: 'Search users...',
              prefixIcon: Icon(Icons.search),
            ),
            onChanged: _onSearchChanged,
          ),
        ),
        Expanded(
          child: StreamBuilder<UserListState>(
            stream: widget.controller.stateStream,
            builder: (context, snapshot) {
              final state = snapshot.data ?? UserListState.initial();
              
              if (state.isLoading && state.users.isEmpty) {
                return const Center(
                  key: Key('loading_indicator'),
                  child: CircularProgressIndicator(),
                );
              }
              
              if (state.hasError && state.users.isEmpty) {
                return Center(
                  key: const Key('error_message'),
                  child: Column(
                    mainAxisAlignment: MainAxisAlignment.center,
                    children: [
                      Text('Error: ${state.errorMessage}'),
                      const SizedBox(height: 16),
                      ElevatedButton(
                        key: const Key('retry_button'),
                        onPressed: () => widget.controller.loadUsers(),
                        child: const Text('Retry'),
                      ),
                    ],
                  ),
                );
              }
              
              if (state.users.isEmpty) {
                return const Center(
                  key: Key('empty_message'),
                  child: Text('No users found'),
                );
              }
              
              return ListView.builder(
                key: const Key('user_list'),
                controller: _scrollController,
                itemCount: state.users.length + (state.isLoadingMore ? 1 : 0),
                itemBuilder: (context, index) {
                  if (index >= state.users.length) {
                    return const Center(
                      key: Key('load_more_indicator'),
                      child: Padding(
                        padding: EdgeInsets.all(16.0),
                        child: CircularProgressIndicator(),
                      ),
                    );
                  }
                  
                  final user = state.users[index];
                  return UserListItem(
                    key: Key('user_item_${user.id}'),
                    user: user,
                    onTap: () => widget.controller.selectUser(user),
                  );
                },
              );
            },
          ),
        ),
      ],
    );
  }
}

// 用户列表项Widget
class UserListItem extends StatelessWidget {
  final UserData user;
  final VoidCallback? onTap;
  
  const UserListItem({
    Key? key,
    required this.user,
    this.onTap,
  }) : super(key: key);
  
  @override
  Widget build(BuildContext context) {
    return ListTile(
      leading: CircleAvatar(
        key: Key('avatar_${user.id}'),
        child: Text(user.name.substring(0, 1).toUpperCase()),
      ),
      title: Text(
        user.name,
        key: Key('name_${user.id}'),
      ),
      subtitle: Text(
        user.email,
        key: Key('email_${user.id}'),
      ),
      trailing: const Icon(Icons.arrow_forward_ios),
      onTap: onTap,
    );
  }
}

// 用户列表状态
class UserListState {
  final List<UserData> users;
  final bool isLoading;
  final bool isLoadingMore;
  final bool hasError;
  final String? errorMessage;
  final String searchQuery;
  
  UserListState({
    required this.users,
    required this.isLoading,
    required this.isLoadingMore,
    required this.hasError,
    this.errorMessage,
    required this.searchQuery,
  });
  
  factory UserListState.initial() {
    return UserListState(
      users: [],
      isLoading: false,
      isLoadingMore: false,
      hasError: false,
      searchQuery: '',
    );
  }
  
  UserListState copyWith({
    List<UserData>? users,
    bool? isLoading,
    bool? isLoadingMore,
    bool? hasError,
    String? errorMessage,
    String? searchQuery,
  }) {
    return UserListState(
      users: users ?? this.users,
      isLoading: isLoading ?? this.isLoading,
      isLoadingMore: isLoadingMore ?? this.isLoadingMore,
      hasError: hasError ?? this.hasError,
      errorMessage: errorMessage ?? this.errorMessage,
      searchQuery: searchQuery ?? this.searchQuery,
    );
  }
}

// 用户列表控制器
class UserListController {
  final DataService _dataService;
  final StreamController<UserListState> _stateController = StreamController<UserListState>.broadcast();
  
  UserListState _currentState = UserListState.initial();
  int _currentPage = 1;
  static const int _pageSize = 20;
  
  UserListController(this._dataService);
  
  Stream<UserListState> get stateStream => _stateController.stream;
  UserListState get currentState => _currentState;
  
  void _updateState(UserListState newState) {
    _currentState = newState;
    _stateController.add(newState);
  }
  
  Future<void> loadUsers() async {
    _updateState(_currentState.copyWith(isLoading: true, hasError: false));
    
    try {
      final users = await _dataService.fetchUserList(page: 1, pageSize: _pageSize);
      _currentPage = 1;
      _updateState(_currentState.copyWith(
        users: users,
        isLoading: false,
        hasError: false,
      ));
    } catch (e) {
      _updateState(_currentState.copyWith(
        isLoading: false,
        hasError: true,
        errorMessage: e.toString(),
      ));
    }
  }
  
  Future<void> loadMoreUsers() async {
    if (_currentState.isLoadingMore) return;
    
    _updateState(_currentState.copyWith(isLoadingMore: true));
    
    try {
      final moreUsers = await _dataService.fetchUserList(
        page: _currentPage + 1,
        pageSize: _pageSize,
        searchQuery: _currentState.searchQuery.isEmpty ? null : _currentState.searchQuery,
      );
      
      _currentPage++;
      _updateState(_currentState.copyWith(
        users: [..._currentState.users, ...moreUsers],
        isLoadingMore: false,
      ));
    } catch (e) {
      _updateState(_currentState.copyWith(
        isLoadingMore: false,
        hasError: true,
        errorMessage: e.toString(),
      ));
    }
  }
  
  Future<void> searchUsers(String query) async {
    _updateState(_currentState.copyWith(
      searchQuery: query,
      isLoading: true,
      hasError: false,
    ));
    
    try {
      final users = await _dataService.fetchUserList(
        page: 1,
        pageSize: _pageSize,
        searchQuery: query.isEmpty ? null : query,
      );
      
      _currentPage = 1;
      _updateState(_currentState.copyWith(
        users: users,
        isLoading: false,
        hasError: false,
      ));
    } catch (e) {
      _updateState(_currentState.copyWith(
        isLoading: false,
        hasError: true,
        errorMessage: e.toString(),
      ));
    }
  }
  
  void selectUser(UserData user) {
    // 处理用户选择逻辑
    print('Selected user: ${user.name}');
  }
  
  void dispose() {
    _stateController.close();
  }
}

// 复杂Widget测试
@GenerateMocks([DataService])
void main() {
  group('UserListWidget Tests', () {
    late MockDataService mockDataService;
    late UserListController controller;
    
    setUp(() {
      mockDataService = MockDataService();
      controller = UserListController(mockDataService);
    });
    
    tearDown(() {
      controller.dispose();
    });
    
    testWidgets('should display loading indicator initially', (WidgetTester tester) async {
      // Arrange
      when(mockDataService.fetchUserList(page: 1, pageSize: 20))
          .thenAnswer((_) async {
        await Future.delayed(const Duration(seconds: 1));
        return [];
      });
      
      // Act
      await tester.pumpWidget(
        MaterialApp(
          home: Scaffold(
            body: UserListWidget(controller: controller),
          ),
        ),
      );
      
      // Assert
      expect(find.byKey(const Key('loading_indicator')), findsOneWidget);
    });
    
    testWidgets('should display user list when data is loaded', (WidgetTester tester) async {
      // Arrange
      final users = [
        UserData(
          id: 'user1',
          name: 'John Doe',
          email: 'john@example.com',
          lastUpdated: DateTime.now(),
        ),
        UserData(
          id: 'user2',
          name: 'Jane Smith',
          email: 'jane@example.com',
          lastUpdated: DateTime.now(),
        ),
      ];
      
      when(mockDataService.fetchUserList(page: 1, pageSize: 20))
          .thenAnswer((_) async => users);
      
      // Act
      await tester.pumpWidget(
        MaterialApp(
          home: Scaffold(
            body: UserListWidget(controller: controller),
          ),
        ),
      );
      
      await tester.pumpAndSettle();
      
      // Assert
      expect(find.byKey(const Key('user_list')), findsOneWidget);
      expect(find.byKey(const Key('user_item_user1')), findsOneWidget);
      expect(find.byKey(const Key('user_item_user2')), findsOneWidget);
      expect(find.text('John Doe'), findsOneWidget);
      expect(find.text('Jane Smith'), findsOneWidget);
    });
    
    testWidgets('should display error message when loading fails', (WidgetTester tester) async {
      // Arrange
      when(mockDataService.fetchUserList(page: 1, pageSize: 20))
          .thenThrow(DataServiceException('Network error'));
      
      // Act
      await tester.pumpWidget(
        MaterialApp(
          home: Scaffold(
            body: UserListWidget(controller: controller),
          ),
        ),
      );
      
      await tester.pumpAndSettle();
      
      // Assert
      expect(find.byKey(const Key('error_message')), findsOneWidget);
      expect(find.text('Error: DataServiceException: Network error'), findsOneWidget);
      expect(find.byKey(const Key('retry_button')), findsOneWidget);
    });
    
    testWidgets('should retry loading when retry button is tapped', (WidgetTester tester) async {
      // Arrange
      when(mockDataService.fetchUserList(page: 1, pageSize: 20))
          .thenThrow(DataServiceException('Network error'));
      
      await tester.pumpWidget(
        MaterialApp(
          home: Scaffold(
            body: UserListWidget(controller: controller),
          ),
        ),
      );
      
      await tester.pumpAndSettle();
      
      // Setup successful retry
      when(mockDataService.fetchUserList(page: 1, pageSize: 20))
          .thenAnswer((_) async => []);
      
      // Act
      await tester.tap(find.byKey(const Key('retry_button')));
      await tester.pumpAndSettle();
      
      // Assert
      verify(mockDataService.fetchUserList(page: 1, pageSize: 20)).called(2);
    });
    
    testWidgets('should filter users when search text is entered', (WidgetTester tester) async {
      // Arrange
      final allUsers = [
        UserData(
          id: 'user1',
          name: 'John Doe',
          email: 'john@example.com',
          lastUpdated: DateTime.now(),
        ),
        UserData(
          id: 'user2',
          name: 'Jane Smith',
          email: 'jane@example.com',
          lastUpdated: DateTime.now(),
        ),
      ];
      
      final filteredUsers = [
        UserData(
          id: 'user1',
          name: 'John Doe',
          email: 'john@example.com',
          lastUpdated: DateTime.now(),
        ),
      ];
      
      when(mockDataService.fetchUserList(page: 1, pageSize: 20))
          .thenAnswer((_) async => allUsers);
      
      when(mockDataService.fetchUserList(page: 1, pageSize: 20, searchQuery: 'john'))
          .thenAnswer((_) async => filteredUsers);
      
      await tester.pumpWidget(
        MaterialApp(
          home: Scaffold(
            body: UserListWidget(controller: controller),
          ),
        ),
      );
      
      await tester.pumpAndSettle();
      
      // Act
      await tester.enterText(find.byKey(const Key('search_field')), 'john');
      await tester.pumpAndSettle();
      
      // Assert
      verify(mockDataService.fetchUserList(page: 1, pageSize: 20, searchQuery: 'john')).called(1);
      expect(find.byKey(const Key('user_item_user1')), findsOneWidget);
      expect(find.byKey(const Key('user_item_user2')), findsNothing);
    });
    
    testWidgets('should load more users when scrolled to bottom', (WidgetTester tester) async {
      // Arrange
      final firstPageUsers = List.generate(20, (index) => UserData(
        id: 'user$index',
        name: 'User $index',
        email: 'user$index@example.com',
        lastUpdated: DateTime.now(),
      ));
      
      final secondPageUsers = List.generate(10, (index) => UserData(
        id: 'user${index + 20}',
        name: 'User ${index + 20}',
        email: 'user${index + 20}@example.com',
        lastUpdated: DateTime.now(),
      ));
      
      when(mockDataService.fetchUserList(page: 1, pageSize: 20))
          .thenAnswer((_) async => firstPageUsers);
      
      when(mockDataService.fetchUserList(page: 2, pageSize: 20))
          .thenAnswer((_) async => secondPageUsers);
      
      await tester.pumpWidget(
        MaterialApp(
          home: Scaffold(
            body: UserListWidget(controller: controller),
          ),
        ),
      );
      
      await tester.pumpAndSettle();
      
      // Act
      await tester.drag(find.byKey(const Key('user_list')), const Offset(0, -5000));
      await tester.pumpAndSettle();
      
      // Assert
      verify(mockDataService.fetchUserList(page: 2, pageSize: 20)).called(1);
      expect(find.byKey(const Key('user_item_user25')), findsOneWidget);
    });
  });
}

// integration_test/app_test.dart
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:integration_test/integration_test.dart';
import 'package:my_app/main.dart' as app;

void main() {
  IntegrationTestWidgetsFlutterBinding.ensureInitialized();
  
  group('App Integration Tests', () {
    testWidgets('complete user flow test', (WidgetTester tester) async {
      // 启动应用
      app.main();
      await tester.pumpAndSettle();
      
      // 验证启动页面
      expect(find.text('Welcome'), findsOneWidget);
      
      // 导航到登录页面
      await tester.tap(find.text('Login'));
      await tester.pumpAndSettle();
      
      // 输入登录信息
      await tester.enterText(find.byKey(const Key('email_field')), 'test@example.com');
      await tester.enterText(find.byKey(const Key('password_field')), 'password123');
      
      // 点击登录按钮
      await tester.tap(find.byKey(const Key('login_button')));
      await tester.pumpAndSettle(const Duration(seconds: 3));
      
      // 验证登录成功，进入主页
      expect(find.text('Dashboard'), findsOneWidget);
      
      // 导航到用户列表
      await tester.tap(find.byIcon(Icons.people));
      await tester.pumpAndSettle();
      
      // 验证用户列表加载
      expect(find.byType(ListView), findsOneWidget);
      
      // 搜索用户
      await tester.enterText(find.byKey(const Key('search_field')), 'John');
      await tester.pumpAndSettle(const Duration(seconds: 2));
      
      // 验证搜索结果
      expect(find.text('John'), findsAtLeastNWidgets(1));
      
      // 点击用户详情
      await tester.tap(find.text('John Doe').first);
      await tester.pumpAndSettle();
      
      // 验证用户详情页面
      expect(find.text('User Details'), findsOneWidget);
      expect(find.text('john@example.com'), findsOneWidget);
      
      // 编辑用户信息
      await tester.tap(find.byIcon(Icons.edit));
      await tester.pumpAndSettle();
      
      // 修改用户名
      await tester.enterText(find.byKey(const Key('name_field')), 'John Smith');
      
      // 保存更改
      await tester.tap(find.text('Save'));
      await tester.pumpAndSettle(const Duration(seconds: 2));
      
      // 验证更改已保存
      expect(find.text('John Smith'), findsOneWidget);
      
      // 返回用户列表
      await tester.tap(find.byIcon(Icons.arrow_back));
      await tester.pumpAndSettle();
      
      // 验证列表中的用户名已更新
      expect(find.text('John Smith'), findsOneWidget);
      
      // 登出
      await tester.tap(find.byIcon(Icons.logout));
      await tester.pumpAndSettle();
      
      // 验证返回到欢迎页面
      expect(find.text('Welcome'), findsOneWidget);
    });
    
    testWidgets('error handling test', (WidgetTester tester) async {
      // 启动应用
      app.main();
      await tester.pumpAndSettle();
      
      // 尝试使用错误的登录信息
      await tester.tap(find.text('Login'));
      await tester.pumpAndSettle();
      
      await tester.enterText(find.byKey(const Key('email_field')), 'invalid@example.com');
      await tester.enterText(find.byKey(const Key('password_field')), 'wrongpassword');
      
      await tester.tap(find.byKey(const Key('login_button')));
      await tester.pumpAndSettle(const Duration(seconds: 3));
      
      // 验证错误消息显示
      expect(find.text('Invalid credentials'), findsOneWidget);
      
      // 验证仍在登录页面
      expect(find.byKey(const Key('login_button')), findsOneWidget);
    });
    
    testWidgets('offline functionality test', (WidgetTester tester) async {
      // 启动应用
      app.main();
      await tester.pumpAndSettle();
      
      // 模拟网络断开
      // 注意：这需要在应用中实现网络状态模拟
      await tester.binding.defaultBinaryMessenger.handlePlatformMessage(
        'flutter/connectivity',
        const StandardMethodCodec().encodeMethodCall(
          const MethodCall('listen', null),
        ),
        (data) {},
      );
      
      // 尝试加载需要网络的内容
      await tester.tap(find.text('Refresh'));
      await tester.pumpAndSettle(const Duration(seconds: 3));
      
      // 验证离线消息显示
      expect(find.text('No internet connection'), findsOneWidget);
      
      // 验证缓存数据仍然可用
      expect(find.text('Cached Data'), findsOneWidget);
    });
  });
}

// integration_test/performance_test.dart
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:integration_test/integration_test.dart';
import 'package:my_app/main.dart' as app;

void main() {
  final binding = IntegrationTestWidgetsFlutterBinding.ensureInitialized();
  
  group('Performance Tests', () {
    testWidgets('app startup performance', (WidgetTester tester) async {
      // 测量应用启动时间
      final stopwatch = Stopwatch()..start();
      
      app.main();
      await tester.pumpAndSettle();
      
      stopwatch.stop();
      
      // 验证启动时间在合理范围内（例如小于3秒）
      expect(stopwatch.elapsedMilliseconds, lessThan(3000));
      
      print('App startup time: ${stopwatch.elapsedMilliseconds}ms');
    });
    
    testWidgets('list scrolling performance', (WidgetTester tester) async {
      app.main();
      await tester.pumpAndSettle();
      
      // 导航到包含大量数据的列表页面
      await tester.tap(find.text('Large List'));
      await tester.pumpAndSettle();
      
      // 开始性能跟踪
      await binding.traceAction(() async {
        // 执行滚动操作
        for (int i = 0; i < 10; i++) {
          await tester.drag(find.byType(ListView), const Offset(0, -500));
          await tester.pumpAndSettle();
        }
      }, reportKey: 'list_scrolling_performance');
    });
    
    testWidgets('animation performance', (WidgetTester tester) async {
      app.main();
      await tester.pumpAndSettle();
      
      // 导航到包含动画的页面
      await tester.tap(find.text('Animations'));
      await tester.pumpAndSettle();
      
      // 测试动画性能
      await binding.traceAction(() async {
        // 触发动画
        await tester.tap(find.text('Start Animation'));
        await tester.pumpAndSettle(const Duration(seconds: 2));
      }, reportKey: 'animation_performance');
    });
    
    testWidgets('memory usage test', (WidgetTester tester) async {
      app.main();
      await tester.pumpAndSettle();
      
      // 执行一系列操作来测试内存使用
      for (int i = 0; i < 5; i++) {
        // 导航到不同页面
        await tester.tap(find.text('Page $i'));
        await tester.pumpAndSettle();
        
        // 加载数据
        await tester.tap(find.text('Load Data'));
        await tester.pumpAndSettle();
        
        // 返回主页
        await tester.tap(find.byIcon(Icons.home));
        await tester.pumpAndSettle();
      }
      
      // 注意：实际的内存测试需要使用平台特定的工具
      // 这里只是演示测试结构
    });
  });
}

// 调试工具类
class DebugUtils {
  static bool get isDebugMode {
    bool inDebugMode = false;
    assert(inDebugMode = true);
    return inDebugMode;
  }
  
  // 打印Widget树结构
  static void printWidgetTree(BuildContext context) {
    if (isDebugMode) {
      debugPrint('Widget Tree:');
      debugPrint(context.widget.toStringDeep());
    }
  }
  
  // 打印渲染树结构
  static void printRenderTree(BuildContext context) {
    if (isDebugMode) {
      final renderObject = context.findRenderObject();
      if (renderObject != null) {
        debugPrint('Render Tree:');
        debugPrint(renderObject.toStringDeep());
      }
    }
  }
  
  // 打印Element树结构
  static void printElementTree(BuildContext context) {
    if (isDebugMode) {
      debugPrint('Element Tree:');
      debugPrint(context.toStringDeep());
    }
  }
  
  // 高亮Widget边界
  static void enableWidgetInspector() {
    if (isDebugMode) {
      debugPaintSizeEnabled = true;
    }
  }
  
  // 显示性能叠加层
  static void enablePerformanceOverlay() {
    if (isDebugMode) {
      debugProfileBuildsEnabled = true;
      debugProfilePaintsEnabled = true;
    }
  }
  
  // 记录构建时间
  static T measureBuildTime<T>(String name, T Function() builder) {
    if (!isDebugMode) return builder();
    
    final stopwatch = Stopwatch()..start();
    final result = builder();
    stopwatch.stop();
    
    debugPrint('$name build time: ${stopwatch.elapsedMicroseconds}μs');
    return result;
  }
  
  // 内存使用情况
  static void logMemoryUsage(String tag) {
    if (isDebugMode) {
      debugPrint('[$tag] Memory usage logged');
    }
  }
  
  // 性能监控
  static void startPerformanceMonitoring() {
    if (isDebugMode) {
      WidgetsBinding.instance.addTimingsCallback((timings) {
        for (final timing in timings) {
          if (timing.totalSpan.inMilliseconds > 16) {
            debugPrint('Frame took ${timing.totalSpan.inMilliseconds}ms');
          }
        }
      });
    }
  }
}

// 自定义调试Widget
class DebugInfoWidget extends StatelessWidget {
  final Widget child;
  final String debugInfo;
  
  const DebugInfoWidget({
    Key? key,
    required this.child,
    required this.debugInfo,
  }) : super(key: key);
  
  @override
  Widget build(BuildContext context) {
    return Stack(
      children: [
        child,
        if (DebugUtils.isDebugMode)
          Positioned(
            top: 0,
            right: 0,
            child: Container(
              padding: const EdgeInsets.all(4),
              color: Colors.red.withOpacity(0.7),
              child: Text(
                debugInfo,
                style: const TextStyle(
                  color: Colors.white,
                  fontSize: 10,
                ),
              ),
            ),
          ),
      ],
    );
  }
}

// 条件断点示例
class ConditionalBreakpointExample {
  void processUserList(List<User> users) {
    for (int i = 0; i < users.length; i++) {
      final user = users[i];
      
      // 在调试器中设置条件断点：user.age > 65
      if (user.isActive) {
        processActiveUser(user);
      }
      
      // 在调试器中设置条件断点：i % 100 == 0
      updateProgress(i, users.length);
    }
  }
  
  void processActiveUser(User user) {
    // 处理活跃用户
  }
  
  void updateProgress(int current, int total) {
    // 更新进度
  }
}

// 日志断点示例
class LoggingBreakpointExample {
  Future<void> fetchDataWithLogging() async {
    try {
      debugPrint('开始获取数据');
      
      final response = await httpClient.get('/api/data');
      
      // 在此处设置日志断点，输出response.statusCode
      debugPrint('响应状态码: ${response.statusCode}');
      
      if (response.statusCode == 200) {
        final data = json.decode(response.body);
        
        // 在此处设置日志断点，输出data.length
        debugPrint('获取到 ${data.length} 条数据');
        
        return data;
      } else {
        throw Exception('请求失败: ${response.statusCode}');
      }
    } catch (e) {
      // 在此处设置日志断点，输出异常信息
      debugPrint('获取数据时发生错误: $e');
      rethrow;
    }
  }
}

// 性能分析器
class PerformanceProfiler {
  static final Map<String, Stopwatch> _timers = {};
  static final Map<String, List<int>> _measurements = {};
  
  // 开始计时
  static void startTimer(String name) {
    _timers[name] = Stopwatch()..start();
  }
  
  // 结束计时
  static void endTimer(String name) {
    final timer = _timers[name];
    if (timer != null) {
      timer.stop();
      
      _measurements.putIfAbsent(name, () => []);
      _measurements[name]!.add(timer.elapsedMicroseconds);
      
      debugPrint('$name: ${timer.elapsedMicroseconds}μs');
      _timers.remove(name);
    }
  }
  
  // 获取性能统计
  static Map<String, PerformanceStats> getStats() {
    final stats = <String, PerformanceStats>{};
    
    for (final entry in _measurements.entries) {
      final measurements = entry.value;
      if (measurements.isNotEmpty) {
        final sum = measurements.reduce((a, b) => a + b);
        final avg = sum / measurements.length;
        final min = measurements.reduce(math.min);
        final max = measurements.reduce(math.max);
        
        stats[entry.key] = PerformanceStats(
          count: measurements.length,
          average: avg,
          minimum: min.toDouble(),
          maximum: max.toDouble(),
          total: sum.toDouble(),
        );
      }
    }
    
    return stats;
  }
  
  // 清除统计数据
  static void clearStats() {
    _measurements.clear();
    _timers.clear();
  }
  
  // 性能测试装饰器
  static T measurePerformance<T>(String name, T Function() function) {
    startTimer(name);
    try {
      return function();
    } finally {
      endTimer(name);
    }
  }
  
  // 异步性能测试装饰器
  static Future<T> measureAsyncPerformance<T>(
    String name,
    Future<T> Function() function,
  ) async {
    startTimer(name);
    try {
      return await function();
    } finally {
      endTimer(name);
    }
  }
}

// 性能统计数据
class PerformanceStats {
  final int count;
  final double average;
  final double minimum;
  final double maximum;
  final double total;
  
  PerformanceStats({
    required this.count,
    required this.average,
    required this.minimum,
    required this.maximum,
    required this.total,
  });
  
  @override
  String toString() {
    return 'PerformanceStats(count: $count, avg: ${average.toStringAsFixed(2)}μs, '
           'min: ${minimum.toStringAsFixed(2)}μs, max: ${maximum.toStringAsFixed(2)}μs, '
           'total: ${total.toStringAsFixed(2)}μs)';
  }
}

// 内存监控器
class MemoryMonitor {
  static Timer? _timer;
  static final List<MemorySnapshot> _snapshots = [];
  
  // 开始监控
  static void startMonitoring({Duration interval = const Duration(seconds: 5)}) {
    _timer?.cancel();
    _timer = Timer.periodic(interval, (_) {
      _takeSnapshot();
    });
  }
  
  // 停止监控
  static void stopMonitoring() {
    _timer?.cancel();
    _timer = null;
  }
  
  // 获取内存快照
  static void _takeSnapshot() {
    // 注意：这里需要使用平台特定的API来获取真实的内存使用情况
    // 这里只是示例代码
    final snapshot = MemorySnapshot(
      timestamp: DateTime.now(),
      usedMemory: 0, // 实际实现中需要获取真实值
      totalMemory: 0, // 实际实现中需要获取真实值
    );
    
    _snapshots.add(snapshot);
    
    // 保持最近100个快照
    if (_snapshots.length > 100) {
      _snapshots.removeAt(0);
    }
    
    debugPrint('Memory: ${snapshot.usedMemory}MB / ${snapshot.totalMemory}MB');
  }
  
  // 获取内存使用历史
  static List<MemorySnapshot> getSnapshots() {
    return List.unmodifiable(_snapshots);
  }
  
  // 检测内存泄漏
  static bool detectMemoryLeak({double threshold = 0.1}) {
    if (_snapshots.length < 10) return false;
    
    final recent = _snapshots.takeLast(10).toList();
    final first = recent.first.usedMemory;
    final last = recent.last.usedMemory;
    
    final growthRate = (last - first) / first;
    return growthRate > threshold;
  }
}

// 内存快照
class MemorySnapshot {
  final DateTime timestamp;
  final double usedMemory;
  final double totalMemory;
  
  MemorySnapshot({
    required this.timestamp,
    required this.usedMemory,
    required this.totalMemory,
  });
  
  double get usagePercentage => (usedMemory / totalMemory) * 100;
}

// 测试基类
abstract class BaseTest {
  void setUp() {
    // 通用设置
  }
  
  void tearDown() {
    // 通用清理
  }
}

// 单元测试基类
abstract class BaseUnitTest extends BaseTest {
  @override
  void setUp() {
    super.setUp();
    TestConfigurationManager.instance.setupTestEnvironment();
  }
  
  @override
  void tearDown() {
    TestConfigurationManager.instance.tearDownTestEnvironment();
    super.tearDown();
  }
}

// Widget测试基类
abstract class BaseWidgetTest extends BaseTest {
  late WidgetTester tester;
  
  @override
  void setUp() {
    super.setUp();
    // Widget测试特定设置
  }
  
  // 创建测试应用
  Widget createTestApp(Widget child) {
    return MaterialApp(
      home: Scaffold(body: child),
      theme: ThemeData.light(),
    );
  }
  
  // 等待动画完成
  Future<void> waitForAnimations() async {
    await tester.pumpAndSettle();
  }
  
  // 验证Widget存在
  void expectWidgetExists(Finder finder) {
    expect(finder, findsOneWidget);
  }
}

// 集成测试基类
abstract class BaseIntegrationTest extends BaseTest {
  @override
  void setUp() {
    super.setUp();
    // 集成测试特定设置
  }
  
  // 等待网络请求完成
  Future<void> waitForNetworkRequests() async {
    await Future.delayed(const Duration(seconds: 2));
  }
  
  // 模拟用户登录
  Future<void> simulateUserLogin(WidgetTester tester) async {
    await tester.enterText(find.byKey(const Key('email_field')), 'test@example.com');
    await tester.enterText(find.byKey(const Key('password_field')), 'password123');
    await tester.tap(find.byKey(const Key('login_button')));
    await tester.pumpAndSettle();
  }
}

// 测试数据工厂
class TestDataFactory {
  static UserData createUser({
    String? id,
    String? name,
    String? email,
    DateTime? lastUpdated,
  }) {
    return UserData(
      id: id ?? 'user_${DateTime.now().millisecondsSinceEpoch}',
      name: name ?? 'Test User',
      email: email ?? 'test@example.com',
      lastUpdated: lastUpdated ?? DateTime.now(),
    );
  }
  
  static List<UserData> createUserList(int count) {
    return List.generate(count, (index) => createUser(
      id: 'user_$index',
      name: 'User $index',
      email: 'user$index@example.com',
    ));
  }
  
  static ProductData createProduct({
    String? id,
    String? name,
    double? price,
    String? category,
  }) {
    return ProductData(
      id: id ?? 'product_${DateTime.now().millisecondsSinceEpoch}',
      name: name ?? 'Test Product',
      price: price ?? 99.99,
      category: category ?? 'Electronics',
    );
  }
}

// 测试数据构建器
class UserDataBuilder {
  String _id = 'default_id';
  String _name = 'Default Name';
  String _email = 'default@example.com';
  DateTime _lastUpdated = DateTime.now();
  
  UserDataBuilder withId(String id) {
    _id = id;
    return this;
  }
  
  UserDataBuilder withName(String name) {
    _name = name;
    return this;
  }
  
  UserDataBuilder withEmail(String email) {
    _email = email;
    return this;
  }
  
  UserDataBuilder withLastUpdated(DateTime lastUpdated) {
    _lastUpdated = lastUpdated;
    return this;
  }
  
  UserData build() {
    return UserData(
      id: _id,
      name: _name,
      email: _email,
      lastUpdated: _lastUpdated,
    );
  }
}

// 使用示例
void exampleUsage() {
  // 使用工厂方法
  final user1 = TestDataFactory.createUser(name: 'John Doe');
  final users = TestDataFactory.createUserList(10);
  
  // 使用构建器模式
  final user2 = UserDataBuilder()
      .withId('user123')
      .withName('Jane Smith')
      .withEmail('jane@example.com')
      .build();
}