The `/test` command generates comprehensive test suites with advanced testing methodologies including property-based testing, mutation testing, snapshot testing, and intelligent edge case discovery.

## Usage

```
/test [options] <file_or_function>
```

## Options

### Test Types
- `--unit` - Unit tests with mocking and isolation
- `--integration` - Integration tests with real dependencies
- `--e2e` - End-to-end tests with full system simulation
- `--property` - Property-based testing with hypothesis generation
- `--mutation` - Mutation testing for test quality assessment
- `--snapshot` - Snapshot testing for UI and output consistency
- `--performance` - Performance and load testing
- `--security` - Security and penetration testing
- `--all` - Comprehensive test suite (default)

### Testing Frameworks
- `--jest` - Jest testing framework (JavaScript/TypeScript)
- `--vitest` - Vitest testing framework (faster Jest alternative)
- `--pytest` - pytest framework (Python)
- `--junit` - JUnit framework (Java)
- `--rspec` - RSpec framework (Ruby)
- `--go-test` - Go testing package
- `--rust-test` - Rust testing framework

### Advanced Features
- `--coverage` - Generate code coverage reports with detailed metrics
- `--baseline` - Generate performance baselines and regression detection
- `--fuzz` - Fuzzing tests with random input generation
- `--contract` - Contract testing for API compatibility
- `--visual` - Visual regression testing for UI components

### AI-Powered Features
- `--smart-cases` - AI-generated edge cases and corner cases
- `--behavior-discovery` - Automatic behavior pattern recognition
- `--test-oracle` - AI-powered test oracle generation
- `--failure-prediction` - Predict likely failure scenarios

## Examples

### Advanced React Component Testing

```jsx
// Component to test: UserProfileCard.jsx
import React, { useState, useEffect } from 'react';
import { fetchUserProfile, updateUserProfile } from '../api/users';
import { useAuth } from '../hooks/useAuth';
import { toast } from '../utils/toast';

const UserProfileCard = ({ userId, onProfileUpdate, editable = false }) => {
  const [profile, setProfile] = useState(null);
  const [loading, setLoading] = useState(true);
  const [editing, setEditing] = useState(false);
  const [formData, setFormData] = useState({});
  const [errors, setErrors] = useState({});
  
  const { user: currentUser } = useAuth();
  
  useEffect(() => {
    loadProfile();
  }, [userId]);
  
  const loadProfile = async () => {
    try {
      setLoading(true);
      const userProfile = await fetchUserProfile(userId);
      setProfile(userProfile);
      setFormData({
        name: userProfile.name,
        email: userProfile.email,
        bio: userProfile.bio || ''
      });
    } catch (error) {
      toast.error('Failed to load profile');
    } finally {
      setLoading(false);
    }
  };
  
  const validateForm = () => {
    const newErrors = {};
    
    if (!formData.name?.trim()) {
      newErrors.name = 'Name is required';
    } else if (formData.name.length < 2) {
      newErrors.name = 'Name must be at least 2 characters';
    } else if (formData.name.length > 100) {
      newErrors.name = 'Name must be less than 100 characters';
    }
    
    if (!formData.email?.trim()) {
      newErrors.email = 'Email is required';
    } else if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(formData.email)) {
      newErrors.email = 'Invalid email format';
    }
    
    if (formData.bio && formData.bio.length > 500) {
      newErrors.bio = 'Bio must be less than 500 characters';
    }
    
    setErrors(newErrors);
    return Object.keys(newErrors).length === 0;
  };
  
  const handleSave = async () => {
    if (!validateForm()) return;
    
    try {
      setLoading(true);
      const updatedProfile = await updateUserProfile(userId, formData);
      setProfile(updatedProfile);
      setEditing(false);
      toast.success('Profile updated successfully');
      onProfileUpdate?.(updatedProfile);
    } catch (error) {
      if (error.status === 409) {
        setErrors({ email: 'Email already exists' });
      } else {
        toast.error('Failed to update profile');
      }
    } finally {
      setLoading(false);
    }
  };
  
  const canEdit = editable && (currentUser?.id === userId || currentUser?.role === 'admin');
  
  if (loading && !profile) {
    return <div data-testid="loading-spinner">Loading...</div>;
  }
  
  if (!profile) {
    return <div data-testid="error-message">Profile not found</div>;
  }
  
  return (
    <div data-testid="user-profile-card" className="profile-card">
      <div className="profile-header">
        <img 
          src={profile.avatar || '/default-avatar.png'} 
          alt={`${profile.name}'s avatar`}
          data-testid="profile-avatar"
        />
        {editing ? (
          <input
            type="text"
            value={formData.name}
            onChange={(e) => setFormData(prev => ({ ...prev, name: e.target.value }))}
            data-testid="name-input"
            className={errors.name ? 'error' : ''}
            placeholder="Enter name"
          />
        ) : (
          <h2 data-testid="profile-name">{profile.name}</h2>
        )}
        {errors.name && <span data-testid="name-error" className="error">{errors.name}</span>}
      </div>
      
      <div className="profile-details">
        <div className="detail-item">
          <label>Email:</label>
          {editing ? (
            <input
              type="email"
              value={formData.email}
              onChange={(e) => setFormData(prev => ({ ...prev, email: e.target.value }))}
              data-testid="email-input"
              className={errors.email ? 'error' : ''}
            />
          ) : (
            <span data-testid="profile-email">{profile.email}</span>
          )}
          {errors.email && <span data-testid="email-error" className="error">{errors.email}</span>}
        </div>
        
        <div className="detail-item">
          <label>Bio:</label>
          {editing ? (
            <textarea
              value={formData.bio}
              onChange={(e) => setFormData(prev => ({ ...prev, bio: e.target.value }))}
              data-testid="bio-input"
              className={errors.bio ? 'error' : ''}
              placeholder="Tell us about yourself..."
              maxLength={500}
            />
          ) : (
            <p data-testid="profile-bio">{profile.bio || 'No bio available'}</p>
          )}
          {errors.bio && <span data-testid="bio-error" className="error">{errors.bio}</span>}
        </div>
      </div>
      
      {canEdit && (
        <div className="profile-actions">
          {editing ? (
            <>
              <button
                onClick={handleSave}
                disabled={loading}
                data-testid="save-button"
                className="btn-primary"
              >
                {loading ? 'Saving...' : 'Save Changes'}
              </button>
              <button
                onClick={() => {
                  setEditing(false);
                  setFormData({
                    name: profile.name,
                    email: profile.email,
                    bio: profile.bio || ''
                  });
                  setErrors({});
                }}
                disabled={loading}
                data-testid="cancel-button"
                className="btn-secondary"
              >
                Cancel
              </button>
            </>
          ) : (
            <button
              onClick={() => setEditing(true)}
              data-testid="edit-button"
              className="btn-primary"
            >
              Edit Profile
            </button>
          )}
        </div>
      )}
    </div>
  );
};

export default UserProfileCard;
```

**Generated Advanced Test Suite:**

```javascript
// UserProfileCard.test.jsx - Comprehensive Test Suite
import React from 'react';
import { render, screen, fireEvent, waitFor, within } from '@testing-library/react';
import userEvent from '@testing-library/user-event';
import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
import { faker } from '@faker-js/faker';
import fc from 'fast-check';
import { axe, toHaveNoViolations } from 'jest-axe';

import UserProfileCard from '../UserProfileCard';
import { fetchUserProfile, updateUserProfile } from '../api/users';
import { useAuth } from '../hooks/useAuth';
import { toast } from '../utils/toast';

// Extend Jest matchers
expect.extend(toHaveNoViolations);

// Mock dependencies
vi.mock('../api/users');
vi.mock('../hooks/useAuth');
vi.mock('../utils/toast');

const mockFetchUserProfile = vi.mocked(fetchUserProfile);
const mockUpdateUserProfile = vi.mocked(updateUserProfile);
const mockUseAuth = vi.mocked(useAuth);
const mockToast = vi.mocked(toast);

// Test data generators
const generateValidUser = () => ({
  id: faker.string.uuid(),
  name: faker.person.fullName(),
  email: faker.internet.email(),
  bio: faker.lorem.paragraph(),
  avatar: faker.image.avatar(),
  createdAt: faker.date.past().toISOString(),
  updatedAt: faker.date.recent().toISOString()
});

const generateInvalidUser = () => ({
  id: '',
  name: '',
  email: 'invalid-email',
  bio: 'x'.repeat(600), // Exceeds 500 char limit
  avatar: null
});

// Custom render function with providers
const renderUserProfileCard = (props = {}) => {
  const defaultProps = {
    userId: faker.string.uuid(),
    editable: false,
    onProfileUpdate: vi.fn(),
    ...props
  };
  
  return {
    ...render(<UserProfileCard {...defaultProps} />),
    props: defaultProps
  };
};

describe('UserProfileCard', () => {
  let mockCurrentUser;
  
  beforeEach(() => {
    vi.clearAllMocks();
    
    // Default auth state
    mockCurrentUser = generateValidUser();
    mockUseAuth.mockReturnValue({ user: mockCurrentUser });
    
    // Default toast implementation
    mockToast.success = vi.fn();
    mockToast.error = vi.fn();
  });
  
  afterEach(() => {
    vi.restoreAllMocks();
  });
  
  describe('Loading States', () => {
    it('should show loading spinner while fetching profile', () => {
      mockFetchUserProfile.mockImplementation(() => new Promise(() => {})); // Never resolves
      
      renderUserProfileCard();
      
      expect(screen.getByTestId('loading-spinner')).toBeInTheDocument();
      expect(screen.getByText('Loading...')).toBeInTheDocument();
    });
    
    it('should show loading button text while saving', async () => {
      const user = userEvent.setup();
      const mockProfile = generateValidUser();
      
      mockFetchUserProfile.mockResolvedValue(mockProfile);
      mockUpdateUserProfile.mockImplementation(() => new Promise(() => {})); // Never resolves
      
      renderUserProfileCard({ 
        userId: mockProfile.id, 
        editable: true 
      });
      
      await waitFor(() => {
        expect(screen.getByTestId('profile-name')).toHaveTextContent(mockProfile.name);
      });
      
      await user.click(screen.getByTestId('edit-button'));
      await user.click(screen.getByTestId('save-button'));
      
      expect(screen.getByTestId('save-button')).toHaveTextContent('Saving...');
      expect(screen.getByTestId('save-button')).toBeDisabled();
      expect(screen.getByTestId('cancel-button')).toBeDisabled();
    });
  });
  
  describe('Profile Display', () => {
    it('should display profile information correctly', async () => {
      const mockProfile = generateValidUser();
      mockFetchUserProfile.mockResolvedValue(mockProfile);
      
      renderUserProfileCard({ userId: mockProfile.id });
      
      await waitFor(() => {
        expect(screen.getByTestId('profile-name')).toHaveTextContent(mockProfile.name);
      });
      
      expect(screen.getByTestId('profile-email')).toHaveTextContent(mockProfile.email);
      expect(screen.getByTestId('profile-bio')).toHaveTextContent(mockProfile.bio);
      expect(screen.getByTestId('profile-avatar')).toHaveAttribute('src', mockProfile.avatar);
      expect(screen.getByTestId('profile-avatar')).toHaveAttribute('alt', `${mockProfile.name}'s avatar`);
    });
    
    it('should display default avatar when user has no avatar', async () => {
      const mockProfile = { ...generateValidUser(), avatar: null };
      mockFetchUserProfile.mockResolvedValue(mockProfile);
      
      renderUserProfileCard({ userId: mockProfile.id });
      
      await waitFor(() => {
        expect(screen.getByTestId('profile-avatar')).toHaveAttribute('src', '/default-avatar.png');
      });
    });
    
    it('should display "No bio available" when user has no bio', async () => {
      const mockProfile = { ...generateValidUser(), bio: null };
      mockFetchUserProfile.mockResolvedValue(mockProfile);
      
      renderUserProfileCard({ userId: mockProfile.id });
      
      await waitFor(() => {
        expect(screen.getByTestId('profile-bio')).toHaveTextContent('No bio available');
      });
    });
  });
  
  describe('Error Handling', () => {
    it('should show error message when profile fetch fails', async () => {
      const errorMessage = 'Network error';
      mockFetchUserProfile.mockRejectedValue(new Error(errorMessage));
      
      renderUserProfileCard();
      
      await waitFor(() => {
        expect(screen.getByTestId('error-message')).toBeInTheDocument();
      });
      
      expect(mockToast.error).toHaveBeenCalledWith('Failed to load profile');
    });
    
    it('should handle API errors during profile update', async () => {
      const user = userEvent.setup();
      const mockProfile = generateValidUser();
      
      mockFetchUserProfile.mockResolvedValue(mockProfile);
      mockUpdateUserProfile.mockRejectedValue(new Error('Server error'));
      
      renderUserProfileCard({ 
        userId: mockProfile.id, 
        editable: true 
      });
      
      await waitFor(() => {
        expect(screen.getByTestId('edit-button')).toBeInTheDocument();
      });
      
      await user.click(screen.getByTestId('edit-button'));
      await user.clear(screen.getByTestId('name-input'));
      await user.type(screen.getByTestId('name-input'), 'Updated Name');
      await user.click(screen.getByTestId('save-button'));
      
      await waitFor(() => {
        expect(mockToast.error).toHaveBeenCalledWith('Failed to update profile');
      });
    });
    
    it('should handle email conflict error specifically', async () => {
      const user = userEvent.setup();
      const mockProfile = generateValidUser();
      const conflictError = new Error('Conflict');
      conflictError.status = 409;
      
      mockFetchUserProfile.mockResolvedValue(mockProfile);
      mockUpdateUserProfile.mockRejectedValue(conflictError);
      
      renderUserProfileCard({ 
        userId: mockProfile.id, 
        editable: true 
      });
      
      await waitFor(() => {
        expect(screen.getByTestId('edit-button')).toBeInTheDocument();
      });
      
      await user.click(screen.getByTestId('edit-button'));
      await user.clear(screen.getByTestId('email-input'));
      await user.type(screen.getByTestId('email-input'), 'existing@example.com');
      await user.click(screen.getByTestId('save-button'));
      
      await waitFor(() => {
        expect(screen.getByTestId('email-error')).toHaveTextContent('Email already exists');
      });
    });
  });
  
  describe('Permission System', () => {
    it('should show edit button for profile owner', async () => {
      const mockProfile = { ...generateValidUser(), id: mockCurrentUser.id };
      mockFetchUserProfile.mockResolvedValue(mockProfile);
      
      renderUserProfileCard({ 
        userId: mockProfile.id, 
        editable: true 
      });
      
      await waitFor(() => {
        expect(screen.getByTestId('edit-button')).toBeInTheDocument();
      });
    });
    
    it('should show edit button for admin users', async () => {
      const mockProfile = generateValidUser();
      const adminUser = { ...mockCurrentUser, role: 'admin' };
      
      mockUseAuth.mockReturnValue({ user: adminUser });
      mockFetchUserProfile.mockResolvedValue(mockProfile);
      
      renderUserProfileCard({ 
        userId: mockProfile.id, 
        editable: true 
      });
      
      await waitFor(() => {
        expect(screen.getByTestId('edit-button')).toBeInTheDocument();
      });
    });
    
    it('should not show edit button for other users', async () => {
      const mockProfile = generateValidUser();
      mockFetchUserProfile.mockResolvedValue(mockProfile);
      
      renderUserProfileCard({ 
        userId: mockProfile.id, 
        editable: true 
      });
      
      await waitFor(() => {
        expect(screen.getByTestId('profile-name')).toBeInTheDocument();
      });
      
      expect(screen.queryByTestId('edit-button')).not.toBeInTheDocument();
    });
    
    it('should not show edit button when editable is false', async () => {
      const mockProfile = { ...generateValidUser(), id: mockCurrentUser.id };
      mockFetchUserProfile.mockResolvedValue(mockProfile);
      
      renderUserProfileCard({ 
        userId: mockProfile.id, 
        editable: false 
      });
      
      await waitFor(() => {
        expect(screen.getByTestId('profile-name')).toBeInTheDocument();
      });
      
      expect(screen.queryByTestId('edit-button')).not.toBeInTheDocument();
    });
  });
  
  describe('Form Validation', () => {
    beforeEach(async () => {
      const mockProfile = { ...generateValidUser(), id: mockCurrentUser.id };
      mockFetchUserProfile.mockResolvedValue(mockProfile);
      
      renderUserProfileCard({ 
        userId: mockProfile.id, 
        editable: true 
      });
      
      await waitFor(() => {
        expect(screen.getByTestId('edit-button')).toBeInTheDocument();
      });
      
      await userEvent.setup().click(screen.getByTestId('edit-button'));
    });
    
    it('should validate required name field', async () => {
      const user = userEvent.setup();
      
      await user.clear(screen.getByTestId('name-input'));
      await user.click(screen.getByTestId('save-button'));
      
      expect(screen.getByTestId('name-error')).toHaveTextContent('Name is required');
      expect(mockUpdateUserProfile).not.toHaveBeenCalled();
    });
    
    it('should validate minimum name length', async () => {
      const user = userEvent.setup();
      
      await user.clear(screen.getByTestId('name-input'));
      await user.type(screen.getByTestId('name-input'), 'A');
      await user.click(screen.getByTestId('save-button'));
      
      expect(screen.getByTestId('name-error')).toHaveTextContent('Name must be at least 2 characters');
    });
    
    it('should validate maximum name length', async () => {
      const user = userEvent.setup();
      const longName = 'A'.repeat(101);
      
      await user.clear(screen.getByTestId('name-input'));
      await user.type(screen.getByTestId('name-input'), longName);
      await user.click(screen.getByTestId('save-button'));
      
      expect(screen.getByTestId('name-error')).toHaveTextContent('Name must be less than 100 characters');
    });
    
    it('should validate required email field', async () => {
      const user = userEvent.setup();
      
      await user.clear(screen.getByTestId('email-input'));
      await user.click(screen.getByTestId('save-button'));
      
      expect(screen.getByTestId('email-error')).toHaveTextContent('Email is required');
    });
    
    it('should validate email format', async () => {
      const user = userEvent.setup();
      
      await user.clear(screen.getByTestId('email-input'));
      await user.type(screen.getByTestId('email-input'), 'invalid-email');
      await user.click(screen.getByTestId('save-button'));
      
      expect(screen.getByTestId('email-error')).toHaveTextContent('Invalid email format');
    });
    
    it('should validate bio length', async () => {
      const user = userEvent.setup();
      const longBio = 'A'.repeat(501);
      
      await user.clear(screen.getByTestId('bio-input'));
      await user.type(screen.getByTestId('bio-input'), longBio);
      await user.click(screen.getByTestId('save-button'));
      
      expect(screen.getByTestId('bio-error')).toHaveTextContent('Bio must be less than 500 characters');
    });
    
    it('should allow empty bio', async () => {
      const user = userEvent.setup();
      const updatedProfile = generateValidUser();
      
      mockUpdateUserProfile.mockResolvedValue(updatedProfile);
      
      await user.clear(screen.getByTestId('bio-input'));
      await user.click(screen.getByTestId('save-button'));
      
      expect(screen.queryByTestId('bio-error')).not.toBeInTheDocument();
      expect(mockUpdateUserProfile).toHaveBeenCalled();
    });
  });
  
  describe('Edit Mode Functionality', () => {
    let mockProfile;
    
    beforeEach(async () => {
      mockProfile = { ...generateValidUser(), id: mockCurrentUser.id };
      mockFetchUserProfile.mockResolvedValue(mockProfile);
      
      renderUserProfileCard({ 
        userId: mockProfile.id, 
        editable: true 
      });
      
      await waitFor(() => {
        expect(screen.getByTestId('edit-button')).toBeInTheDocument();
      });
    });
    
    it('should switch to edit mode when edit button is clicked', async () => {
      const user = userEvent.setup();
      
      await user.click(screen.getByTestId('edit-button'));
      
      expect(screen.getByTestId('name-input')).toHaveValue(mockProfile.name);
      expect(screen.getByTestId('email-input')).toHaveValue(mockProfile.email);
      expect(screen.getByTestId('bio-input')).toHaveValue(mockProfile.bio);
      expect(screen.getByTestId('save-button')).toBeInTheDocument();
      expect(screen.getByTestId('cancel-button')).toBeInTheDocument();
      expect(screen.queryByTestId('edit-button')).not.toBeInTheDocument();
    });
    
    it('should cancel edit mode and restore original values', async () => {
      const user = userEvent.setup();
      
      await user.click(screen.getByTestId('edit-button'));
      
      // Make changes
      await user.clear(screen.getByTestId('name-input'));
      await user.type(screen.getByTestId('name-input'), 'Changed Name');
      
      // Cancel
      await user.click(screen.getByTestId('cancel-button'));
      
      expect(screen.getByTestId('profile-name')).toHaveTextContent(mockProfile.name);
      expect(screen.getByTestId('edit-button')).toBeInTheDocument();
      expect(screen.queryByTestId('save-button')).not.toBeInTheDocument();
    });
    
    it('should save changes and exit edit mode', async () => {
      const user = userEvent.setup();
      const updatedProfile = {
        ...mockProfile,
        name: 'Updated Name',
        email: 'updated@example.com'
      };
      
      mockUpdateUserProfile.mockResolvedValue(updatedProfile);
      
      await user.click(screen.getByTestId('edit-button'));
      
      await user.clear(screen.getByTestId('name-input'));
      await user.type(screen.getByTestId('name-input'), updatedProfile.name);
      
      await user.clear(screen.getByTestId('email-input'));
      await user.type(screen.getByTestId('email-input'), updatedProfile.email);
      
      await user.click(screen.getByTestId('save-button'));
      
      await waitFor(() => {
        expect(mockUpdateUserProfile).toHaveBeenCalledWith(mockProfile.id, {
          name: updatedProfile.name,
          email: updatedProfile.email,
          bio: mockProfile.bio
        });
      });
      
      expect(mockToast.success).toHaveBeenCalledWith('Profile updated successfully');
      expect(screen.getByTestId('profile-name')).toHaveTextContent(updatedProfile.name);
      expect(screen.getByTestId('edit-button')).toBeInTheDocument();
    });
  });
  
  describe('Callback Functions', () => {
    it('should call onProfileUpdate callback after successful save', async () => {
      const user = userEvent.setup();
      const mockProfile = { ...generateValidUser(), id: mockCurrentUser.id };
      const updatedProfile = { ...mockProfile, name: 'Updated Name' };
      const mockOnProfileUpdate = vi.fn();
      
      mockFetchUserProfile.mockResolvedValue(mockProfile);
      mockUpdateUserProfile.mockResolvedValue(updatedProfile);
      
      renderUserProfileCard({ 
        userId: mockProfile.id, 
        editable: true,
        onProfileUpdate: mockOnProfileUpdate
      });
      
      await waitFor(() => {
        expect(screen.getByTestId('edit-button')).toBeInTheDocument();
      });
      
      await user.click(screen.getByTestId('edit-button'));
      await user.clear(screen.getByTestId('name-input'));
      await user.type(screen.getByTestId('name-input'), updatedProfile.name);
      await user.click(screen.getByTestId('save-button'));
      
      await waitFor(() => {
        expect(mockOnProfileUpdate).toHaveBeenCalledWith(updatedProfile);
      });
    });
    
    it('should not call onProfileUpdate callback on save failure', async () => {
      const user = userEvent.setup();
      const mockProfile = { ...generateValidUser(), id: mockCurrentUser.id };
      const mockOnProfileUpdate = vi.fn();
      
      mockFetchUserProfile.mockResolvedValue(mockProfile);
      mockUpdateUserProfile.mockRejectedValue(new Error('Save failed'));
      
      renderUserProfileCard({ 
        userId: mockProfile.id, 
        editable: true,
        onProfileUpdate: mockOnProfileUpdate
      });
      
      await waitFor(() => {
        expect(screen.getByTestId('edit-button')).toBeInTheDocument();
      });
      
      await user.click(screen.getByTestId('edit-button'));
      await user.click(screen.getByTestId('save-button'));
      
      await waitFor(() => {
        expect(mockToast.error).toHaveBeenCalled();
      });
      
      expect(mockOnProfileUpdate).not.toHaveBeenCalled();
    });
  });
  
  describe('Accessibility', () => {
    it('should have no accessibility violations', async () => {
      const mockProfile = generateValidUser();
      mockFetchUserProfile.mockResolvedValue(mockProfile);
      
      const { container } = renderUserProfileCard({ userId: mockProfile.id });
      
      await waitFor(() => {
        expect(screen.getByTestId('profile-name')).toBeInTheDocument();
      });
      
      const results = await axe(container);
      expect(results).toHaveNoViolations();
    });
    
    it('should have proper ARIA labels and roles', async () => {
      const mockProfile = generateValidUser();
      mockFetchUserProfile.mockResolvedValue(mockProfile);
      
      renderUserProfileCard({ userId: mockProfile.id, editable: true });
      
      await waitFor(() => {
        expect(screen.getByTestId('edit-button')).toBeInTheDocument();
      });
      
      const avatar = screen.getByTestId('profile-avatar');
      expect(avatar).toHaveAttribute('alt', `${mockProfile.name}'s avatar`);
      
      await userEvent.setup().click(screen.getByTestId('edit-button'));
      
      const nameInput = screen.getByTestId('name-input');
      expect(nameInput).toHaveAttribute('placeholder', 'Enter name');
      
      const bioInput = screen.getByTestId('bio-input');
      expect(bioInput).toHaveAttribute('placeholder', 'Tell us about yourself...');
      expect(bioInput).toHaveAttribute('maxLength', '500');
    });
  });
  
  describe('Property-Based Testing', () => {
    it('should handle any valid user profile data', () => {
      fc.assert(
        fc.property(
          fc.record({
            id: fc.string({ minLength: 1 }),
            name: fc.string({ minLength: 2, maxLength: 100 }),
            email: fc.emailAddress(),
            bio: fc.option(fc.string({ maxLength: 500 }), { nil: undefined }),
            avatar: fc.option(fc.webUrl(), { nil: undefined })
          }),
          (profile) => {
            mockFetchUserProfile.mockResolvedValue(profile);
            
            const { unmount } = renderUserProfileCard({ userId: profile.id });
            
            // Should not throw any errors
            expect(() => {
              screen.getByTestId('user-profile-card');
            }).not.toThrow();
            
            unmount();
          }
        ),
        { numRuns: 100 }
      );
    });
    
    it('should validate form inputs with random invalid data', () => {
      fc.assert(
        fc.property(
          fc.record({
            name: fc.oneof(
              fc.constant(''), // Empty string
              fc.string({ minLength: 1, maxLength: 1 }), // Too short
              fc.string({ minLength: 101, maxLength: 200 }), // Too long
            ),
            email: fc.oneof(
              fc.constant(''), // Empty string
              fc.string().filter(s => !s.includes('@')), // Invalid format
              fc.string().map(s => s + '@'), // Incomplete email
            ),
            bio: fc.string({ minLength: 501, maxLength: 1000 }) // Too long
          }),
          async (invalidData) => {
            const mockProfile = { ...generateValidUser(), id: mockCurrentUser.id };
            mockFetchUserProfile.mockResolvedValue(mockProfile);
            
            const { unmount } = renderUserProfileCard({ 
              userId: mockProfile.id, 
              editable: true 
            });
            
            await waitFor(() => {
              expect(screen.getByTestId('edit-button')).toBeInTheDocument();
            });
            
            const user = userEvent.setup();
            await user.click(screen.getByTestId('edit-button'));
            
            // Fill form with invalid data
            await user.clear(screen.getByTestId('name-input'));
            await user.type(screen.getByTestId('name-input'), invalidData.name);
            
            await user.clear(screen.getByTestId('email-input'));
            await user.type(screen.getByTestId('email-input'), invalidData.email);
            
            await user.clear(screen.getByTestId('bio-input'));
            await user.type(screen.getByTestId('bio-input'), invalidData.bio);
            
            await user.click(screen.getByTestId('save-button'));
            
            // Should show validation errors
            expect(
              screen.queryByTestId('name-error') ||
              screen.queryByTestId('email-error') ||
              screen.queryByTestId('bio-error')
            ).toBeInTheDocument();
            
            // Should not call update API
            expect(mockUpdateUserProfile).not.toHaveBeenCalled();
            
            unmount();
          }
        ),
        { numRuns: 50 }
      );
    });
  });
  
  describe('Performance Testing', () => {
    it('should render within performance budget', async () => {
      const mockProfile = generateValidUser();
      mockFetchUserProfile.mockResolvedValue(mockProfile);
      
      const startTime = performance.now();
      
      renderUserProfileCard({ userId: mockProfile.id });
      
      await waitFor(() => {
        expect(screen.getByTestId('profile-name')).toBeInTheDocument();
      });
      
      const endTime = performance.now();
      const renderTime = endTime - startTime;
      
      // Should render within 100ms
      expect(renderTime).toBeLessThan(100);
    });
    
    it('should handle rapid state changes without performance degradation', async () => {
      const mockProfile = { ...generateValidUser(), id: mockCurrentUser.id };
      mockFetchUserProfile.mockResolvedValue(mockProfile);
      mockUpdateUserProfile.mockResolvedValue(mockProfile);
      
      renderUserProfileCard({ 
        userId: mockProfile.id, 
        editable: true 
      });
      
      await waitFor(() => {
        expect(screen.getByTestId('edit-button')).toBeInTheDocument();
      });
      
      const user = userEvent.setup();
      const startTime = performance.now();
      
      // Rapid edit mode toggling
      for (let i = 0; i < 10; i++) {
        await user.click(screen.getByTestId('edit-button'));
        await user.click(screen.getByTestId('cancel-button'));
      }
      
      const endTime = performance.now();
      const totalTime = endTime - startTime;
      
      // Should complete all operations within 500ms
      expect(totalTime).toBeLessThan(500);
    });
  });
  
  describe('Visual Regression Testing', () => {
    it('should match visual snapshot in display mode', async () => {
      const mockProfile = generateValidUser();
      mockFetchUserProfile.mockResolvedValue(mockProfile);
      
      const { container } = renderUserProfileCard({ userId: mockProfile.id });
      
      await waitFor(() => {
        expect(screen.getByTestId('profile-name')).toBeInTheDocument();
      });
      
      expect(container.firstChild).toMatchSnapshot('user-profile-display-mode');
    });
    
    it('should match visual snapshot in edit mode', async () => {
      const mockProfile = { ...generateValidUser(), id: mockCurrentUser.id };
      mockFetchUserProfile.mockResolvedValue(mockProfile);
      
      const { container } = renderUserProfileCard({ 
        userId: mockProfile.id, 
        editable: true 
      });
      
      await waitFor(() => {
        expect(screen.getByTestId('edit-button')).toBeInTheDocument();
      });
      
      await userEvent.setup().click(screen.getByTestId('edit-button'));
      
      expect(container.firstChild).toMatchSnapshot('user-profile-edit-mode');
    });
  });
  
  describe('Integration Testing', () => {
    it('should integrate correctly with auth system', async () => {
      const adminUser = { ...mockCurrentUser, role: 'admin' };
      const regularUser = generateValidUser();
      
      // Test as admin
      mockUseAuth.mockReturnValue({ user: adminUser });
      mockFetchUserProfile.mockResolvedValue(regularUser);
      
      const { rerender } = renderUserProfileCard({ 
        userId: regularUser.id, 
        editable: true 
      });
      
      await waitFor(() => {
        expect(screen.getByTestId('edit-button')).toBeInTheDocument();
      });
      
      // Switch to regular user
      mockUseAuth.mockReturnValue({ user: regularUser });
      
      rerender(
        <UserProfileCard 
          userId={regularUser.id} 
          editable={true}
          onProfileUpdate={vi.fn()}
        />
      );
      
      expect(screen.queryByTestId('edit-button')).not.toBeInTheDocument();
    });
  });
  
  describe('Edge Cases', () => {
    it('should handle extremely long profile data gracefully', async () => {
      const mockProfile = {
        ...generateValidUser(),
        name: 'A'.repeat(1000),
        bio: 'B'.repeat(10000)
      };
      
      mockFetchUserProfile.mockResolvedValue(mockProfile);
      
      renderUserProfileCard({ userId: mockProfile.id });
      
      await waitFor(() => {
        expect(screen.getByTestId('user-profile-card')).toBeInTheDocument();
      });
      
      // Should not break rendering
      expect(screen.getByTestId('profile-name')).toBeInTheDocument();
      expect(screen.getByTestId('profile-bio')).toBeInTheDocument();
    });
    
    it('should handle special characters in profile data', async () => {
      const mockProfile = {
        ...generateValidUser(),
        name: '测试用户 🚀 <script>alert("xss")</script>',
        bio: 'Bio with 🎉 emojis and <b>HTML</b> & special chars: @#$%^&*()'
      };
      
      mockFetchUserProfile.mockResolvedValue(mockProfile);
      
      renderUserProfileCard({ userId: mockProfile.id });
      
      await waitFor(() => {
        expect(screen.getByTestId('profile-name')).toHaveTextContent(mockProfile.name);
      });
      
      // Should display special characters safely
      expect(screen.getByTestId('profile-bio')).toHaveTextContent(mockProfile.bio);
    });
    
    it('should handle rapid prop changes', async () => {
      const user1 = generateValidUser();
      const user2 = generateValidUser();
      
      mockFetchUserProfile.mockImplementation((id) => {
        if (id === user1.id) return Promise.resolve(user1);
        if (id === user2.id) return Promise.resolve(user2);
        return Promise.reject(new Error('User not found'));
      });
      
      const { rerender } = renderUserProfileCard({ userId: user1.id });
      
      await waitFor(() => {
        expect(screen.getByTestId('profile-name')).toHaveTextContent(user1.name);
      });
      
      // Rapidly change user ID
      rerender(
        <UserProfileCard 
          userId={user2.id}
          editable={false}
          onProfileUpdate={vi.fn()}
        />
      );
      
      await waitFor(() => {
        expect(screen.getByTestId('profile-name')).toHaveTextContent(user2.name);
      });
      
      expect(mockFetchUserProfile).toHaveBeenCalledWith(user1.id);
      expect(mockFetchUserProfile).toHaveBeenCalledWith(user2.id);
    });
  });
});

// Mutation Testing Configuration
export const mutationTestConfig = {
  testMatch: ['**/*.test.{js,jsx}'],
  mutators: [
    'ArithmeticOperator',
    'ArrayDeclaration',
    'ArrowFunction',
    'Block',
    'BooleanLiteral',
    'ConditionalExpression',
    'EqualityOperator',
    'LogicalOperator',
    'MethodExpression',
    'ObjectLiteral',
    'StringLiteral',
    'UnaryOperator',
    'UpdateOperator'
  ],
  thresholds: {
    high: 90,
    low: 80
  },
  timeoutMS: 30000,
  maxConcurrentTestRunners: 4
};

// Performance benchmarking
export const performanceBenchmarks = {
  'UserProfileCard render time': {
    threshold: 100, // milliseconds
    setup: () => {
      const mockProfile = generateValidUser();
      mockFetchUserProfile.mockResolvedValue(mockProfile);
      return { userId: mockProfile.id };
    },
    test: (props) => {
      const start = performance.now();
      renderUserProfileCard(props);
      return performance.now() - start;
    }
  },
  'Edit mode transition': {
    threshold: 50,
    setup: async () => {
      const mockProfile = { ...generateValidUser(), id: mockCurrentUser.id };
      mockFetchUserProfile.mockResolvedValue(mockProfile);
      
      renderUserProfileCard({ 
        userId: mockProfile.id, 
        editable: true 
      });
      
      await waitFor(() => {
        expect(screen.getByTestId('edit-button')).toBeInTheDocument();
      });
      
      return { editButton: screen.getByTestId('edit-button') };
    },
    test: async ({ editButton }) => {
      const start = performance.now();
      await userEvent.setup().click(editButton);
      await waitFor(() => {
        expect(screen.getByTestId('save-button')).toBeInTheDocument();
      });
      return performance.now() - start;
    }
  }
};
```

## Advanced Testing Features

### Mutation Testing
- **Code Quality Assessment**: Measures test suite effectiveness
- **Fault Detection**: Identifies weak test coverage areas
- **Test Improvement**: Suggests additional test cases
- **Quality Metrics**: Provides mutation score and coverage analytics

### Property-Based Testing
- **Hypothesis Generation**: AI-powered test case creation
- **Edge Case Discovery**: Automatic boundary value testing
- **Invariant Verification**: Ensures consistent behavior patterns
- **Input Space Exploration**: Comprehensive input combination testing

### Visual Regression Testing
- **UI Consistency**: Detects unintended visual changes
- **Cross-browser Testing**: Validates appearance across platforms
- **Responsive Testing**: Ensures mobile/desktop compatibility
- **Component Isolation**: Tests individual component rendering

### Performance Testing
- **Render Performance**: Measures component render times
- **Memory Usage**: Tracks memory leaks and optimization opportunities
- **User Interaction**: Benchmarks user interaction responsiveness
- **Load Testing**: Simulates high-frequency usage patterns

This advanced test generator creates comprehensive, maintainable test suites that ensure code quality, performance, and reliability across all application layers.