Cursor rule

1---
2description: Debugging, logging, and testing patterns
3globs: ["**/*.cs"]
4alwaysApply: false
5---
6 
7# Debugging and Testing Patterns
8 
9## Logging
10 
11### LogManager Usage
12Use LogManager for structured logging:
13 
14```csharp
15using UGTLive;
16 
17// Info log
18LogManager.Instance.LogInfo("Processing started");
19 
20// Error log
21LogManager.Instance.LogError("Failed to process", exception);
22 
23// Debug log
24LogManager.Instance.LogDebug("Debug information");
25```
26 
27### Console Output
28Use Console.WriteLine for debug output:
29 
30```csharp
31Console.WriteLine($"Processing {count} items");
32Console.WriteLine($"Config value: {key} = {value}");
33```
34 
35### Masking Sensitive Data
36Never log API keys or sensitive information:
37 
38```csharp
39// BAD
40Console.WriteLine($"API Key: {apiKey}");
41 
42// GOOD
43Console.WriteLine($"API Key: {(string.IsNullOrEmpty(apiKey) ? "not set" : "***")}");
44```
45 
46## Error File Writing
47 
48### Service Error Files
49Some services write error details to files for debugging:
50 
51```csharp
52try
53{
54    // API call
55}
56catch (Exception ex)
57{
58    string errorFile = "gemini_last_error.txt";
59    File.WriteAllText(errorFile, 
60        $"Error: {ex.Message}\n\nStack trace: {ex.StackTrace}");
61    
62    Console.WriteLine($"Error written to {errorFile}");
63}
64```
65 
66## Debug Configuration Files
67 
68### Debug Output Files
69The app writes debug files for troubleshooting:
70 
71- `last_llm_request_sent.txt` - Last LLM request
72- `last_llm_reply_received.txt` - Last LLM response
73- `last_ocr_response.json` - Last OCR result
74- `gemini_last_error.txt` - Last Gemini error
75- `openai_audio_log.txt` - OpenAI audio debug log
76 
77### Writing Debug Files
78```csharp
79public void WriteDebugFile(string filename, string content)
80{
81    try
82    {
83        string debugPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, filename);
84        File.WriteAllText(debugPath, content);
85        Console.WriteLine($"Debug file written: {debugPath}");
86    }
87    catch (Exception ex)
88    {
89        Console.WriteLine($"Failed to write debug file: {ex.Message}");
90    }
91}
92```
93 
94## Exception Handling
95 
96### Unhandled Exception Handler
97App.xaml.cs handles unhandled exceptions:
98 
99```csharp
100private void App_DispatcherUnhandledException(object sender, 
101    DispatcherUnhandledExceptionEventArgs e)
102{
103    Console.WriteLine($"Unhandled exception: {e.Exception.Message}");
104    Console.WriteLine($"Stack trace: {e.Exception.StackTrace}");
105    
106    // Mark as handled to prevent crash
107    e.Handled = true;
108}
109```
110 
111### Service Exception Handling
112Services should catch and log exceptions:
113 
114```csharp
115public async Task<Result?> ProcessAsync()
116{
117    try
118    {
119        return await DoWorkAsync();
120    }
121    catch (HttpRequestException ex)
122    {
123        Console.WriteLine($"HTTP error: {ex.Message}");
124        LogManager.Instance.LogError("HTTP request failed", ex);
125        return null;
126    }
127    catch (Exception ex)
128    {
129        Console.WriteLine($"Unexpected error: {ex.Message}");
130        LogManager.Instance.LogError("Unexpected error", ex);
131        return null;
132    }
133}
134```
135 
136## Debug Builds
137 
138### Debug vs Release
139Debug builds use different assembly names:
140 
141```xml
142<PropertyGroup Condition="'$(Configuration)'=='Debug'">
143    <AssemblyName>ugtlive_debug</AssemblyName>
144</PropertyGroup>
145```
146 
147### Conditional Compilation
148```csharp
149#if DEBUG
150    Console.WriteLine("Debug mode - extra logging enabled");
151#endif
152```
153 
154## Testing Translation Services
155 
156### Manual Testing Pattern
1571. Set API key in settings
1582. Select service and model
1593. Use Monitor window to capture text
1604. Check ChatBox for results
1615. Review logs for errors
162 
163### Service Connection Test
164```csharp
165public async Task<bool> TestConnectionAsync()
166{
167    try
168    {
169        var result = await TranslateAsync("test", "en", "");
170        return result != null;
171    }
172    catch (Exception ex)
173    {
174        Console.WriteLine($"Connection test failed: {ex.Message}");
175        return false;
176    }
177}
178```
179 
180## OCR Testing
181 
182### Testing OCR Output
183```csharp
184// Write OCR results to file for inspection
185var ocrResults = await ProcessOCRAsync(bitmap);
186var json = JsonSerializer.Serialize(ocrResults, new JsonSerializerOptions 
187{ 
188    WriteIndented = true 
189});
190File.WriteAllText("last_ocr_response.json", json);
191```
192 
193### Visual OCR Feedback
194Monitor window shows OCR results visually:
195 
196```csharp
197private void DrawOCRResults(Graphics g, List<TextObject> textObjects)
198{
199    foreach (var textObj in textObjects)
200    {
201        // Draw bounding box
202        g.DrawRectangle(Pens.Red, textObj.BoundingBox);
203        
204        // Draw text
205        g.DrawString(textObj.Text, font, Brushes.White, textObj.BoundingBox);
206    }
207}
208```
209 
210## Performance Debugging
211 
212### Timing Operations
213```csharp
214var stopwatch = System.Diagnostics.Stopwatch.StartNew();
215await ProcessAsync();
216stopwatch.Stop();
217Console.WriteLine($"Processing took {stopwatch.ElapsedMilliseconds}ms");
218```
219 
220### Memory Usage
221```csharp
222using System.Diagnostics;
223 
224var process = Process.GetCurrentProcess();
225Console.WriteLine($"Memory usage: {process.WorkingSet64 / 1024 / 1024} MB");
226```
227 
228## Network Debugging
229 
230### HTTP Request Logging
231```csharp
232// Log request details
233Console.WriteLine($"Request URL: {url}");
234Console.WriteLine($"Request Method: POST");
235Console.WriteLine($"Request Body: {requestBody}");
236 
237var response = await httpClient.PostAsync(url, content);
238 
239Console.WriteLine($"Response Status: {response.StatusCode}");
240var responseBody = await response.Content.ReadAsStringAsync();
241Console.WriteLine($"Response Body: {responseBody}");
242```
243 
244### WebSocket Debugging
245```csharp
246private void LogWebSocketMessage(string direction, string message)
247{
248    Console.WriteLine($"[WebSocket {direction}] {message}");
249    
250    // Write to log file
251    File.AppendAllText("websocket_log.txt", 
252        $"[{DateTime.Now}] {direction}: {message}\n");
253}
254```
255 
256## Configuration Debugging
257 
258### Dump Configuration
259```csharp
260public void DumpConfig()
261{
262    Console.WriteLine("=== Configuration Dump ===");
263    foreach (var kvp in _configValues)
264    {
265        string value = kvp.Key.Contains("api_key") ? "***" : kvp.Value;
266        Console.WriteLine($"{kvp.Key} = {value}");
267    }
268    Console.WriteLine("=========================");
269}
270```
271 
272## Breakpoint Strategy
273 
274### Strategic Breakpoints
275- Entry points of service methods
276- Error handling blocks
277- Configuration loading/saving
278- UI event handlers
279- Async method completions
280 
281### Conditional Breakpoints
282```csharp
283// Set breakpoint with condition: text.Length > 100
284if (text.Length > 100)
285{
286    // Breakpoint here
287}
288```
289 
290## Unit Testing Considerations
291 
292### Testable Code Structure
293- Separate business logic from UI
294- Use dependency injection where possible
295- Make methods static when they don't need instance state
296- Extract complex logic into testable methods
297 
298### Example Testable Method
299```csharp
300// Testable static method
301public static string ProcessText(string input)
302{
303    if (string.IsNullOrWhiteSpace(input))
304    {
305        return "";
306    }
307    
308    return input.Trim().ToLower();
309}
310```
311 
312## Integration Testing
313 
314### Testing Service Integration
315```csharp
316// Test translation service
317var service = TranslationServiceFactory.CreateService("Gemini");
318var result = await service.TranslateAsync("test", "en", "");
319Assert.IsNotNull(result);
320```
321 
322### Testing OCR Integration
323```csharp
324// Test OCR processing
325var bitmap = LoadTestImage();
326var results = await ocrManager.ProcessImageAsync(bitmap);
327Assert.IsTrue(results.Count > 0);
328```
329 
330## Common Debugging Scenarios
331 
332### Translation Not Working
3331. Check API key is set
3342. Verify service is running (for Ollama)
3353. Check network connection
3364. Review error logs
3375. Test with simple text
338 
339### OCR Not Detecting Text
3401. Verify capture region is correct
3412. Check OCR method is set correctly
3423. Verify Python server is running (for EasyOCR)
3434. Check language settings
3445. Review OCR confidence thresholds
345 
346### UI Not Updating
3471. Verify Dispatcher.Invoke is used
3482. Check if window is visible
3493. Verify data binding is correct
3504. Check for exceptions in logs
351