ranger-compiler 3.5.0 → 3.5.2

package/dist/lib/evg/EVGPatchTest.rgr

@@ -0,0 +1,692 @@
+; SPDX-License-Identifier: MIT
+
+; ==============================================================================
+; EVGPatchTest — an edit that cannot be undone is a bug, not a feature
+; ==============================================================================
+;
+; `EVGPatch` makes one promise that everything above it relies on: after
+; `apply` and then `rollback`, the tree is what it was. Most of this file is
+; that promise, asked of each kind of op, because the ways it can be broken are
+; all quiet — a value restored but its inline flag left set, a subtree put back
+; one index over, a rejected op that already wrote half of itself.
+;
+; The last test is the one that guards the file's own structure: every property
+; name `kindOf` admits must be readable and clearable, or the "an op that
+; cannot be inverted does not apply" rule has a hole in exactly the place
+; nobody looks.
+;
+;   npm run evg:patch:test
+; ==============================================================================
+
+Import "EVGPatch.rgr"
+Import "EVGCodepoint.rgr"
+Import "EVGTreeJson.rgr"
+Import "EVGElement.rgr"
+Import "EVGInspect.rgr"
+Import "EVGReject.rgr"
+
+class EVGPatchTest {
+    def passed:int 0
+    def failed:int 0
+
+    sfn m@(main):void () {
+        def t (new EVGPatchTest())
+        t.run()
+    }
+
+    fn ok:void (what:string cond:boolean) {
+        if cond {
+            passed = (passed + 1)
+            print ("  PASS  " + what)
+        } {
+            failed = (failed + 1)
+            print ("  FAIL  " + what)
+        }
+    }
+
+    fn same:void (what:string got:string want:string) {
+        def hit:boolean (got == want)
+        if hit {
+            passed = (passed + 1)
+            print ("  PASS  " + what)
+        } {
+            failed = (failed + 1)
+            print ((((("  FAIL  " + what) + " — got \"") + got) + "\" want \"") + (want + "\""))
+        }
+    }
+
+    ; --- a tree to edit -------------------------------------------------------
+    ;
+    ;   0            root, a column
+    ;   0/0          card
+    ;   0/0/0        title (span, "Orders")
+    ;   0/k:side     an aside, keyed — so the keyed path is exercised too
+
+    fn build:EVGElement () {
+        def root:EVGElement (EVGElement.createDiv())
+        root.className = "page"
+        def card:EVGElement (EVGElement.createDiv())
+        card.className = "card"
+        def title:EVGElement (EVGElement.createSpan())
+        title.textContent = "Orders"
+        card.addChild(title)
+        root.addChild(card)
+        def side:EVGElement (EVGElement.createDiv())
+        side.key = "side"
+        root.addChild(side)
+        return root
+    }
+
+    fn ops:[EVGPatchOp] () {
+        def a:[EVGPatchOp]
+        return a
+    }
+
+    ; --- set-prop -------------------------------------------------------------
+
+    fn testSetProp:void () {
+        print ""
+        print "-- set-prop"
+        def root:EVGElement (this.build())
+        def p (new EVGPatch())
+        def list:[EVGPatchOp] (this.ops())
+        push list (EVGPatchOp.setProp("0/0" "background-color" "#ff0000"))
+        def r:EVGPatchResult (p.apply(root list))
+        this.ok("it applied" r.ok)
+        this.ok("one op" (r.applied == 1))
+        def card:EVGElement (itemAt root.children 0)
+        this.ok("the colour is set" card.backgroundColor.isSet)
+        this.ok("and marked inline" (card.hasInline("background-color")))
+        this.ok("one inverse recorded" ((array_length r.inverse) == 1))
+
+        p.rollback(root)
+        this.ok("rollback unset it again" (card.backgroundColor.isSet == false))
+        this.ok("and unmarked it" ((card.hasInline("background-color")) == false))
+    }
+
+    fn testSetPropOverExisting:void () {
+        print ""
+        print "-- set-prop over a value that was already there"
+        def root:EVGElement (this.build())
+        def card:EVGElement (itemAt root.children 0)
+        card.setAttribute("width" "300px")
+        card.markInline("width")
+        def before:string (EVGPatch.readProp(card "width"))
+        def p (new EVGPatch())
+        def list:[EVGPatchOp] (this.ops())
+        push list (EVGPatchOp.setProp("0/0" "width" "50%"))
+        def r:EVGPatchResult (p.apply(root list))
+        this.ok("it applied" r.ok)
+        this.same("the new width" (EVGPatch.readProp(card "width")) "50%")
+        p.rollback(root)
+        this.same("rollback put the old one back" (EVGPatch.readProp(card "width")) before)
+        this.ok("and it is still inline, as it was" (card.hasInline("width")))
+    }
+
+    ; An id is the one thing on a node that nothing paints and everything else
+    ; depends on: the hit test answers with it, and an app turns it into an
+    ; event. It round-trips like any other edit, and it refuses to name two
+    ; nodes the same, because a press can only reach one of them.
+    fn testSetId:void () {
+        print ""
+        print "-- set-id"
+        def root:EVGElement (this.build())
+        def p (new EVGPatch())
+        def list:[EVGPatchOp] (this.ops())
+        push list (EVGPatchOp.setId("0/0" "nav.map"))
+        def r:EVGPatchResult (p.apply(root list))
+        this.ok("it applied" r.ok)
+        def card:EVGElement (itemAt root.children 0)
+        this.same("the node is named" card.id "nav.map")
+        p.rollback(root)
+        this.same("rollback takes the name off again" card.id "")
+    }
+
+    fn testDuplicateId:void () {
+        print ""
+        print "-- two nodes, one id"
+        def root:EVGElement (this.build())
+        def p (new EVGPatch())
+        def list:[EVGPatchOp] (this.ops())
+        push list (EVGPatchOp.setId("0/0" "nav.map"))
+        push list (EVGPatchOp.setId("0/k:side" "nav.map"))
+        def r:EVGPatchResult (p.apply(root list))
+        this.ok("the batch is refused" (r.ok == false))
+        this.ok("the reason names the node that has it" ((indexOf (r.reason()) "0/0") >= 0))
+        def card:EVGElement (itemAt root.children 0)
+        this.same("and nothing landed" card.id "")
+    }
+
+    fn testUnknownProperty:void () {
+        print ""
+        print "-- a property the engine does not implement"
+        def root:EVGElement (this.build())
+        def p (new EVGPatch())
+        def list:[EVGPatchOp] (this.ops())
+        push list (EVGPatchOp.setProp("0/0" "aspect-ratio" "16/9"))
+        def r:EVGPatchResult (p.apply(root list))
+        this.ok("it was rejected" (r.ok == false))
+        this.ok("nothing applied" (r.applied == 0))
+        this.ok("with a reason" ((strlen (r.reason())) > 0))
+        def card:EVGElement (itemAt root.children 0)
+        this.ok("and nothing was marked inline" ((card.hasInline("aspect-ratio")) == false))
+    }
+
+    fn testValueTheEngineRejects:void () {
+        print ""
+        print "-- a known property, a value it cannot read"
+        def root:EVGElement (this.build())
+        def card:EVGElement (itemAt root.children 0)
+        card.setAttribute("width" "300px")
+        card.markInline("width")
+        def p (new EVGPatch())
+        def list:[EVGPatchOp] (this.ops())
+        push list (EVGPatchOp.setProp("0/0" "width" "banana"))
+        def r:EVGPatchResult (p.apply(root list))
+        this.ok("it was rejected" (r.ok == false))
+        this.same("and the old width survived" (EVGPatch.readProp(card "width")) "300px")
+    }
+
+    fn testNoSuchNode:void () {
+        print ""
+        print "-- an address that is not there"
+        def root:EVGElement (this.build())
+        def p (new EVGPatch())
+        def list:[EVGPatchOp] (this.ops())
+        push list (EVGPatchOp.setProp("0/9/4" "color" "#000000"))
+        def r:EVGPatchResult (p.apply(root list))
+        this.ok("it was rejected" (r.ok == false))
+        this.ok("the reason names the path" ((indexOf (r.reason()) "0/9/4") >= 0))
+    }
+
+    ; --- all or nothing -------------------------------------------------------
+
+    fn testAllOrNothing:void () {
+        print ""
+        print "-- a bad op in the middle of a good batch"
+        def root:EVGElement (this.build())
+        def card:EVGElement (itemAt root.children 0)
+        def title:EVGElement (itemAt card.children 0)
+        def p (new EVGPatch())
+        def list:[EVGPatchOp] (this.ops())
+        push list (EVGPatchOp.setProp("0/0" "background-color" "#ff0000"))
+        push list (EVGPatchOp.setText("0/0/0" "Invoices"))
+        push list (EVGPatchOp.setProp("0/0" "aspect-ratio" "16/9"))
+        push list (EVGPatchOp.setProp("0/0" "color" "#00ff00"))
+        def r:EVGPatchResult (p.apply(root list))
+        this.ok("the batch failed" (r.ok == false))
+        this.ok("and reports nothing applied" (r.applied == 0))
+        this.ok("the colour from op 0 is gone" (card.backgroundColor.isSet == false))
+        this.same("and the text from op 1 is back" title.textContent "Orders")
+    }
+
+    ; --- set-text -------------------------------------------------------------
+
+    fn testSetText:void () {
+        print ""
+        print "-- set-text"
+        def root:EVGElement (this.build())
+        def card:EVGElement (itemAt root.children 0)
+        def title:EVGElement (itemAt card.children 0)
+        def p (new EVGPatch())
+        def list:[EVGPatchOp] (this.ops())
+        push list (EVGPatchOp.setText("0/0/0" "Invoices"))
+        def r:EVGPatchResult (p.apply(root list))
+        this.ok("it applied" r.ok)
+        this.same("the new text" title.textContent "Invoices")
+        p.rollback(root)
+        this.same("rollback restored it" title.textContent "Orders")
+    }
+
+    fn testSetTextOnAParent:void () {
+        print ""
+        print "-- set-text where there are children to lose"
+        def root:EVGElement (this.build())
+        def p (new EVGPatch())
+        def list:[EVGPatchOp] (this.ops())
+        push list (EVGPatchOp.setText("0/0" "nope"))
+        def r:EVGPatchResult (p.apply(root list))
+        this.ok("it was rejected" (r.ok == false))
+    }
+
+    ; --- insert / remove / move -----------------------------------------------
+
+    fn testInsert:void () {
+        print ""
+        print "-- insert"
+        def root:EVGElement (this.build())
+        def card:EVGElement (itemAt root.children 0)
+        def p (new EVGPatch())
+        def list:[EVGPatchOp] (this.ops())
+        push list (EVGPatchOp.insertNode("0/0" 0 "span"))
+        def r:EVGPatchResult (p.apply(root list))
+        this.ok("it applied" r.ok)
+        this.ok("the card has two children" ((array_length card.children) == 2))
+        def first:EVGElement (itemAt card.children 0)
+        this.same("the new one is first" first.tagName "span")
+        p.rollback(root)
+        this.ok("rollback took it out" ((array_length card.children) == 1))
+        def back:EVGElement (itemAt card.children 0)
+        this.same("leaving the original" back.textContent "Orders")
+    }
+
+    ; A CONTROL, not an empty box. A switch is a track with a thumb in it, so
+    ; an insert that can only carry one tag makes an agent build one out of a
+    ; dozen ops — and a dozen ops is how a screen ends up with a drawing of a
+    ; switch rather than a switch.
+    fn testInsertSubtree:void () {
+        print ""
+        print "-- insert a whole subtree"
+        def root:EVGElement (this.build())
+        def card:EVGElement (itemAt root.children 0)
+        def track:EVGElement (EVGElement.createDiv())
+        track.className = "ui-switch-track"
+        def thumb:EVGElement (EVGElement.createDiv())
+        thumb.className = "ui-switch-thumb"
+        track.addChild(thumb)
+        def p (new EVGPatch())
+        def list:[EVGPatchOp] (this.ops())
+        push list (EVGPatchOp.insertTree("0/0" 0 track))
+        def r:EVGPatchResult (p.apply(root list))
+        this.ok("it applied" r.ok)
+        def first:EVGElement (itemAt card.children 0)
+        this.same("the subtree went in whole" first.className "ui-switch-track")
+        this.ok("with what was inside it" ((array_length first.children) == 1))
+        p.rollback(root)
+        this.ok("rollback takes the whole thing out again" ((array_length card.children) == 1))
+    }
+
+    fn testInsertUnknownTag:void () {
+        print ""
+        print "-- insert of something that is not an element"
+        def root:EVGElement (this.build())
+        def p (new EVGPatch())
+        def list:[EVGPatchOp] (this.ops())
+        push list (EVGPatchOp.insertNode("0/0" 0 "marquee"))
+        def r:EVGPatchResult (p.apply(root list))
+        this.ok("it was rejected" (r.ok == false))
+    }
+
+    fn testRemoveAndRestore:void () {
+        print ""
+        print "-- remove, and put it back with its subtree"
+        def root:EVGElement (this.build())
+        def p (new EVGPatch())
+        def list:[EVGPatchOp] (this.ops())
+        push list (EVGPatchOp.removeNode("0/0"))
+        def r:EVGPatchResult (p.apply(root list))
+        this.ok("it applied" r.ok)
+        this.ok("the root has one child left" ((array_length root.children) == 1))
+        def left:EVGElement (itemAt root.children 0)
+        this.same("and it is the keyed one" left.key "side")
+
+        p.rollback(root)
+        this.ok("rollback gave the card back" ((array_length root.children) == 2))
+        def card:EVGElement (itemAt root.children 0)
+        this.same("in its old place" card.className "card")
+        this.ok("with its child" ((array_length card.children) == 1))
+        def title:EVGElement (itemAt card.children 0)
+        this.same("and its text" title.textContent "Orders")
+    }
+
+    fn testRemoveRoot:void () {
+        print ""
+        print "-- remove of the root"
+        def root:EVGElement (this.build())
+        def p (new EVGPatch())
+        def list:[EVGPatchOp] (this.ops())
+        push list (EVGPatchOp.removeNode("0"))
+        def r:EVGPatchResult (p.apply(root list))
+        this.ok("it was rejected" (r.ok == false))
+    }
+
+    fn testKeyedPath:void () {
+        print ""
+        print "-- a keyed address"
+        def root:EVGElement (this.build())
+        def side:EVGElement (itemAt root.children 1)
+        def p (new EVGPatch())
+        def list:[EVGPatchOp] (this.ops())
+        push list (EVGPatchOp.setProp("0/k:side" "width" "120px"))
+        def r:EVGPatchResult (p.apply(root list))
+        this.ok("it applied" r.ok)
+        this.same("to the keyed node" (EVGPatch.readProp(side "width")) "120px")
+        p.rollback(root)
+        this.same("and rolled back" (EVGPatch.readProp(side "width")) "")
+    }
+
+    fn testMove:void () {
+        print ""
+        print "-- move"
+        def root:EVGElement (this.build())
+        def card:EVGElement (itemAt root.children 0)
+        def side:EVGElement (itemAt root.children 1)
+        def p (new EVGPatch())
+        def list:[EVGPatchOp] (this.ops())
+        push list (EVGPatchOp.move("0/0/0" "0/k:side" 0))
+        def r:EVGPatchResult (p.apply(root list))
+        this.ok("it applied" r.ok)
+        this.ok("the card lost its child" ((array_length card.children) == 0))
+        this.ok("the aside gained one" ((array_length side.children) == 1))
+        p.rollback(root)
+        this.ok("rollback moved it home" ((array_length card.children) == 1))
+        this.ok("and emptied the aside" ((array_length side.children) == 0))
+        def title:EVGElement (itemAt card.children 0)
+        this.same("the same node" title.textContent "Orders")
+    }
+
+    fn testMoveIntoItself:void () {
+        print ""
+        print "-- move of a node into its own subtree"
+        def root:EVGElement (this.build())
+        def p (new EVGPatch())
+        def list:[EVGPatchOp] (this.ops())
+        push list (EVGPatchOp.move("0/0" "0/0/0" 0))
+        def r:EVGPatchResult (p.apply(root list))
+        this.ok("it was rejected" (r.ok == false))
+        def card:EVGElement (itemAt root.children 0)
+        this.ok("and the card still has its child" ((array_length card.children) == 1))
+    }
+
+    ; --- the table's own invariant --------------------------------------------
+    ;
+    ; Every name `kindOf` admits has to be answerable by `readProp` and
+    ; `clearProp`. A name in one list and not the others is the failure mode
+    ; this file exists to make loud: it would present as "this property is
+    ; patchable" followed by an undo that silently does nothing.
+
+    fn testTableIsWhole:void () {
+        print ""
+        print "-- the patchable set answers in all three places"
+        def list:[string] (EVGPatch.patchableNames())
+        def admitted:int 0
+        def clearable:int 0
+        def i:int 0
+        while (i < (array_length list)) {
+            def name:string (itemAt list i)
+            if (EVGPatch.readable(name)) {
+                admitted = (admitted + 1)
+            } {
+                print ("        kindOf does not admit " + name)
+            }
+            def el:EVGElement (EVGElement.createDiv())
+            if (EVGPatch.clearProp(el name)) {
+                clearable = (clearable + 1)
+            } {
+                print ("        clearProp cannot clear " + name)
+            }
+            i = (i + 1)
+        }
+        def n:int (array_length list)
+        this.ok("every name is admitted" (admitted == n))
+        this.ok("every name is clearable" (clearable == n))
+    }
+
+    fn testClearedIsWhatAFreshElementSays:void () {
+        print ""
+        print "-- clearing restores what a fresh element reads"
+        def list:[string] (EVGPatch.patchableNames())
+        def matched:int 0
+        def i:int 0
+        while (i < (array_length list)) {
+            def name:string (itemAt list i)
+            def fresh:EVGElement (EVGElement.createDiv())
+            def want:string (EVGPatch.readProp(fresh name))
+            def used:EVGElement (EVGElement.createDiv())
+            used.setAttribute(name "10px")
+            def cleared:boolean (EVGPatch.clearProp(used name))
+            def got:string (EVGPatch.readProp(used name))
+            if (got == want) {
+                matched = (matched + 1)
+            } {
+                print (((("        " + name) + ": cleared to \"") + got) + (("\" but fresh reads \"" + want) + "\""))
+            }
+            i = (i + 1)
+        }
+        this.ok("all of them" (matched == (array_length list)))
+    }
+
+    fn testNotPatchable:void () {
+        print ""
+        print "-- a name nothing here can read"
+        this.ok("aspect-ratio is not patchable" ((EVGPatch.readable("aspect-ratio")) == false))
+        this.ok("width is" (EVGPatch.readable("width")))
+        this.ok("camelCase finds it too" (EVGPatch.readable("minWidth")))
+        this.ok("and class is an alias for class-name" (EVGPatch.readable("class")))
+    }
+
+
+    ; --- the document format --------------------------------------------------
+    ;
+    ; Round-trip is the only claim worth testing here: write, read, write, and
+    ; the two texts are the same. It catches a property the writer emits and
+    ; the reader ignores, and a reader that quietly builds the wrong tag, both
+    ; of which otherwise show up much later as a document that drifts a little
+    ; every time it is saved.
+
+    fn testRoundTrip:void () {
+        print ""
+        print "-- write, read, write"
+        def root:EVGElement (this.build())
+        def card:EVGElement (itemAt root.children 0)
+        card.setAttribute("background-color" "#ff0000")
+        card.markInline("background-color")
+        card.setAttribute("width" "320px")
+        card.markInline("width")
+        def once:string (EVGTreeJson.toText(root))
+        def back@(optional):EVGElement (EVGTreeJson.fromText(once))
+        this.ok("it read back" ((null? back) == false))
+        if (null? back) {
+            return
+        }
+        def again:EVGElement (unwrap back)
+        def twice:string (EVGTreeJson.toText(again))
+        this.same("the two texts agree" twice once)
+        def readCard:EVGElement (itemAt again.children 0)
+        ; the reader's canonical form is what setAttribute takes back, which is rgb()
+        this.same("the colour survived" (EVGPatch.readProp(readCard "background-color")) "rgb(255,0,0)")
+        this.same("the width survived" (EVGPatch.readProp(readCard "width")) "320px")
+        this.same("the class survived" readCard.className "card")
+        def readTitle:EVGElement (itemAt readCard.children 0)
+        this.same("the text survived" readTitle.textContent "Orders")
+        this.same("and the tag" readTitle.tagName "span")
+        def readSide:EVGElement (itemAt again.children 1)
+        this.same("as did the key" readSide.key "side")
+    }
+
+    ; WHAT A NODE IS survives the file. A document that cannot say "this is a
+    ; switch" leaves everything downstream guessing from the shape, and a
+    ; control drawn out of boxes is exactly the same shape as a real one.
+    fn testMeaningRoundTrip:void () {
+        print ""
+        print "-- what a node IS, written and read"
+        def root:EVGElement (this.build())
+        def card:EVGElement (itemAt root.children 0)
+        card.role = "switch"
+        card.a11yLabel = "Wi-Fi"
+        card.a11yChecked = 2
+        def kid:EVGElement (itemAt card.children 0)
+        kid.a11yHidden = true
+        def once:string (EVGTreeJson.toText(root))
+        this.ok("the role is in the file" ((indexOf once "\"role\":\"switch\"") >= 0))
+        def back@(optional):EVGElement (EVGTreeJson.fromText(once))
+        this.ok("it read back" ((null? back) == false))
+        if (null? back) {
+            return
+        }
+        def again:EVGElement (unwrap back)
+        def readCard:EVGElement (itemAt again.children 0)
+        this.same("the role survived" readCard.role "switch")
+        this.same("the name survived" readCard.a11yLabel "Wi-Fi")
+        this.ok("the state survived" (readCard.a11yChecked == 2))
+        def readKid:EVGElement (itemAt readCard.children 0)
+        this.ok("a part stays hidden from a reader" readKid.a11yHidden)
+        this.same("the two texts agree" (EVGTreeJson.toText(again)) once)
+    }
+
+    fn testDefaultsAreNotWritten:void () {
+        print ""
+        print "-- a fresh tree says almost nothing"
+        def plain:EVGElement (EVGElement.createDiv())
+        def text:string (EVGTreeJson.toText(plain))
+        this.ok("no props block" ((indexOf text "props") < 0))
+        this.ok("but it has its tag" ((indexOf text "\"tag\":\"div\"") >= 0))
+    }
+
+    ; A document an agent wrote by hand. Anything that is not ASCII arrives as
+    ; `\uXXXX` — that is what every JSON writer emits — and the reader used to
+    ; drop the backslash and keep the four hex digits, so a middot reached the
+    ; screen as the literal text `u00b7`. It reads as a broken font, which is
+    ; the wrong thing to go looking at.
+    fn testUnicodeEscapes:void () {
+        print ""
+        print "-- \\uXXXX, including a surrogate pair"
+        def json:string "{\"evg\":1,\"root\":{\"tag\":\"div\",\"children\":[{\"tag\":\"span\",\"text\":\"7h \\u00b7 42m \\u203a \\ud83d\\ude00\"}]}}"
+        def back@(optional):EVGElement (EVGTreeJson.fromText(json))
+        this.ok("it read" ((null? back) == false))
+        if (null? back) {
+            return
+        }
+        def tree:EVGElement (unwrap back)
+        def label:EVGElement (itemAt tree.children 0)
+        def want:string ((((("7h " + (EVGCodepoint.toStr(183))) + " 42m ") + (EVGCodepoint.toStr(8250))) + " ") + (EVGCodepoint.toStr(128512)))
+        this.same("every escape became its character" label.textContent want)
+        ; And it survives the way back out, which is where a half-decoded
+        ; string would show up as mojibake instead of a missing character.
+        def again@(optional):EVGElement (EVGTreeJson.fromText((EVGTreeJson.toText(tree))))
+        if (null? again) {
+            this.ok("it wrote back" false)
+            return
+        }
+        def back2:EVGElement (unwrap again)
+        def label2:EVGElement (itemAt back2.children 0)
+        this.same("and the round trip" label2.textContent want)
+    }
+
+    ; A malformed escape is not a crash and not a silent drop: it stays as it
+    ; was written, so the mistake is visible in the document that has it.
+    fn testBadEscape:void () {
+        print ""
+        print "-- an escape that is not one"
+        def json:string "{\"evg\":1,\"root\":{\"tag\":\"div\",\"children\":[{\"tag\":\"span\",\"text\":\"half \\u00zz\"}]}}"
+        def back@(optional):EVGElement (EVGTreeJson.fromText(json))
+        this.ok("it still read" ((null? back) == false))
+        if (null? back) {
+            return
+        }
+        def tree:EVGElement (unwrap back)
+        def kid:EVGElement (itemAt tree.children 0)
+        this.same("and kept what was written" kid.textContent "half u00zz")
+    }
+
+    fn testTextWithQuotes:void () {
+        print ""
+        print "-- text that needs escaping"
+        def root:EVGElement (EVGElement.createDiv())
+        def label:EVGElement (EVGElement.createSpan())
+        label.textContent = "a \"quoted\" line\nand a second"
+        root.addChild(label)
+        def text:string (EVGTreeJson.toText(root))
+        def back@(optional):EVGElement (EVGTreeJson.fromText(text))
+        this.ok("it read back" ((null? back) == false))
+        if (null? back) {
+            return
+        }
+        def again:EVGElement (unwrap back)
+        def readLabel:EVGElement (itemAt again.children 0)
+        this.same("the text came through" readLabel.textContent label.textContent)
+    }
+
+    fn testPatchThenSave:void () {
+        print ""
+        print "-- an edit survives being written down"
+        def root:EVGElement (this.build())
+        def p (new EVGPatch())
+        def list:[EVGPatchOp] (this.ops())
+        push list (EVGPatchOp.setProp("0/0" "padding-left" "16px"))
+        push list (EVGPatchOp.setText("0/0/0" "Invoices"))
+        def r:EVGPatchResult (p.apply(root list))
+        this.ok("the patch applied" r.ok)
+        def saved:string (EVGTreeJson.toText(root))
+        def back@(optional):EVGElement (EVGTreeJson.fromText(saved))
+        this.ok("it read back" ((null? back) == false))
+        if (null? back) {
+            return
+        }
+        def again:EVGElement (unwrap back)
+        def readCard:EVGElement (itemAt again.children 0)
+        this.same("the padding is in the file" (EVGPatch.readProp(readCard "padding-left")) "16px")
+        def readTitle:EVGElement (itemAt readCard.children 0)
+        this.same("and so is the text" readTitle.textContent "Invoices")
+    }
+
+    fn testNotThisFormat:void () {
+        print ""
+        print "-- something that is not a document"
+        def back@(optional):EVGElement (EVGTreeJson.fromText("[1,2,3]"))
+        this.ok("nothing came back" (null? back))
+    }
+
+
+    ; The bug this guards: `EVGBox` keeps the authored unit and the px layout
+    ; resolves from it, and reading the px gave "0.00px" for a padding that had
+    ; just been set — so the inverse restored a number nobody wrote.
+    fn testBoxSidesReadWhatWasWritten:void () {
+        print ""
+        print "-- a box side, before anything is laid out"
+        def root:EVGElement (this.build())
+        def card:EVGElement (itemAt root.children 0)
+        def p (new EVGPatch())
+        def list:[EVGPatchOp] (this.ops())
+        push list (EVGPatchOp.setProp("0/0" "padding-left" "16px"))
+        push list (EVGPatchOp.setProp("0/0" "margin-top" "2em"))
+        def r:EVGPatchResult (p.apply(root list))
+        this.ok("it applied" r.ok)
+        this.same("the padding reads as written" (EVGPatch.readProp(card "padding-left")) "16px")
+        this.same("and the margin keeps its unit" (EVGPatch.readProp(card "margin-top")) "2em")
+        p.rollback(root)
+        this.same("rollback clears the padding" (EVGPatch.readProp(card "padding-left")) "")
+        this.same("and the margin" (EVGPatch.readProp(card "margin-top")) "")
+    }
+
+    fn run:void () {
+        print "=== EVGPatch: every edit carries its own undo ==="
+        this.testSetProp()
+        this.testSetPropOverExisting()
+        this.testSetId()
+        this.testDuplicateId()
+        this.testUnknownProperty()
+        this.testValueTheEngineRejects()
+        this.testNoSuchNode()
+        this.testAllOrNothing()
+        this.testSetText()
+        this.testSetTextOnAParent()
+        this.testInsert()
+        this.testInsertSubtree()
+        this.testMeaningRoundTrip()
+        this.testInsertUnknownTag()
+        this.testRemoveAndRestore()
+        this.testRemoveRoot()
+        this.testKeyedPath()
+        this.testMove()
+        this.testMoveIntoItself()
+        this.testTableIsWhole()
+        this.testClearedIsWhatAFreshElementSays()
+        this.testNotPatchable()
+        this.testBoxSidesReadWhatWasWritten()
+        this.testRoundTrip()
+        this.testDefaultsAreNotWritten()
+        this.testTextWithQuotes()
+        this.testUnicodeEscapes()
+        this.testBadEscape()
+        this.testPatchThenSave()
+        this.testNotThisFormat()
+        print ""
+        print (("passed = " + (to_string passed)) + ("  failed = " + (to_string failed)))
+        if (failed > 0) {
+            print "FAILURES"
+        } {
+            print "ALL PASS"
+        }
+    }
+}