fixed integration test on clasic esp32

Author: pavelrevak

mpytool/mpy.py

@@ -534,21 +534,23 @@ def detect_chunk_size(self):
             free = self._mpy_comm.exec_eval("gc.mem_free()")
         except _mpy_comm.CmdError:
             free = 0
-        # Select chunk size based on free RAM (~10-15% of free RAM)
-        if free > 256 * 1024:
+        # Select chunk size based on free RAM
+        if free > 320 * 1024:
             chunk = 32768
-        elif free > 128 * 1024:
+        elif free > 192 * 1024:
             chunk = 16384
-        elif free > 64 * 1024:
+        elif free > 128 * 1024:
             chunk = 8192
-        elif free > 48 * 1024:
+        elif free > 92 * 1024:
             chunk = 4096
-        elif free > 32 * 1024:
+        elif free > 64 * 1024:
             chunk = 2048
-        elif free > 24 * 1024:
+        elif free > 48 * 1024:
             chunk = 1024
-        else:
+        elif free > 32 * 1024:
             chunk = 512
+        else:
+            chunk = 256
         Mpy._CHUNK_AUTO_DETECTED = chunk
         return chunk
 
@@ -1146,15 +1148,19 @@ def flash_read(self, label=None, progress_callback=None):
             total_size = block_count * block_size
 
         total_blocks = (total_size + block_size - 1) // block_size
-        chunk_blocks = 8  # 32KB per iteration
+        # Use detect_chunk_size() which auto-detects based on free RAM
+        chunk_bytes = self.detect_chunk_size()
+        chunk_blocks = max(1, chunk_bytes // block_size)
         data = bytearray()
         block_num = 0
 
         while block_num < total_blocks:
             blocks_to_read = min(chunk_blocks, total_blocks - block_num)
             bytes_to_read = blocks_to_read * block_size
+            # gc.collect() before each chunk to avoid fragmentation on low-RAM devices
             self._mpy_comm.exec(
-                f"_buf=bytearray({bytes_to_read}); _dev.readblocks({block_num}, _buf)")
+                f"gc.collect(); _buf=bytearray({bytes_to_read}); "
+                f"_dev.readblocks({block_num}, _buf)")
             b64_data = self._mpy_comm.exec_eval("repr(ub.b2a_base64(_buf).decode())")
             chunk = base64.b64decode(b64_data)
             data.extend(chunk)

tests/test_integration.py

@@ -1342,11 +1342,29 @@ def test_02_partition_read_nvs(self):
                 break
         if not nvs:
             self.skipTest("No nvs partition found")
-        # Read nvs partition
+        # Read nvs partition (flash_read uses dynamic chunk size based on RAM)
         data = self.mpy.flash_read(label='nvs')
         self.assertIsInstance(data, bytes)
         self.assertEqual(len(data), nvs['size'])
 
+    def test_03_partition_read_phy_init(self):
+        """Test reading phy_init partition (4KB, works on low-RAM devices)"""
+        if not self.is_esp32:
+            self.skipTest("Not an ESP32 device")
+        # Find phy_init partition
+        info = self.mpy.partitions()
+        phy = None
+        for p in info['partitions']:
+            if p['label'] == 'phy_init':
+                phy = p
+                break
+        if not phy:
+            self.skipTest("No phy_init partition found")
+        # Read phy_init partition (small enough for low-RAM devices)
+        data = self.mpy.flash_read(label='phy_init')
+        self.assertIsInstance(data, bytes)
+        self.assertEqual(len(data), phy['size'])
+
 
 @requires_device
 class TestFlashRP2(unittest.TestCase):

tests/test_mpy.py

@@ -140,57 +140,57 @@ def tearDown(self):
         Mpy._CHUNK_AUTO_DETECTED = None
 
     def test_large_ram_uses_32k_chunks(self):
-        """Test that devices with >256KB RAM use 32KB chunks"""
-        self.mpy._mpy_comm.exec_eval.return_value = 300 * 1024  # 300KB
+        """Test that devices with >320KB RAM use 32KB chunks"""
+        self.mpy._mpy_comm.exec_eval.return_value = 350 * 1024  # 350KB
         chunk = self.mpy.detect_chunk_size()
         self.assertEqual(chunk, 32768)
 
     def test_medium_large_ram_uses_16k_chunks(self):
-        """Test that devices with >128KB RAM use 16KB chunks"""
-        self.mpy._mpy_comm.exec_eval.return_value = 150 * 1024  # 150KB
+        """Test that devices with >192KB RAM use 16KB chunks"""
+        self.mpy._mpy_comm.exec_eval.return_value = 250 * 1024  # 250KB
         chunk = self.mpy.detect_chunk_size()
         self.assertEqual(chunk, 16384)
 
     def test_medium_ram_uses_8k_chunks(self):
-        """Test that devices with >64KB RAM use 8KB chunks"""
-        self.mpy._mpy_comm.exec_eval.return_value = 80 * 1024  # 80KB
+        """Test that devices with >128KB RAM use 8KB chunks"""
+        self.mpy._mpy_comm.exec_eval.return_value = 150 * 1024  # 150KB
         chunk = self.mpy.detect_chunk_size()
         self.assertEqual(chunk, 8192)
 
     def test_small_ram_uses_4k_chunks(self):
-        """Test that devices with >48KB RAM use 4KB chunks"""
-        self.mpy._mpy_comm.exec_eval.return_value = 55 * 1024  # 55KB
+        """Test that devices with >92KB RAM use 4KB chunks"""
+        self.mpy._mpy_comm.exec_eval.return_value = 100 * 1024  # 100KB
         chunk = self.mpy.detect_chunk_size()
         self.assertEqual(chunk, 4096)
 
     def test_smaller_ram_uses_2k_chunks(self):
-        """Test that devices with >32KB RAM use 2KB chunks"""
-        self.mpy._mpy_comm.exec_eval.return_value = 40 * 1024  # 40KB
+        """Test that devices with >64KB RAM use 2KB chunks"""
+        self.mpy._mpy_comm.exec_eval.return_value = 70 * 1024  # 70KB
         chunk = self.mpy.detect_chunk_size()
         self.assertEqual(chunk, 2048)
 
     def test_small_ram_uses_1k_chunks(self):
-        """Test that devices with >24KB RAM use 1KB chunks"""
-        self.mpy._mpy_comm.exec_eval.return_value = 28 * 1024  # 28KB
+        """Test that devices with >48KB RAM use 1KB chunks"""
+        self.mpy._mpy_comm.exec_eval.return_value = 55 * 1024  # 55KB
         chunk = self.mpy.detect_chunk_size()
         self.assertEqual(chunk, 1024)
 
     def test_tiny_ram_uses_512_chunks(self):
-        """Test that devices with <=24KB RAM use 512B chunks"""
-        self.mpy._mpy_comm.exec_eval.return_value = 20 * 1024  # 20KB
+        """Test that devices with >32KB RAM use 512B chunks"""
+        self.mpy._mpy_comm.exec_eval.return_value = 40 * 1024  # 40KB
         chunk = self.mpy.detect_chunk_size()
         self.assertEqual(chunk, 512)
 
-    def test_error_defaults_to_512(self):
-        """Test that errors default to 512B chunks"""
+    def test_error_defaults_to_256(self):
+        """Test that errors default to 256B chunks"""
         from mpytool.mpy_comm import CmdError
         self.mpy._mpy_comm.exec_eval.side_effect = CmdError("cmd", b"", b"error")
         chunk = self.mpy.detect_chunk_size()
-        self.assertEqual(chunk, 512)
+        self.assertEqual(chunk, 256)
 
     def test_caches_result(self):
         """Test that chunk size is cached after first detection"""
-        self.mpy._mpy_comm.exec_eval.return_value = 300 * 1024  # 300KB
+        self.mpy._mpy_comm.exec_eval.return_value = 350 * 1024  # 350KB
         chunk1 = self.mpy.detect_chunk_size()
         # Change return value - should still use cached
         self.mpy._mpy_comm.exec_eval.return_value = 20 * 1024  # 20KB
@@ -340,6 +340,7 @@ def setUp(self):
         self.mpy = Mpy(self.mock_conn)
         self.mpy._mpy_comm = Mock()
         self.mpy._platform = 'esp32'  # Set platform for partition operations
+        self.mpy._chunk_size = 4096  # Skip chunk size detection
 
     def test_flash_read_with_label_returns_bytes(self):
         """Test that flash_read with label returns bytes"""