new committ

app.py

@@ -100,28 +100,97 @@ def ensure_initialized():
                     logger.warning("⚠️ Model initialization failed, using template mode")
                 _initialized = True
 
+def read_uploaded_file(file_obj):
+    """Read and extract text from uploaded file"""
+    if file_obj is None:
+        return ""
+    
+    try:
+        file_path = file_obj.name
+        file_extension = os.path.splitext(file_path)[1].lower()
+        
+        if file_extension in ['.txt', '.md']:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+        elif file_extension in ['.doc', '.docx']:
+            try:
+                import docx
+                doc = docx.Document(file_path)
+                content = '\n'.join([paragraph.text for paragraph in doc.paragraphs])
+            except ImportError:
+                logger.warning("python-docx not available, trying to read as text")
+                with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+                    content = f.read()
+        elif file_extension == '.pdf':
+            try:
+                import PyPDF2
+                with open(file_path, 'rb') as f:
+                    reader = PyPDF2.PdfReader(f)
+                    content = ''
+                    for page in reader.pages:
+                        content += page.extract_text() + '\n'
+            except ImportError:
+                logger.warning("PyPDF2 not available, cannot read PDF files")
+                return "❌ PDF support requires PyPDF2. Please install it or use text/Word files."
+        else:
+            # Try to read as plain text
+            with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+                content = f.read()
+        
+        logger.info(f"📄 File read successfully: {len(content)} characters")
+        return content
+        
+    except Exception as e:
+        logger.error(f"❌ Error reading file: {str(e)}")
+        return f"❌ Error reading file: {str(e)}"
+
+def combine_inputs(prompt_text, uploaded_file):
+    """Combine prompt text and uploaded file content"""
+    file_content = ""
+    
+    if uploaded_file is not None:
+        file_content = read_uploaded_file(uploaded_file)
+        if file_content.startswith("❌"):
+            return file_content  # Return error message
+    
+    # Combine both inputs
+    combined_text = ""
+    
+    if prompt_text and prompt_text.strip():
+        combined_text += "PROMPT:\n" + prompt_text.strip() + "\n\n"
+    
+    if file_content and not file_content.startswith("❌"):
+        combined_text += "DOCUMENT CONTENT:\n" + file_content.strip()
+    
+    if not combined_text.strip():
+        return "❌ Please provide either text input or upload a document."
+    
+    return combined_text.strip()
+
 # Initialize on startup
 ensure_initialized()
 
 @smart_memory_monitor
-def generate_test_cases_api(srs_text):
-    """Main API function for generating test cases"""
-    if not srs_text or not srs_text.strip():
+def generate_test_cases_api(prompt_text, uploaded_file):
+    """Main API function for generating test cases with dual input support"""
+    
+    # Combine inputs
+    combined_input = combine_inputs(prompt_text, uploaded_file)
+    
+    if combined_input.startswith("❌"):
         return {
-            "error": "No SRS or prompt content provided",
+            "error": combined_input,
             "test_cases": [],
             "count": 0
         }
-
-    srs_text = srs_text.strip()
     
-    if len(srs_text) > 5000:
-        logger.warning(f"SRS text truncated from {len(srs_text)} to 5000 characters")
-        srs_text = srs_text[:5000]
+    if len(combined_input) > 8000:
+        logger.warning(f"Input text truncated from {len(combined_input)} to 8000 characters")
+        combined_input = combined_input[:8000]
 
     try:
-        logger.info(f"🎯 Generating test cases for input ({len(srs_text)} chars)")
-        test_cases = generate_test_cases(srs_text)
+        logger.info(f"🎯 Generating test cases for combined input ({len(combined_input)} chars)")
+        test_cases = generate_test_cases(combined_input)
 
         if not test_cases or len(test_cases) == 0:
             logger.error("No test cases generated")
@@ -141,8 +210,8 @@ def generate_test_cases_api(srs_text):
             generation_method = "template_mode"
 
         if model_used == "Template-Based Generator":
-            model_algorithm = "Rule-based Template"
-            model_reason = "Used rule-based generation due to memory constraints or fallback condition."
+            model_algorithm = "Enhanced Rule-based Template"
+            model_reason = "Used enhanced rule-based generation with pattern matching and context analysis."
         elif "distilgpt2" in model_used:
             model_algorithm = "Transformer-based LM"
             model_reason = "Used DistilGPT2 for balanced performance and memory efficiency."
@@ -161,7 +230,9 @@ def generate_test_cases_api(srs_text):
             "model_used": model_used,
             "generation_method": generation_method,
             "model_algorithm": model_algorithm,
-            "model_reason": model_reason
+            "model_reason": model_reason,
+            "input_source": "Combined (Prompt + Document)" if (prompt_text and uploaded_file) else 
+                           "Document Upload" if uploaded_file else "Text Prompt"
         }
 
     except Exception as e:
@@ -184,38 +255,59 @@ def format_test_cases_output(result):
     
     # Format test cases for display
     formatted_output = f"✅ Generated {result['count']} Test Cases\n\n"
+    formatted_output += f"📥 Input Source: {result.get('input_source', 'Unknown')}\n"
     formatted_output += f"🤖 Model: {result['model_used']}\n"
     formatted_output += f"🔧 Algorithm: {result['model_algorithm']}\n"
     formatted_output += f"💡 Reason: {result['model_reason']}\n\n"
     
-    formatted_output += "=" * 50 + "\n"
-    formatted_output += "TEST CASES:\n"
-    formatted_output += "=" * 50 + "\n\n"
+    formatted_output += "=" * 60 + "\n"
+    formatted_output += "GENERATED TEST CASES\n"
+    formatted_output += "=" * 60 + "\n\n"
     
     for i, tc in enumerate(test_cases, 1):
         formatted_output += f"🔹 Test Case {i}:\n"
         formatted_output += f"   ID: {tc.get('id', f'TC_{i:03d}')}\n"
         formatted_output += f"   Title: {tc.get('title', 'N/A')}\n"
+        formatted_output += f"   Priority: {tc.get('priority', 'Medium')}\n"
+        formatted_output += f"   Category: {tc.get('category', 'Functional')}\n"
         formatted_output += f"   Description: {tc.get('description', 'N/A')}\n"
         
+        # Pre-conditions
+        preconditions = tc.get('preconditions', [])
+        if preconditions:
+            formatted_output += f"   Pre-conditions:\n"
+            for j, precond in enumerate(preconditions, 1):
+                formatted_output += f"      • {precond}\n"
+        
+        # Test steps
         steps = tc.get('steps', [])
-        if isinstance(steps, list):
-            formatted_output += f"   Steps:\n"
+        if isinstance(steps, list) and steps:
+            formatted_output += f"   Test Steps:\n"
             for j, step in enumerate(steps, 1):
                 formatted_output += f"      {j}. {step}\n"
         else:
-            formatted_output += f"   Steps: {steps}\n"
+            formatted_output += f"   Test Steps: {steps if steps else 'N/A'}\n"
         
-        formatted_output += f"   Expected Result: {tc.get('expected', 'N/A')}\n\n"
+        formatted_output += f"   Expected Result: {tc.get('expected', 'N/A')}\n"
+        
+        # Post-conditions
+        postconditions = tc.get('postconditions', [])
+        if postconditions:
+            formatted_output += f"   Post-conditions:\n"
+            for postcond in postconditions:
+                formatted_output += f"      • {postcond}\n"
+        
+        formatted_output += f"   Test Data: {tc.get('test_data', 'N/A')}\n"
+        formatted_output += "\n" + "-" * 40 + "\n\n"
     
     # Return JSON for API access
     json_output = json.dumps(result, indent=2)
     
     return formatted_output, json_output
 
-def gradio_generate_test_cases(srs_text):
+def gradio_generate_test_cases(prompt_text, uploaded_file):
     """Gradio interface function"""
-    result = generate_test_cases_api(srs_text)
+    result = generate_test_cases_api(prompt_text, uploaded_file)
     return format_test_cases_output(result)
 
 def get_system_status():
@@ -226,7 +318,7 @@ def get_system_status():
         model_info = generator.get_model_info()
     except Exception:
         model_info = {
-            "model_name": "Template-Based Generator",
+            "model_name": "Enhanced Template-Based Generator",
             "status": "template_mode",
             "optimization": "memory_safe"
         }
@@ -246,9 +338,11 @@ Optimization: {model_info.get("optimization", "standard")}
 
 🚀 APPLICATION INFO
 ==================
-Version: 1.0.0-spaces-optimized
+Version: 2.0.0-enhanced-input
 Environment: Hugging Face Spaces
 Backend: Gradio
+Features: Text Input + File Upload
+Supported Files: .txt, .md, .doc, .docx, .pdf
     """
     return status_info
 
@@ -279,50 +373,71 @@ Environment: {"Hugging Face Spaces" if os.environ.get('SPACE_ID') else "Local"}
 Backend: Gradio
 Threading: Enabled
 Memory Monitoring: Active
+Input Methods: Text + File Upload
+File Support: TXT, MD, DOC, DOCX, PDF
         """
         return detailed_info
     except Exception as e:
         return f"❌ Error getting model info: {str(e)}"
 
 # Create Gradio interface
-with gr.Blocks(title="AI Test Case Generator", theme=gr.themes.Soft()) as app:
+with gr.Blocks(title="AI Test Case Generator - Enhanced", theme=gr.themes.Soft()) as app:
     gr.Markdown("""
-    # 🧪 AI Test Case Generator
+    # 🧪 AI Test Case Generator - Enhanced Edition
     
     Generate comprehensive test cases from Software Requirements Specification (SRS) documents using AI models.
     
-    **Features:**
-    - 🤖 AI-powered test case generation
-    - 📝 Template-based fallback for low memory environments  
-    - 🔧 Memory-optimized processing
-    - 📊 Real-time system monitoring
+    **New Features:**
+    - 📝 **Dual Input Support**: Text prompt AND/OR document upload
+    - 📄 **File Upload**: Support for .txt, .md, .doc, .docx, .pdf files
+    - 🎯 **Enhanced Test Cases**: More detailed and comprehensive test case generation
+    - 🔧 **Improved Templates**: Better rule-based fallback with pattern matching
+    - 📊 **Better Formatting**: Enhanced output with priorities, categories, and conditions
     """)
     
     with gr.Tab("🧪 Generate Test Cases"):
+        gr.Markdown("### Choose your input method: Enter text directly, upload a document, or use both!")
+        
         with gr.Row():
             with gr.Column(scale=2):
+                # Text input
                 srs_input = gr.Textbox(
-                    label="📋 Software Requirements Specification (SRS)",
-                    placeholder="Enter your SRS document or requirements here...\n\nExample:\nThe system shall provide user authentication with username and password. Users should be able to login, logout, and reset passwords. The system should validate input and display appropriate error messages for invalid credentials.",
-                    lines=10,
-                    max_lines=20
+                    label="📝 Text Input (SRS, Requirements, or Prompt)",
+                    placeholder="Enter your requirements, user stories, or specific prompt here...\n\nExample:\n- The system shall provide user authentication with username and password\n- Users should be able to login, logout, and reset passwords\n- The system should validate input and display appropriate error messages\n- Performance requirement: Login should complete within 3 seconds",
+                    lines=8,
+                    max_lines=15
                 )
                 
+                # File upload
+                file_upload = gr.File(
+                    label="📄 Upload Document (Optional)",
+                    file_types=[".txt", ".md", ".doc", ".docx", ".pdf"],
+                    type="filepath"
+                )
+                
+                gr.Markdown("""
+                **💡 Tips:**
+                - Use **text input** for quick requirements or specific prompts
+                - Use **file upload** for complete SRS documents
+                - Use **both** to combine a specific prompt with a detailed document
+                - Supported formats: TXT, Markdown, Word (.doc/.docx), PDF
+                """)
+                
                 generate_btn = gr.Button("🚀 Generate Test Cases", variant="primary", size="lg")
             
             with gr.Column(scale=3):
                 output_display = gr.Textbox(
                     label="📋 Generated Test Cases",
-                    lines=20,
-                    max_lines=30,
+                    lines=25,
+                    max_lines=35,
                     interactive=False
                 )
         
         with gr.Row():
             json_output = gr.Textbox(
                 label="📄 JSON Output (for API use)",
-                lines=10,
-                max_lines=15,
+                lines=12,
+                max_lines=20,
                 interactive=False
             )
     
@@ -330,7 +445,7 @@ with gr.Blocks(title="AI Test Case Generator", theme=gr.themes.Soft()) as app:
         with gr.Column():
             status_display = gr.Textbox(
                 label="🏥 System Health & Status",
-                lines=15,
+                lines=18,
                 interactive=False
             )
             refresh_status_btn = gr.Button("🔄 Refresh Status", variant="secondary")
@@ -339,82 +454,100 @@ with gr.Blocks(title="AI Test Case Generator", theme=gr.themes.Soft()) as app:
         with gr.Column():
             model_info_display = gr.Textbox(
                 label="🤖 Detailed Model Information",
-                lines=20,
+                lines=22,
                 interactive=False
             )
             refresh_model_btn = gr.Button("🔄 Refresh Model Info", variant="secondary")
     
     with gr.Tab("📚 API Documentation"):
         gr.Markdown("""
-        ## 🔌 API Endpoints
+        ## 🔌 Enhanced API Endpoints
         
-        This Gradio app automatically creates API endpoints for all functions:
+        This Gradio app supports both text input and file upload through API:
         
-        ### Generate Test Cases
+        ### Generate Test Cases (Text Only)
         **Endpoint:** `/api/predict`  
         **Method:** POST  
         **Body:**
         ```json
         {
-          "data": ["Your SRS text here"]
+          "data": ["Your SRS text here", null]
         }
         ```
         
-        **Response:**
+        ### Generate Test Cases (With File)
+        **Endpoint:** `/api/predict`  
+        **Method:** POST (multipart/form-data)
+        - Upload file and include text in the data array
+        
+        **Response Format:**
         ```json
         {
           "data": [
             "Formatted test cases output",
-            "JSON output with test cases"
+            "JSON output with enhanced test cases"
           ]
         }
         ```
         
-        ### Example Usage (Python):
-        ```python
-        import requests
-        
-        response = requests.post(
-            "YOUR_SPACE_URL/api/predict",
-            json={"data": ["User login system requirements..."]}
-        )
-        result = response.json()
-        test_cases = result["data"][1]  # JSON output
-        ```
-        
-        ### Example Usage (cURL):
-        ```bash
-        curl -X POST "YOUR_SPACE_URL/api/predict" \\
-          -H "Content-Type: application/json" \\
-          -d '{"data":["Your SRS text here"]}'
-        ```
-        
-        ## 📋 Response Format
-        
-        The API returns test cases in this format:
+        ### Enhanced Test Case Structure
         ```json
         {
           "test_cases": [
             {
               "id": "TC_001",
-              "title": "Test Case Title", 
-              "description": "Test description",
-              "steps": ["Step 1", "Step 2"],
-              "expected": "Expected result"
+              "title": "Test Case Title",
+              "priority": "High/Medium/Low", 
+              "category": "Functional/Security/Performance/UI",
+              "description": "Detailed test description",
+              "preconditions": ["Pre-condition 1", "Pre-condition 2"],
+              "steps": ["Step 1", "Step 2", "Step 3"],
+              "expected": "Expected result",
+              "postconditions": ["Post-condition 1"],
+              "test_data": "Required test data"
             }
           ],
-          "count": 3,
+          "count": 5,
           "model_used": "distilgpt2",
-          "model_algorithm": "Transformer-based LM",
-          "model_reason": "Selected for balanced performance..."
+          "model_algorithm": "Enhanced Rule-based Template",
+          "model_reason": "Detailed selection reasoning...",
+          "input_source": "Combined (Prompt + Document)"
         }
         ```
+        
+        ### Example Usage (Python with File):
+        ```python
+        import requests
+        
+        # Text only
+        response = requests.post(
+            "YOUR_SPACE_URL/api/predict",
+            json={"data": ["User login requirements...", None]}
+        )
+        
+        # With file upload (requires multipart handling)
+        files = {'file': open('requirements.pdf', 'rb')}
+        data = {'data': json.dumps(["Additional prompt", "file_placeholder"])}
+        response = requests.post("YOUR_SPACE_URL/api/predict", files=files, data=data)
+        ```
+        
+        ## 📋 Supported File Formats
+        - **Text Files**: .txt, .md
+        - **Word Documents**: .doc, .docx (requires python-docx)
+        - **PDF Files**: .pdf (requires PyPDF2)
+        - **Fallback**: Any text-readable format
+        
+        ## 🎯 Enhanced Features
+        - **Dual Input**: Combine text prompts with document uploads
+        - **Better Test Cases**: Includes priorities, categories, pre/post-conditions
+        - **Smart Parsing**: Automatically detects requirement types and generates appropriate tests
+        - **Memory Optimized**: Handles large documents efficiently
         """)
     
     # Event handlers
     generate_btn.click(
         fn=gradio_generate_test_cases,
-        inputs=[srs_input],
+        inputs=[srs_input, file_upload],
         outputs=[output_display, json_output]
     )
     
@@ -443,8 +576,9 @@ with gr.Blocks(title="AI Test Case Generator", theme=gr.themes.Soft()) as app:
 if __name__ == "__main__":
     port = int(os.environ.get("PORT", 7860))
     
-    logger.info(f"🚀 Starting Gradio app on port {port}")
+    logger.info(f"🚀 Starting Enhanced Gradio app on port {port}")
     logger.info(f"🖥️ Environment: {'Hugging Face Spaces' if os.environ.get('SPACE_ID') else 'Local'}")
+    logger.info("📝 Features: Text Input + File Upload Support")
     
     app.launch(
         server_name="0.0.0.0",

model/generate.py

@@ -5,6 +5,8 @@ import logging
 import psutil
 import re
 import gc
+import random
+from typing import List, Dict, Any
 
 # Initialize logger
 logger = logging.getLogger(__name__)
@@ -21,6 +23,60 @@ MEMORY_OPTIMIZED_MODELS = [
 # Singleton state
 _generator_instance = None
 
+# Enhanced pattern matching for comprehensive test case generation
+REQUIREMENT_PATTERNS = {
+    'authentication': {
+        'keywords': ['login', 'authentication', 'signin', 'sign in', 'password', 'username', 'credential', 'auth'],
+        'priority': 'High',
+        'category': 'Security'
+    },
+    'authorization': {
+        'keywords': ['permission', 'role', 'access', 'privilege', 'authorize', 'admin', 'user level'],
+        'priority': 'High', 
+        'category': 'Security'
+    },
+    'data_validation': {
+        'keywords': ['validate', 'validation', 'input', 'format', 'check', 'verify', 'constraint'],
+        'priority': 'High',
+        'category': 'Functional'
+    },
+    'database': {
+        'keywords': ['database', 'db', 'store', 'save', 'persist', 'record', 'data storage', 'crud'],
+        'priority': 'Medium',
+        'category': 'Functional'
+    },
+    'performance': {
+        'keywords': ['performance', 'speed', 'time', 'response', 'load', 'concurrent', 'scalability'],
+        'priority': 'Medium',
+        'category': 'Performance'
+    },
+    'ui_interface': {
+        'keywords': ['interface', 'ui', 'user interface', 'display', 'screen', 'form', 'button', 'menu'],
+        'priority': 'Medium',
+        'category': 'UI/UX'
+    },
+    'api': {
+        'keywords': ['api', 'endpoint', 'service', 'request', 'response', 'rest', 'http'],
+        'priority': 'High',
+        'category': 'Integration'
+    },
+    'error_handling': {
+        'keywords': ['error', 'exception', 'failure', 'invalid', 'incorrect', 'wrong'],
+        'priority': 'High',
+        'category': 'Error Handling'
+    },
+    'reporting': {
+        'keywords': ['report', 'export', 'generate', 'analytics', 'dashboard', 'chart'],
+        'priority': 'Medium',
+        'category': 'Reporting'
+    },
+    'security': {
+        'keywords': ['security', 'encrypt', 'secure', 'ssl', 'https', 'token', 'session'],
+        'priority': 'High',
+        'category': 'Security'
+    }
+}
+
 def get_optimal_model_for_memory():
     """Select the best model based on available memory."""
     available_memory = psutil.virtual_memory().available / (1024 * 1024)  # MB
@@ -60,60 +116,405 @@ def load_model_with_memory_optimization(model_name):
         logger.error(f"❌ Failed to load model {model_name}: {e}")
         return None, None
 
-def extract_keywords(text):
-    common_keywords = [
-        'login', 'authentication', 'user', 'password', 'database', 'data',
-        'interface', 'api', 'function', 'feature', 'requirement', 'system',
-        'input', 'output', 'validation', 'error', 'security', 'performance'
+def analyze_requirements(text: str) -> Dict[str, Any]:
+    """Analyze requirements text to identify patterns and generate appropriate test cases"""
+    text_lower = text.lower()
+    detected_patterns = {}
+    
+    for pattern_name, pattern_info in REQUIREMENT_PATTERNS.items():
+        matches = []
+        for keyword in pattern_info['keywords']:
+            if keyword in text_lower:
+                # Find context around the keyword
+                pattern = rf'.{{0,50}}{re.escape(keyword)}.{{0,50}}'
+                context_matches = re.findall(pattern, text_lower, re.IGNORECASE)
+                matches.extend(context_matches)
+        
+        if matches:
+            detected_patterns[pattern_name] = {
+                'matches': matches[:3],  # Limit to 3 matches
+                'priority': pattern_info['priority'],
+                'category': pattern_info['category']
+            }
+    
+    return detected_patterns
+
+def generate_authentication_tests(matches: List[str]) -> List[Dict]:
+    """Generate comprehensive authentication test cases"""
+    base_tests = [
+        {
+            "title": "Valid User Login",
+            "description": "Verify that users can successfully log in with valid credentials",
+            "preconditions": ["User account exists", "Application is accessible"],
+            "steps": [
+                "Navigate to login page",
+                "Enter valid username",
+                "Enter valid password", 
+                "Click login button"
+            ],
+            "expected": "User is successfully authenticated and redirected to dashboard/home page",
+            "postconditions": ["User session is created", "User is logged in"],
+            "test_data": "Valid username: [email protected], Valid password: Test@123"
+        },
+        {
+            "title": "Invalid Username Login",
+            "description": "Verify that login fails with invalid username",
+            "preconditions": ["Application is accessible"],
+            "steps": [
+                "Navigate to login page",
+                "Enter invalid/non-existent username",
+                "Enter valid password format",
+                "Click login button"
+            ],
+            "expected": "Login fails with appropriate error message 'Invalid credentials'",
+            "postconditions": ["User remains on login page", "Account security maintained"],
+            "test_data": "Valid username: [email protected], Invalid password: WrongPass123"
+        },
+        {
+            "title": "Empty Fields Login Attempt",
+            "description": "Verify validation when login attempted with empty fields",
+            "preconditions": ["Application is accessible"],
+            "steps": [
+                "Navigate to login page",
+                "Leave username field empty",
+                "Leave password field empty",
+                "Click login button"
+            ],
+            "expected": "Validation errors displayed for required fields",
+            "postconditions": ["User remains on login page", "Form validation active"],
+            "test_data": "Username: (empty), Password: (empty)"
+        },
+        {
+            "title": "SQL Injection Attack Prevention",
+            "description": "Verify that login form prevents SQL injection attacks",
+            "preconditions": ["Application is accessible"],
+            "steps": [
+                "Navigate to login page",
+                "Enter SQL injection payload in username field",
+                "Enter any password",
+                "Click login button"
+            ],
+            "expected": "Login fails safely without database compromise or error exposure",
+            "postconditions": ["System security maintained", "No unauthorized access"],
+            "test_data": "Username: admin'; DROP TABLE users; --, Password: anypass"
+        }
+    ]
+    
+    return base_tests
+
+def generate_data_validation_tests(matches: List[str]) -> List[Dict]:
+    """Generate comprehensive data validation test cases"""
+    return [
+        {
+            "title": "Valid Data Input Validation",
+            "description": "Verify system accepts valid data formats correctly",
+            "preconditions": ["Form/API endpoint is accessible", "User has appropriate permissions"],
+            "steps": [
+                "Access the input form/endpoint",
+                "Enter data in valid format",
+                "Submit the form/request",
+                "Verify data is accepted"
+            ],
+            "expected": "Data is accepted and processed successfully with confirmation message",
+            "postconditions": ["Data is stored correctly", "User receives success feedback"],
+            "test_data": "Valid email: [email protected], Valid phone: +1-234-567-8900"
+        },
+        {
+            "title": "Invalid Data Format Rejection",
+            "description": "Verify system rejects invalid data formats",
+            "preconditions": ["Form/API endpoint is accessible"],
+            "steps": [
+                "Access the input form/endpoint",
+                "Enter data in invalid format",
+                "Submit the form/request",
+                "Verify validation error is shown"
+            ],
+            "expected": "System rejects invalid data with clear error message",
+            "postconditions": ["Invalid data is not stored", "User guided to correct format"],
+            "test_data": "Invalid email: notanemail, Invalid phone: 123-abc-defg"
+        },
+        {
+            "title": "Boundary Value Testing",
+            "description": "Test data validation at boundary values",
+            "preconditions": ["System has defined data length/value limits"],
+            "steps": [
+                "Test with minimum allowed value",
+                "Test with maximum allowed value", 
+                "Test with value just below minimum",
+                "Test with value just above maximum"
+            ],
+            "expected": "Min/max values accepted, out-of-range values rejected appropriately",
+            "postconditions": ["Boundary validation working correctly"],
+            "test_data": "Min: 1, Max: 100, Below: 0, Above: 101"
+        },
+        {
+            "title": "Special Characters Handling",
+            "description": "Verify proper handling of special characters in input",
+            "preconditions": ["Input fields accept text data"],
+            "steps": [
+                "Enter text with special characters (!@#$%^&*)",
+                "Enter text with unicode characters (émañ)",
+                "Enter text with HTML tags (<script>)",
+                "Submit and verify handling"
+            ],
+            "expected": "Special characters handled safely without breaking functionality",
+            "postconditions": ["Data integrity maintained", "No XSS vulnerabilities"],
+            "test_data": "Special: Test!@#$, Unicode: Café, HTML: <b>test</b>"
+        }
     ]
-    words = re.findall(r'\b\w+\b', text.lower())
-    return [word for word in words if word in common_keywords]
 
-def generate_template_based_test_cases(srs_text):
-    keywords = extract_keywords(srs_text)
-    test_cases = []
+def generate_performance_tests(matches: List[str]) -> List[Dict]:
+    """Generate comprehensive performance test cases"""
+    return [
+        {
+            "title": "Response Time Under Normal Load",
+            "description": "Verify system response time meets requirements under normal usage",
+            "preconditions": ["System is running in production-like environment", "Normal user load"],
+            "steps": [
+                "Execute typical user operations",
+                "Measure response times for key functions",
+                "Record average response times",
+                "Compare against SLA requirements"
+            ],
+            "expected": "All operations complete within specified time limits (e.g., <3 seconds)",
+            "postconditions": ["Performance baseline established"],
+            "test_data": "Target: <3 sec for page loads, <1 sec for API calls"
+        },
+        {
+            "title": "Load Testing with Multiple Users",
+            "description": "Test system performance with concurrent users",
+            "preconditions": ["Load testing tools configured", "Test environment ready"],
+            "steps": [
+                "Simulate 100 concurrent users",
+                "Execute common user workflows",
+                "Monitor system resources (CPU, memory)",
+                "Measure response times and error rates"
+            ],
+            "expected": "System maintains acceptable performance with <5% error rate",
+            "postconditions": ["Load capacity documented", "Performance bottlenecks identified"],
+            "test_data": "Concurrent users: 100, Duration: 30 minutes"
+        },
+        {
+            "title": "Memory Usage Optimization",
+            "description": "Verify system memory usage remains within acceptable limits",
+            "preconditions": ["System monitoring tools available"],
+            "steps": [
+                "Monitor memory usage during normal operations",
+                "Execute memory-intensive operations",
+                "Check for memory leaks over extended periods",
+                "Verify garbage collection effectiveness"
+            ],
+            "expected": "Memory usage stays within allocated limits, no memory leaks detected",
+            "postconditions": ["Memory optimization verified"],
+            "test_data": "Memory limit: 512MB, Test duration: 2 hours"
+        }
+    ]
 
-    if any(word in keywords for word in ['login', 'authentication', 'user', 'password']):
-        test_cases.extend([
-            {
-                "id": "TC_001",
-                "title": "Valid Login Test",
-                "description": "Test login with valid credentials",
-                "steps": ["Enter valid username", "Enter valid password", "Click login"],
-                "expected": "User should be logged in successfully"
-            },
-            {
-                "id": "TC_002",
-                "title": "Invalid Login Test",
-                "description": "Test login with invalid credentials",
-                "steps": ["Enter invalid username", "Enter invalid password", "Click login"],
-                "expected": "Error message should be displayed"
-            }
-        ])
+def generate_api_tests(matches: List[str]) -> List[Dict]:
+    """Generate comprehensive API test cases"""
+    return [
+        {
+            "title": "Valid API Request Processing",
+            "description": "Verify API correctly processes valid requests",
+            "preconditions": ["API endpoint is accessible", "Valid authentication token available"],
+            "steps": [
+                "Send GET/POST request with valid parameters",
+                "Include proper authentication headers",
+                "Verify response status code",
+                "Validate response data structure"
+            ],
+            "expected": "API returns 200 OK with expected data format",
+            "postconditions": ["Request logged", "Data processed correctly"],
+            "test_data": "Endpoint: /api/users, Method: GET, Auth: Bearer token123"
+        },
+        {
+            "title": "Invalid API Request Handling",
+            "description": "Verify API properly handles invalid requests",
+            "preconditions": ["API endpoint is accessible"],
+            "steps": [
+                "Send request with invalid parameters",
+                "Send request with missing required fields",
+                "Send malformed JSON in request body",
+                "Verify error responses"
+            ],
+            "expected": "API returns appropriate error codes (400, 422) with descriptive messages",
+            "postconditions": ["Errors logged appropriately", "System remains stable"],
+            "test_data": "Invalid param: user_id='invalid', Missing: required field 'name'"
+        },
+        {
+            "title": "API Authentication and Authorization",
+            "description": "Test API security and access controls",
+            "preconditions": ["API requires authentication"],
+            "steps": [
+                "Send request without authentication token",
+                "Send request with invalid/expired token",
+                "Send request with valid token but insufficient permissions",
+                "Verify security responses"
+            ],
+            "expected": "Unauthorized requests return 401/403 with security maintained",
+            "postconditions": ["Security audit trail created"],
+            "test_data": "Valid token: Bearer abc123, Invalid: Bearer expired456"
+        }
+    ]
 
-    if any(word in keywords for word in ['database', 'data', 'store', 'save']):
-        test_cases.append({
-            "id": "TC_003",
-            "title": "Data Storage Test",
-            "description": "Test data storage functionality",
-            "steps": ["Enter data", "Save data", "Verify storage"],
-            "expected": "Data should be stored correctly"
-        })
+def generate_error_handling_tests(matches: List[str]) -> List[Dict]:
+    """Generate comprehensive error handling test cases"""
+    return [
+        {
+            "title": "Graceful Error Message Display",
+            "description": "Verify system displays user-friendly error messages",
+            "preconditions": ["Error conditions can be triggered"],
+            "steps": [
+                "Trigger various error conditions",
+                "Verify error messages are displayed",
+                "Check that messages are user-friendly",
+                "Ensure no technical details exposed"
+            ],
+            "expected": "Clear, helpful error messages shown without exposing system internals",
+            "postconditions": ["User experience maintained during errors"],
+            "test_data": "Error scenarios: network timeout, invalid input, server error"
+        },
+        {
+            "title": "System Recovery After Errors",
+            "description": "Test system's ability to recover from error states",
+            "preconditions": ["System can be put into error state"],
+            "steps": [
+                "Trigger system error condition",
+                "Verify error is handled gracefully",
+                "Attempt normal operations after error",
+                "Verify system functionality restored"
+            ],
+            "expected": "System recovers fully and continues normal operation",
+            "postconditions": ["System stability maintained", "No data corruption"],
+            "test_data": "Recovery scenarios: database disconnect, memory overflow"
+        }
+    ]
 
-    if not test_cases:
-        test_cases = [
-            {
-                "id": "TC_001",
-                "title": "Basic Functionality Test",
-                "description": "Test basic system functionality",
-                "steps": ["Access the system", "Perform basic operations", "Verify results"],
-                "expected": "System should work as expected"
-            }
-        ]
+def generate_template_based_test_cases(srs_text: str) -> List[Dict]:
+    """Generate comprehensive template-based test cases using pattern analysis"""
+    detected_patterns = analyze_requirements(srs_text)
+    all_test_cases = []
+    
+    # Generate specific test cases based on detected patterns
+    for pattern_name, pattern_data in detected_patterns.items():
+        if pattern_name == 'authentication':
+            tests = generate_authentication_tests(pattern_data['matches'])
+        elif pattern_name == 'data_validation':
+            tests = generate_data_validation_tests(pattern_data['matches'])
+        elif pattern_name == 'performance':
+            tests = generate_performance_tests(pattern_data['matches'])
+        elif pattern_name == 'api':
+            tests = generate_api_tests(pattern_data['matches'])
+        elif pattern_name == 'error_handling':
+            tests = generate_error_handling_tests(pattern_data['matches'])
+        else:
+            # Generate generic tests for other patterns
+            tests = generate_generic_tests(pattern_name, pattern_data)
+        
+        # Add pattern-specific metadata to each test
+        for i, test in enumerate(tests):
+            test['id'] = f"TC_{pattern_name.upper()}_{i+1:03d}"
+            test['priority'] = pattern_data['priority']
+            test['category'] = pattern_data['category']
+            
+        all_test_cases.extend(tests)
+    
+    # If no specific patterns detected, generate generic functional tests
+    if not all_test_cases:
+        all_test_cases = generate_generic_functional_tests(srs_text)
+    
+    # Limit to reasonable number of test cases
+    return all_test_cases[:12]
+
+def generate_generic_tests(pattern_name: str, pattern_data: Dict) -> List[Dict]:
+    """Generate generic test cases for unspecified patterns"""
+    return [
+        {
+            "title": f"{pattern_name.replace('_', ' ').title()} - Positive Test",
+            "description": f"Verify {pattern_name.replace('_', ' ')} functionality works correctly",
+            "preconditions": ["System is accessible", "User has required permissions"],
+            "steps": [
+                f"Access {pattern_name.replace('_', ' ')} feature",
+                "Perform valid operation",
+                "Verify expected behavior"
+            ],
+            "expected": f"{pattern_name.replace('_', ' ').title()} functionality works as expected",
+            "postconditions": ["System state is valid"],
+            "test_data": "Valid test data as per requirements"
+        },
+        {
+            "title": f"{pattern_name.replace('_', ' ').title()} - Negative Test", 
+            "description": f"Verify {pattern_name.replace('_', ' ')} handles invalid scenarios",
+            "preconditions": ["System is accessible"],
+            "steps": [
+                f"Access {pattern_name.replace('_', ' ')} feature",
+                "Perform invalid operation",
+                "Verify error handling"
+            ],
+            "expected": f"Invalid {pattern_name.replace('_', ' ')} operation handled gracefully",
+            "postconditions": ["System remains stable"],
+            "test_data": "Invalid test data to trigger error conditions"
+        }
+    ]
 
-    return test_cases
+def generate_generic_functional_tests(srs_text: str) -> List[Dict]:
+    """Generate generic functional test cases when no specific patterns are detected"""
+    return [
+        {
+            "id": "TC_FUNC_001",
+            "title": "Basic System Functionality",
+            "priority": "High",
+            "category": "Functional",
+            "description": "Verify core system functionality works as specified",
+            "preconditions": ["System is deployed and accessible", "Test environment is configured"],
+            "steps": [
+                "Access the system/application",
+                "Navigate through main features",
+                "Execute primary use cases",
+                "Verify all functions work correctly"
+            ],
+            "expected": "All core functionality operates according to requirements",
+            "postconditions": ["System demonstrates full functionality"],
+            "test_data": "Standard test data set as defined in requirements"
+        },
+        {
+            "id": "TC_FUNC_002",
+            "title": "Input Validation and Processing",
+            "priority": "High", 
+            "category": "Functional",
+            "description": "Test system's ability to validate and process various inputs",
+            "preconditions": ["System accepts user input"],
+            "steps": [
+                "Enter valid data in all input fields",
+                "Submit data and verify processing",
+                "Enter invalid data and verify rejection",
+                "Test boundary conditions"
+            ],
+            "expected": "Valid data processed correctly, invalid data rejected with appropriate messages",
+            "postconditions": ["Data integrity maintained"],
+            "test_data": "Mix of valid, invalid, and boundary test data"
+        },
+        {
+            "id": "TC_FUNC_003",
+            "title": "System Integration and Workflow",
+            "priority": "Medium",
+            "category": "Integration", 
+            "description": "Verify end-to-end workflow and system integration",
+            "preconditions": ["All system components are integrated"],
+            "steps": [
+                "Execute complete business workflow",
+                "Verify data flow between components",
+                "Test system integration points",
+                "Validate end-to-end functionality"
+            ],
+            "expected": "Complete workflow executes successfully with proper data flow",
+            "postconditions": ["Workflow completion confirmed"],
+            "test_data": "Complete dataset for end-to-end testing"
+        }
+    ]
 
-def parse_generated_test_cases(generated_text):
+def parse_generated_test_cases(generated_text: str) -> List[Dict]:
+    """Parse AI-generated text into structured test cases"""
     lines = generated_text.split('\n')
     test_cases = []
     current_case = {}
@@ -125,11 +526,16 @@ def parse_generated_test_cases(generated_text):
             if current_case:
                 test_cases.append(current_case)
             current_case = {
-                "id": f"TC_{case_counter:03d}",
+                "id": f"TC_AI_{case_counter:03d}",
                 "title": line,
+                "priority": "Medium",
+                "category": "Functional",
                 "description": line,
-                "steps": ["Execute the test"],
-                "expected": "Test should pass"
+                "preconditions": ["System is accessible"],
+                "steps": ["Execute the test procedure"],
+                "expected": "Test should pass according to requirements",
+                "postconditions": ["System state verified"],
+                "test_data": "As specified in requirements"
             }
             case_counter += 1
 
@@ -138,21 +544,27 @@ def parse_generated_test_cases(generated_text):
 
     if not test_cases:
         return [{
-            "id": "TC_001",
-            "title": "Generated Test Case",
-            "description": "Auto-generated test case based on requirements",
-            "steps": ["Review requirements", "Execute test", "Verify results"],
-            "expected": "Requirements should be met"
+            "id": "TC_AI_001",
+            "title": "AI Generated Test Case",
+            "priority": "Medium",
+            "category": "Functional", 
+            "description": "Auto-generated test case based on AI analysis",
+            "preconditions": ["System meets specified requirements"],
+            "steps": ["Review requirements", "Execute test procedure", "Verify results"],
+            "expected": "Requirements should be met as specified",
+            "postconditions": ["Test completion verified"],
+            "test_data": "Test data as defined in requirements"
         }]
 
     return test_cases
 
-def generate_with_ai_model(srs_text, tokenizer, model):
-    max_input_length = 200
+def generate_with_ai_model(srs_text: str, tokenizer, model) -> List[Dict]:
+    """Generate test cases using AI model"""
+    max_input_length = 300
     if len(srs_text) > max_input_length:
         srs_text = srs_text[:max_input_length]
 
-    prompt = f"""Generate test cases for this software requirement:
+    prompt = f"""Generate comprehensive test cases for this software requirement:
 {srs_text}
 
 Test Cases:
@@ -162,14 +574,14 @@ Test Cases:
         inputs = tokenizer.encode(
             prompt,
             return_tensors="pt",
-            max_length=150,
+            max_length=200,
             truncation=True
         )
 
         with torch.no_grad():
             outputs = model.generate(
                 inputs,
-                max_new_tokens=100,
+                max_new_tokens=150,
                 num_return_sequences=1,
                 temperature=0.7,
                 do_sample=True,
@@ -186,7 +598,8 @@ Test Cases:
         logger.error(f"❌ AI generation failed: {e}")
         raise
 
-def generate_with_fallback(srs_text):
+def generate_with_fallback(srs_text: str):
+    """Generate test cases with AI model fallback to enhanced templates"""
     model_name = get_optimal_model_for_memory()
 
     if model_name:
@@ -197,17 +610,19 @@ def generate_with_fallback(srs_text):
                 reason = get_algorithm_reason(model_name)
                 return test_cases, model_name, "transformer (causal LM)", reason
             except Exception as e:
-                logger.warning(f"AI generation failed: {e}, falling back to templates")
+                logger.warning(f"AI generation failed: {e}, falling back to enhanced templates")
 
-    logger.info("⚠️ Using fallback template-based generation")
+    logger.info("⚠️ Using enhanced template-based generation")
     test_cases = generate_template_based_test_cases(srs_text)
-    return test_cases, "Template-Based Generator", "rule-based", "Low memory - fallback to rule-based generation"
+    return test_cases, "Enhanced Template-Based Generator", "pattern-matching + rule-based", "Enhanced template generation with comprehensive pattern analysis and structured test case creation"
 
 # ✅ Function exposed to app.py
-def generate_test_cases(srs_text):
+def generate_test_cases(srs_text: str) -> List[Dict]:
+    """Main function to generate test cases"""
     return generate_with_fallback(srs_text)[0]
 
 def get_generator():
+    """Get generator instance"""
     global _generator_instance
     if _generator_instance is None:
         class Generator:
@@ -221,10 +636,10 @@ def get_generator():
             def get_model_info(self):
                 mem = psutil.Process().memory_info().rss / 1024 / 1024
                 return {
-                    "model_name": self.model_name if self.model_name else "Template-Based Generator",
-                    "status": "loaded" if self.model else "template_mode",
+                    "model_name": self.model_name if self.model_name else "Enhanced Template-Based Generator",
+                    "status": "loaded" if self.model else "enhanced_template_mode",
                     "memory_usage": f"{mem:.1f}MB",
-                    "optimization": "low_memory"
+                    "optimization": "low_memory_enhanced"
                 }
 
         _generator_instance = Generator()
@@ -232,14 +647,15 @@ def get_generator():
     return _generator_instance
 
 def monitor_memory():
+    """Monitor and manage memory usage"""
     mem = psutil.Process().memory_info().rss / 1024 / 1024
     logger.info(f"Memory usage: {mem:.1f}MB")
     if mem > 450:
         gc.collect()
         logger.info("Memory cleanup triggered")
 
-# ✅ NEW FUNCTION for enhanced output: test cases + model info + reason
-def generate_test_cases_and_info(input_text):
+def generate_test_cases_and_info(input_text: str) -> Dict[str, Any]:
+    """Generate test cases with full information"""
     test_cases, model_name, algorithm_used, reason = generate_with_fallback(input_text)
     return {
         "model": model_name,
@@ -248,15 +664,29 @@ def generate_test_cases_and_info(input_text):
         "test_cases": test_cases
     }
 
-# ✅ Explain why each algorithm is selected
-def get_algorithm_reason(model_name):
+def get_algorithm_reason(model_name: str) -> str:
+    """Get explanation for algorithm selection"""
     if model_name == "microsoft/DialoGPT-small":
-        return "Selected due to low memory availability; DialoGPT-small provides conversational understanding in limited memory environments."
+        return "Selected due to low memory availability; DialoGPT-small provides conversational understanding in limited memory environments with enhanced context processing."
     elif model_name == "distilgpt2":
-        return "Selected for its balance between performance and low memory usage. Ideal for small environments needing causal language modeling."
+        return "Selected for its balance between performance and low memory usage. Ideal for small environments needing causal language modeling with good text generation quality."
     elif model_name == "gpt2":
-        return "Chosen for general-purpose text generation with moderate memory headroom."
+        return "Chosen for general-purpose text generation with moderate memory headroom and superior language understanding capabilities."
     elif model_name is None:
-        return "No model used due to insufficient memory. Rule-based template generation chosen instead."
+        return "Enhanced template-based generation selected due to memory constraints. Uses comprehensive pattern matching, requirement analysis, and structured test case templates for robust test coverage."
     else:
-        return "Model selected based on best tradeoff between memory usage and language generation capability."
+        return "Model selected based on optimal tradeoff between memory usage, language generation capability, and test case quality requirements." fails with appropriate error message 'Invalid credentials'",
+            "postconditions": ["User remains on login page", "No session created"],
+            "test_data": "Invalid username: [email protected], Password: Test@123"
+        },
+        {
+            "title": "Invalid Password Login",
+            "description": "Verify that login fails with incorrect password",
+            "preconditions": ["Valid user account exists"],
+            "steps": [
+                "Navigate to login page", 
+                "Enter valid username",
+                "Enter incorrect password",
+                "Click login button"
+            ],
+            "expected": "Login