test: add runtime and memory stress coverage

.github/workflows/ci.yml

@@ -43,6 +43,9 @@ jobs:
       - name: Run performance regression checks
         run: make performance-check
 
+      - name: Run runtime stress checks
+        run: make stress-check
+
       - name: Build debug APK
         run: make assemble
 

CHANGELOG.md

@@ -9,6 +9,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 ### Added
 
 - Real-engine performance regression tests covering QuickJS runtime reuse and tolerant cold-start, sentence and paragraph timing budgets.
+- Runtime stress coverage for prolonged Grammalecte analysis, concurrent engine calls, repeated QuickJS lifecycle cycles and retained QuickJS memory growth.
 - Initial modular Android project foundation.
 - Pure Kotlin `GrammarEngine` abstraction for correction results.
 - Native Android `SpellCheckerService` integration.

Makefile

@@ -1,6 +1,6 @@
 GRADLE := ./gradlew
 
-.PHONY: bootstrap vendor check performance-check test lint assemble instrumented refresh-verification-metadata clean
+.PHONY: bootstrap vendor check performance-check stress-check test lint assemble instrumented refresh-verification-metadata clean
 
 bootstrap:
 	./tools/bootstrap-gradle-wrapper.sh
@@ -22,6 +22,13 @@ performance-check:
 		-PgrammalectePerf=1 \
 		--rerun-tasks
 
+stress-check:
+	$(GRADLE) --no-daemon \
+		:engine-grammalecte:testDebugUnitTest \
+		--tests '*EngineRuntimeStressTest*' \
+		-PgrammalecteStress=1 \
+		--rerun-tasks
+
 test:
 	$(GRADLE) --no-daemon :core:test :engine-grammalecte:test :spellchecker:test
 

ROADMAP.md

@@ -95,7 +95,7 @@ Exit criterion: correction remains usable in common editable applications even w
 - [x] Review all user-facing French strings
 - [x] Add compatibility documentation
 - [x] Add performance regression tests
-- [ ] Add memory/runtime stress tests
+- [x] Add memory/runtime stress tests
 
 ## Phase 5 — Public distribution
 

docs/testing.md

@@ -246,3 +246,42 @@ profiling concern.
 Performance regression tests are intended to detect substantial regressions,
 such as accidental runtime reinitialization, repeated asset loading or major
 analysis slowdowns, rather than small timing variations.
+
+## Runtime and memory stress tests
+
+`EngineRuntimeStressTest` exercises the real embedded QuickJS/Grammalecte
+runtime under sustained use.
+
+The stress suite covers:
+
+- a long-lived engine performing hundreds of grammar analyses and repeated
+  spelling checks;
+- retained QuickJS memory before and after sustained analysis, measured after
+  explicit QuickJS garbage collection;
+- concurrent bursts of grammar and spelling requests sharing one serialized
+  runtime;
+- repeated engine creation, use and closure cycles.
+
+Run the suite with:
+
+    make stress-check
+
+The stress tests are opt-in through `-PgrammalecteStress=1` and are executed
+by CI through the dedicated `stress-check` target.
+
+The initial development measurement after 400 long-lived analyses reported:
+
+- QuickJS memory before stress: 30.00 MiB;
+- QuickJS memory after stress: 30.00 MiB;
+- retained-memory growth: 0.00 MiB;
+- QuickJS allocated memory after stress: 40.62 MiB;
+- objects after stress: 91,502;
+- strings after stress: 36,620.
+
+The retained-memory regression budget is 8 MiB. This intentionally allows
+normal runtime and host variation while detecting substantial accumulation
+across repeated corrections.
+
+These measurements concern the embedded QuickJS runtime used by the JVM test
+environment. They protect engine lifecycle and memory behavior but are not a
+claim about total Android process memory or device-specific RSS.

engine-grammalecte/build.gradle.kts

@@ -64,6 +64,14 @@ tasks.withType<org.gradle.api.tasks.testing.Test>().configureEach {
             .orElse("0")
             .get(),
     )
+
+    systemProperty(
+        "grammalecte.stress",
+        providers
+            .gradleProperty("grammalecteStress")
+            .orElse("0")
+            .get(),
+    )
 }
 
 dependencies {

engine-grammalecte/src/main/kotlin/fr/grammalecteandroid/engine/GrammalecteQuickJsEngine.kt

@@ -13,6 +13,13 @@ import kotlinx.coroutines.runBlocking
 import org.json.JSONArray
 import org.json.JSONObject
 
+internal data class GrammalecteRuntimeMemorySnapshot(
+    val memoryUsedBytes: Long,
+    val mallocBytes: Long,
+    val objectCount: Long,
+    val stringCount: Long,
+)
+
 class GrammalecteQuickJsEngine internal constructor(
     private val assetLoader: AssetTextLoader,
     private val rulePreferences: GrammalecteRulePreferences? = null,
@@ -598,6 +605,27 @@ class GrammalecteQuickJsEngine internal constructor(
         }
     }
 
+    internal fun collectRuntimeGarbageAndSnapshot(): GrammalecteRuntimeMemorySnapshot =
+        synchronized(lock) {
+            val js =
+                runtime
+                    ?: createRuntime().also {
+                        runtime = it
+                    }
+
+            js.gc()
+
+            val usage =
+                js.memoryUsage
+
+            GrammalecteRuntimeMemorySnapshot(
+                memoryUsedBytes = usage.memoryUsedSize,
+                mallocBytes = usage.mallocSize,
+                objectCount = usage.objCount,
+                stringCount = usage.strCount,
+            )
+        }
+
     override fun close() {
         synchronized(lock) {
             runtime?.close()