@openeditor/react-native-prose-editor 0.0.2

package/android/src/test/java/com/apollohg/editor/NativeEditorModuleTest.kt

@@ -0,0 +1,27 @@
+package com.openeditor.editor
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+class NativeEditorModuleTest {
+    @Test
+    fun `native unsigned argument helpers reject negative values`() {
+        assertNull(nativeULong(-1))
+        assertNull(nativeUInt(-1))
+    }
+
+    @Test
+    fun `native unsigned argument helpers keep non-negative values`() {
+        assertEquals(0UL, nativeULong(0))
+        assertEquals(42UL, nativeULong(42))
+        assertEquals(0U, nativeUInt(0))
+        assertEquals(42U, nativeUInt(42))
+    }
+
+    @Test
+    fun `native argument error returns bridge parseable json`() {
+        assertEquals("{\"error\":\"invalid editor id\"}", nativeArgumentError("editor id"))
+        assertEquals("{\"error\":\"invalid position\"}", nativeArgumentError("position"))
+    }
+}

package/android/src/test/java/com/apollohg/editor/NativePerformanceTest.kt

@@ -0,0 +1,197 @@
+package com.openeditor.editor
+
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.Color
+import android.view.View
+import android.view.ViewGroup
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+import org.robolectric.annotation.Config
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [34])
+class NativePerformanceTest {
+    private val context = RuntimeEnvironment.getApplication()
+    private val baseFontSize = 16f
+    private val textColor = Color.BLACK
+
+    @Test
+    fun `performance - render bridge large document`() {
+        val renderJson = NativePerformanceFixtureFactory.largeRenderJson()
+
+        val stats = measureOperation("renderBridgeLargeDocument") {
+            val spannable = RenderBridge.buildSpannable(
+                renderJson,
+                baseFontSize,
+                textColor,
+                density = context.resources.displayMetrics.density
+            )
+
+            assertTrue("rendered spannable should not be empty", spannable.isNotEmpty())
+            if (spannable.isNotEmpty()) {
+                spannable.getSpans(
+                    0,
+                    minOf(spannable.length, 1),
+                    Any::class.java
+                )
+            }
+        }
+
+        assertTrue("average render time should be positive", stats.averageMillis > 0.0)
+    }
+
+    @Test
+    fun `performance - apply update json large document`() {
+        val updateJson = NativePerformanceFixtureFactory.largeUpdateJson()
+        val editText = EditorEditText(context).apply {
+            layoutParams = ViewGroup.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                ViewGroup.LayoutParams.WRAP_CONTENT
+            )
+            setBaseStyle(baseFontSize, textColor, Color.WHITE)
+            captureApplyUpdateTraceForTesting = true
+        }
+        val traceSamples = mutableListOf<EditorEditText.ApplyUpdateTrace>()
+
+        editText.applyUpdateJSON(updateJson, notifyListener = false)
+        layoutView(editText, widthPx = 1080, heightPx = 2400, heightMode = View.MeasureSpec.AT_MOST)
+
+        val stats = measureOperation("applyUpdateJsonLargeDocument") {
+            editText.applyUpdateJSON(updateJson, notifyListener = false)
+            layoutView(editText, widthPx = 1080, heightPx = 2400, heightMode = View.MeasureSpec.AT_MOST)
+            editText.lastApplyUpdateTrace()?.let(traceSamples::add)
+
+            assertFalse("edit text should contain rendered content", editText.text.isNullOrEmpty())
+            assertNotNull("edit text should have a layout after applying update", editText.layout)
+        }
+        println(
+            ApplyUpdateTraceStats(
+                name = "applyUpdateJsonLargeDocument.breakdown",
+                traces = traceSamples.takeLast(5)
+            ).summaryString()
+        )
+
+        assertTrue("average applyUpdateJSON time should be positive", stats.averageMillis > 0.0)
+    }
+
+    @Test
+    fun `performance - apply render patch large document`() {
+        val initialUpdateJson = NativePerformanceFixtureFactory.largeUpdateJson()
+        val patchedUpdateJson = NativePerformanceFixtureFactory.largePatchedUpdateJson()
+        val editText = EditorEditText(context).apply {
+            layoutParams = ViewGroup.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                ViewGroup.LayoutParams.WRAP_CONTENT
+            )
+            setBaseStyle(baseFontSize, textColor, Color.WHITE)
+            captureApplyUpdateTraceForTesting = true
+        }
+        val traceSamples = mutableListOf<EditorEditText.ApplyUpdateTrace>()
+
+        val stats = measureOperation(
+            name = "applyRenderPatchLargeDocument",
+            beforeEach = {
+                editText.applyUpdateJSON(initialUpdateJson, notifyListener = false)
+                layoutView(editText, widthPx = 1080, heightPx = 2400, heightMode = View.MeasureSpec.AT_MOST)
+            }
+        ) {
+            editText.applyUpdateJSON(patchedUpdateJson, notifyListener = false)
+            layoutView(editText, widthPx = 1080, heightPx = 2400, heightMode = View.MeasureSpec.AT_MOST)
+            editText.lastApplyUpdateTrace()?.let(traceSamples::add)
+
+            assertFalse("edit text should contain rendered content", editText.text.isNullOrEmpty())
+        }
+        println(
+            ApplyUpdateTraceStats(
+                name = "applyRenderPatchLargeDocument.breakdown",
+                traces = traceSamples.takeLast(5)
+            ).summaryString()
+        )
+
+        assertTrue("average patch apply time should be positive", stats.averageMillis > 0.0)
+    }
+
+    @Test
+    fun `performance - remote selection overlay refresh multi peer large document`() {
+        val updateJson = NativePerformanceFixtureFactory.largeUpdateJson()
+        val richTextView = RichTextEditorView(context).apply {
+            configure(textSizePx = baseFontSize, textColor = textColor, backgroundColor = Color.WHITE)
+            setRemoteSelectionEditorIdForTesting(1L)
+            setRemoteSelectionScalarResolverForTesting { _, docPos -> docPos }
+        }
+
+        richTextView.editorEditText.applyUpdateJSON(updateJson, notifyListener = false)
+        layoutView(richTextView, widthPx = 1080, heightPx = 1600, heightMode = View.MeasureSpec.EXACTLY)
+
+        val totalScalar = richTextView.editorEditText.text?.length ?: 0
+        val selections = NativePerformanceFixtureFactory.remoteSelections(
+            totalScalar,
+            peerCount = 24,
+            selectionWidth = 24
+        )
+        richTextView.setRemoteSelections(selections)
+        layoutView(richTextView, widthPx = 1080, heightPx = 1600, heightMode = View.MeasureSpec.EXACTLY)
+
+        val bitmap = Bitmap.createBitmap(1080, 1600, Bitmap.Config.ARGB_8888)
+        val canvas = Canvas(bitmap)
+
+        val stats = measureOperation("remoteSelectionOverlayRefreshMultiPeerLargeDocument") {
+            bitmap.eraseColor(Color.TRANSPARENT)
+            richTextView.setRemoteSelections(selections)
+            layoutView(richTextView, widthPx = 1080, heightPx = 1600, heightMode = View.MeasureSpec.EXACTLY)
+            richTextView.draw(canvas)
+
+            val snapshots = richTextView.remoteSelectionDebugSnapshotsForTesting()
+            assertTrue(
+                "remote selection overlay should resolve visible carets",
+                snapshots.any { it.caretRect != null }
+            )
+            assertEquals("expected one snapshot per peer", selections.size, snapshots.size)
+        }
+
+        assertTrue("average remote selection refresh time should be positive", stats.averageMillis > 0.0)
+    }
+
+    private fun layoutView(
+        view: View,
+        widthPx: Int,
+        heightPx: Int,
+        heightMode: Int
+    ) {
+        val widthSpec = View.MeasureSpec.makeMeasureSpec(widthPx, View.MeasureSpec.EXACTLY)
+        val heightSpec = View.MeasureSpec.makeMeasureSpec(heightPx, heightMode)
+        view.measure(widthSpec, heightSpec)
+        view.layout(0, 0, view.measuredWidth, view.measuredHeight)
+    }
+
+    private fun measureOperation(
+        name: String,
+        warmupIterations: Int = 3,
+        measuredIterations: Int = 5,
+        beforeEach: (() -> Unit)? = null,
+        block: () -> Unit
+    ): TimingStats {
+        repeat(warmupIterations) {
+            beforeEach?.invoke()
+            block()
+        }
+
+        val samples = MutableList(measuredIterations) {
+            beforeEach?.invoke()
+            val startedAt = System.nanoTime()
+            block()
+            System.nanoTime() - startedAt
+        }
+
+        val stats = TimingStats(name, samples)
+        println(stats.summaryString())
+        return stats
+    }
+}

package/android/src/test/java/com/apollohg/editor/NativeProseViewerExpoViewTest.kt

@@ -0,0 +1,84 @@
+package com.openeditor.editor
+
+import android.content.Context
+import android.view.View
+import expo.modules.core.ModuleRegistry
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.ModulesProvider
+import expo.modules.kotlin.modules.Module
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+import org.robolectric.annotation.Config
+import java.lang.ref.WeakReference
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [34])
+class NativeProseViewerExpoViewTest {
+    @Test
+    fun `viewer measure ignores stale exact parent height`() {
+        val expoContext = testExpoContext(RuntimeEnvironment.getApplication())
+        val view = NativeProseViewerExpoView(expoContext.context, expoContext.appContext)
+        view.suppressContentHeightEventsForTesting = true
+        view.setRenderJson(paragraphRenderJson(LONG_MESSAGE_TEXT))
+
+        val widthSpec = View.MeasureSpec.makeMeasureSpec(600, View.MeasureSpec.EXACTLY)
+        val wrapHeightSpec = View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED)
+        view.measure(widthSpec, wrapHeightSpec)
+        view.layout(0, 0, view.measuredWidth, view.measuredHeight)
+        val contentHeight = view.measuredHeight
+
+        assertTrue(contentHeight > 0)
+
+        val staleExactHeightSpec = View.MeasureSpec.makeMeasureSpec(
+            contentHeight + 480,
+            View.MeasureSpec.EXACTLY
+        )
+        view.measure(widthSpec, staleExactHeightSpec)
+
+        assertEquals(contentHeight, view.measuredHeight)
+    }
+
+    private data class TestExpoContext(
+        val context: Context,
+        val appContext: AppContext
+    )
+
+    private fun testExpoContext(context: Context): TestExpoContext {
+        val reactContext = Class
+            .forName("com.facebook.react.bridge.BridgeReactContext")
+            .getConstructor(Context::class.java)
+            .newInstance(context) as Context
+
+        val modulesProvider = object : ModulesProvider {
+            override fun getModulesList(): List<Class<out Module>> = emptyList()
+        }
+        val constructor = AppContext::class.java.constructors.first { constructor ->
+            constructor.parameterTypes.size == 3
+        }
+        val appContext = constructor.newInstance(
+            modulesProvider,
+            ModuleRegistry(emptyList(), emptyList()),
+            WeakReference(reactContext)
+        ) as AppContext
+        return TestExpoContext(reactContext, appContext)
+    }
+
+    private fun paragraphRenderJson(text: String): String =
+        """
+        [
+          {"type":"blockStart","nodeType":"paragraph","depth":0},
+          {"type":"textRun","text":"$text","marks":[]},
+          {"type":"blockEnd"}
+        ]
+        """.trimIndent()
+
+    private companion object {
+        private val LONG_MESSAGE_TEXT = List(80) {
+            "Long Android viewer message"
+        }.joinToString(" ")
+    }
+}