sd card works now (in simulator)

Author: k9ert

src/stresstest/components/sdcard_test.py

@@ -1,36 +1,44 @@
 # SD Card Stress Test Component
 
-import time
 import os
 import platform
-from ..utils import StressTestError, get_timestamp, format_bytes, safe_file_operation
+from ..utils import StressTestError, get_timestamp, safe_file_operation
 
 
 class SDCardTester:
     """SD Card testing component"""
 
     def __init__(self, test_path="/sd/stresstest"):
-        self.test_path = test_path
+        # Convert path to proper simulator path if needed
+        self.test_path = platform.fpath(test_path)
         self.initial_data = None
 
     async def initialize(self):
         """Initialize SD card testing"""
         try:
-            print("Testing SD card...")
-            
-            # Check if SD card is available
-            if not platform.file_exists("/sd"):
-                raise StressTestError("SD card not mounted")
-            
+            # Check if SD card is present
+            if not platform.sdcard.is_present:
+                raise StressTestError("SD card not present")
+
+            # Check if SD card directory exists and is accessible
+            sd_path = platform.fpath("/sd")
+            try:
+                # Try to list the directory to see if it exists and is accessible
+                list(os.ilistdir(sd_path))
+            except OSError as e:
+                try:
+                    platform.maybe_mkdir(sd_path)
+                except Exception as create_error:
+                    raise StressTestError("SD card directory not accessible and cannot create: " + str(create_error))
+
             # Create test directory
             platform.maybe_mkdir(self.test_path)
-            
+
             # Test basic file operations
             sdcard_data = await self._test_sdcard_operations()
             self.initial_data = sdcard_data
-            print("SD card test completed:", repr(sdcard_data))
             return True
-            
+
         except Exception as e:
             print("WARNING: SD card not available:", str(e))
             self.initial_data = None
@@ -39,48 +47,30 @@ async def initialize(self):
     async def _test_sdcard_operations(self):
         """Test basic SD card operations"""
         try:
-            print("SD card test: Starting...")
-            
             # Test file creation
             test_file = self.test_path + "/test_" + get_timestamp() + ".txt"
             test_data = "SD card test data: " + get_timestamp()
-            
-            print("SD card test: Writing file...")
+
+            # Write test file
             result = safe_file_operation(self._write_test_file, test_file, test_data)
             if result is None:
                 raise StressTestError("Failed to write test file")
-            
-            print("SD card test: Reading file...")
+
+            # Read test file
             read_data = safe_file_operation(self._read_test_file, test_file)
             if read_data is None:
                 raise StressTestError("Failed to read test file")
-            
+
+            # Compare data
             if read_data != test_data:
                 raise StressTestError("Data mismatch: written != read")
-            
-            print("SD card test: Checking file stats...")
-            file_size = safe_file_operation(self._get_file_size, test_file)
-            
-            print("SD card test: Cleaning up...")
+
+            # Clean up
             safe_file_operation(self._delete_test_file, test_file)
-            
-            # Get SD card info
-            sdcard_info = self._get_sdcard_info()
-            
-            result = {
-                "test_file": test_file,
-                "data_length": len(test_data),
-                "file_size": file_size,
-                "sdcard_info": sdcard_info,
-                "timestamp": get_timestamp(),
-                "status": "success"
-            }
-            
-            print("SD card test: Success")
-            return result
-            
+
+            return test_data
+
         except Exception as e:
-            print("SD card test: Exception occurred:", str(e))
             raise StressTestError("SD card test failed: " + str(e))
 
     def _write_test_file(self, filename, data):
@@ -93,14 +83,32 @@ def _read_test_file(self, filename):
         """Read test data from file"""
         with open(filename, 'r') as f:
             return f.read()
-    
-    def _get_file_size(self, filename):
-        """Get file size"""
+
+    async def _read_sdcard(self):
+        """Read SD card data for continuous stress testing"""
         try:
-            stat = os.stat(filename)
-            return stat[6]  # Size is at index 6 in MicroPython
-        except:
-            return None
+            # Create a quick test file and read it back
+            test_file = self.test_path + "/stress_test_" + get_timestamp() + ".txt"
+            test_data = self.initial_data  # Use the initial data for comparison
+
+            # Write and read back the data
+            result = safe_file_operation(self._write_test_file, test_file, test_data)
+            if result is None:
+                raise StressTestError("Failed to write stress test file")
+
+            read_data = safe_file_operation(self._read_test_file, test_file)
+            if read_data is None:
+                raise StressTestError("Failed to read stress test file")
+
+            # Clean up
+            safe_file_operation(self._delete_test_file, test_file)
+
+            return read_data
+
+        except Exception as e:
+            raise StressTestError("SD card stress read failed: " + str(e))
+    
+
 
     def _delete_test_file(self, filename):
         """Delete test file"""
@@ -110,96 +118,42 @@ def _delete_test_file(self, filename):
         except:
             return False
 
-    def _get_sdcard_info(self):
-        """Get SD card information"""
-        try:
-            # Get filesystem stats
-            if hasattr(os, 'statvfs'):
-                stats = os.statvfs('/sd')
-                block_size = stats[0]
-                total_blocks = stats[2]
-                free_blocks = stats[3]
-                
-                total_space = block_size * total_blocks
-                free_space = block_size * free_blocks
-                used_space = total_space - free_space
-                
-                return {
-                    "total_space": total_space,
-                    "free_space": free_space,
-                    "used_space": used_space,
-                    "total_formatted": format_bytes(total_space),
-                    "free_formatted": format_bytes(free_space),
-                    "used_formatted": format_bytes(used_space)
-                }
-            else:
-                return {"status": "statvfs not available"}
-        except Exception as e:
-            return {"error": str(e)}
+
 
     async def test_sdcard_performance(self, iterations=5, data_size=1024):
         """Test SD card performance with multiple operations"""
         if not self.is_available():
             return {"status": "skipped", "reason": "SD card not available"}
-        
-        results = []
+
         successful_operations = 0
-        
+
         for i in range(iterations):
             try:
-                print("SD card test iteration", i + 1, "of", iterations)
-                start_time = time.time()
-                
                 # Create test data
                 test_data = "x" * data_size
                 test_file = self.test_path + "/perf_test_" + str(i) + "_" + get_timestamp() + ".txt"
-                
+
                 # Write test
-                write_start = time.time()
                 safe_file_operation(self._write_test_file, test_file, test_data)
-                write_time = time.time() - write_start
-                
+
                 # Read test
-                read_start = time.time()
                 read_data = safe_file_operation(self._read_test_file, test_file)
-                read_time = time.time() - read_start
-                
+
                 # Cleanup
                 safe_file_operation(self._delete_test_file, test_file)
-                
-                end_time = time.time()
-                total_duration = end_time - start_time
-                
+
                 # Verify data integrity
-                data_ok = (read_data == test_data) if read_data else False
-                
-                results.append({
-                    "iteration": i + 1,
-                    "status": "success" if data_ok else "data_error",
-                    "data_size": data_size,
-                    "write_time": write_time,
-                    "read_time": read_time,
-                    "total_duration": total_duration,
-                    "data_integrity": data_ok
-                })
-                
-                if data_ok:
+                if read_data == test_data:
                     successful_operations += 1
-                
-            except Exception as e:
-                results.append({
-                    "iteration": i + 1,
-                    "status": "failed",
-                    "error": str(e)
-                })
-        
+
+            except Exception:
+                pass  # Count as failed iteration
+
         return {
             "status": "completed",
             "total_iterations": iterations,
             "successful_operations": successful_operations,
-            "success_rate": (successful_operations / iterations) * 100,
-            "data_size": data_size,
-            "results": results
+            "success_rate": (successful_operations / iterations) * 100
         }
 
     def is_available(self):
@@ -216,6 +170,5 @@ def cleanup(self):
         """Clean up test files and directories"""
         try:
             platform.delete_recursively(self.test_path)
-            print("SD card test cleanup completed")
-        except Exception as e:
-            print("SD card cleanup failed:", str(e))
+        except Exception:
+            pass

src/stresstest/core.py

@@ -250,16 +250,28 @@ async def _test_component_continuously(self, component_name, tester):
                     print("Storage read error:", str(e))
 
             elif component_name == 'sdcard':
-                if self.initial_values.get('sdcard') is None:
+                print("DEBUG: Testing SD card component")
+                # Check if SD card was successfully initialized
+                if not self.initial_values.get('sd_card'):
+                    print("DEBUG: SD card not initialized, skipping")
                     return
 
+                # Use the actual initial data from the tester
+                initial_value = tester.initial_data
+                if initial_value is None:
+                    print("DEBUG: SD card initial data is None, skipping")
+                    return
+
+                print("DEBUG: SD card initial data:", repr(initial_value))
                 try:
                     current_data = await tester._read_sdcard()
                     self.statistics['sdcard_reads'] += 1
+                    print("DEBUG: SD card read successful, count now:", self.statistics['sdcard_reads'])
 
                     # Compare with initial value (like original stress test)
-                    if current_data != self.initial_values.get('sdcard'):
+                    if current_data != initial_value:
                         self.statistics['mismatches'] += 1
+                        print("DEBUG: SD card data mismatch - expected:", repr(initial_value), "got:", repr(current_data))
 
                 except Exception as e:
                     self.statistics['sdcard_errors'] += 1