>>> nextvi: Building community/nextvi 7.9-r0 (using abuild 3.18.0_rc7-r1) started Thu, 22 Oct 2026 17:00:42 +0000
>>> nextvi: Validating /home/buildozer/aports/community/nextvi/APKBUILD...
>>> nextvi: Analyzing dependencies...
>>> nextvi: Installing for build: build-base
(1/1) Installing .makedepends-nextvi (20261022.170042)
OK: 427.4 MiB in 106 packages
>>> nextvi: Cleaning up srcdir
>>> nextvi: Cleaning up pkgdir
>>> nextvi: Cleaning up tmpdir
>>> nextvi: Fetching https://distfiles.alpinelinux.org/distfiles/edge/nextvi-7.9.tar.gz
Connecting to distfiles.alpinelinux.org (172.105.82.32:443)
wget: server returned error: HTTP/1.1 404 Not Found
>>> nextvi: Fetching nextvi-7.9.tar.gz::https://github.com/kyx0r/nextvi/archive/refs/tags/7.9.tar.gz
Connecting to github.com (140.82.121.3:443)
Connecting to codeload.github.com (140.82.121.10:443)
saving to '/var/cache/distfiles/edge/nextvi-7.9.tar.gz.part'
nextvi-7.9.tar.gz.pa 100% |********************************| 1071k  0:00:00 ETA
'/var/cache/distfiles/edge/nextvi-7.9.tar.gz.part' saved
/var/cache/distfiles/edge/nextvi-7.9.tar.gz: OK
>>> nextvi: Fetching https://distfiles.alpinelinux.org/distfiles/edge/nextvi-7.9.tar.gz
/var/cache/distfiles/edge/nextvi-7.9.tar.gz: OK
>>> nextvi: Unpacking /var/cache/distfiles/edge/nextvi-7.9.tar.gz...
-> Entering step: "Build "nextvi-7.9" using "cc""
-> cc vi.c -o vi -pedantic -Wall -Wextra -Wno-implicit-fallthrough -Wno-missing-field-initializers -Wno-unused-parameter -Wno-unused-result -Wfatal-errors -std=c99 -Os -fstack-clash-protection -Wformat -Werror=format-security -D_POSIX_C_SOURCE=200809L
Test 1: "print line 1"
Test 2: "print range 1-3"
Test 3: "print all with %"
Test 4: "print last line ($)"
Test 5: "print literal arg"
Test 6: "print line number (=)"
Test 7: "substitute simple"
Test 8: "substitute global"
Test 9: "substitute backreference"
Test 10: "conditional else on sub no-match"
Test 11: "conditional then on sub match"
Test 12: "delete range 2-4"
Test 13: "delete to end"
Test 14: "delete empty lines (global)"
Test 15: "join all no padding"
Test 16: "join all with space padding"
Test 17: "yank line and paste at end"
Test 18: "append to register then paste"
Test 19: "put string into register via :reg"
Test 20: "global print matching lines"
Test 21: "inverted global print"
Test 22: "global with chained sub+print"
Test 23: "nested global"
Test 24: "nested global with substitute"
Test 25: "triple nested global with substitute"
Test 26: "parity: \: keeps separator literal, chains print in global"
Test 27: "parity: \/ in pattern keeps delimiter literal"
Test 28: "parity: \/ in replacement keeps delimiter literal"
Test 29: "parity: 1 pass, \: -> literal colon"
Test 30: "parity: 2 passes, \\\: -> \: -> literal colon"
Test 31: "parity: 3 passes, run-7 colon halves 7->3->1"
Test 32: "parity: sub delimiter unaffected by separator depth (1 backslash)"
Test 33: "parity: selector colon (1 pass) vs body sub colon (2 passes)"
Test 34: "conditional then on search found"
Test 35: "conditional else on search not found"
Test 36: "while loop counted delete"
Test 37: "while loop breaks on xuerr (sub no-match)"
Test 38: "sort buffer via !"
Test 39: "read from pipe into empty buffer"
Test 40: "default ic=1: case-insensitive match"
Test 41: ":ic toggles to case-sensitive match"
Test 42: "exit code :q -> 0"
Test 43: "exit code :q 3 -> 3"
Test 44: "xuerr is silent and chain continues"
Test 45: "vi dw: delete word"
Test 46: "vi dd: delete line"
Test 47: "vi x: delete char"
Test 48: "vi J: join lines with space"
Test 49: "vi gUw: uppercase word"
Test 50: "vi guw: lowercase word"
Test 51: "vi ~: toggle case of char"
Test 52: "vi rH: replace char"
Test 53: "vi yyp: yank and paste line"
Test 54: "vi i...<ESC>: insert at cursor"
Test 55: "vi A...<ESC>: append at end of line"
Test 56: "ex :ud undoes substitute"
Test 57: "ex :rd redoes after undo"
Test 58: "marks: print range via marks"
Test 59: "horizontal range ;6 prints from offset 6"
Test 60: "horizontal range ;0;5 prints chars 0-4"
Test 61: "empty pattern reuses last keyword"
Test 62: "regex alternation in substitute"
Test 63: "regex quantifier {2} matches"
Test 64: "regex lookahead in substitute"
Test 65: "substitute backreference \\0 full match"
Test 66: "substitute backreference \\1 group 1"
Test 67: "substitute with empty replacement deletes match"
Test 68: "ranged :f> search then print current line"
Test 69: "global command with explicit range"
Test 70: ":bs marks buffer saved so :q exits 0"
Test 71: "range arithmetic $-1 prints second-to-last"
Test 72: "pipe through tr a-z A-Z uppercases"
Test 73: "register expansion %@97 in :p"
Test 74: "C12b %\123 — path then literal digits"
Test 75: "C12b %\# — path then literal \#"
Test 76: "C12b \%123 — escaped %, fully literal"
Test 77: "C12b %0\132 — buffer 0 path then literal digits"
Test 78: "C12b %@asd — non-digit after %@ emits path + literal @"
Test 79: "C12b %\"324 — backslash before quote stays literal"
Test 80: "C12b %@100\75 — register 100 then literal digits"
Test 81: "err=3 breaks chain on xuerr"
Test 82: "err=4 silences error and chain continues"
Test 83: ":wq! exits 0"
Test 84: ":f< searches backward"
Test 85: "g! inverted global chained sub+print"
Test 86: "range arithmetic ,2+3 prints 5"
Test 87: "yank two registers and paste both"
Test 88: "vi cw: change word"
Test 89: "vi C: change to end of line"
Test 90: "vi D: delete to end of line"
Test 91: "vi o: open line below"
Test 92: "vi O: open line above"
Test 93: "vi s: substitute char"
Test 94: "vi S: substitute line"
Test 95: "vi P: paste above current line"
Test 96: "vi u: undo restores deleted char"
Test 97: "vi >>: indent adds tab"
Test 98: "vi di(: delete inside parens"
Test 99: "vi ci(: change inside parens"
Test 100: "vi 2dw: delete 2 words"
Test 101: "vi fw+x: find char then delete it"
Test 102: "vi K: split line at cursor"
Test 103: "E1 :& %@97 — register expansion used as raw vi input"
Test 104: "E2 :& \:s// — ex cmd from macro (newline submits)"
Test 105: "E3 vi &a — executes register as non-blocking macro"
Test 106: "E4 vi && — repeats last & macro"
Test 107: "G1 ya! frees reg; pu 97 silently skipped (err 4)"
Test 108: "H1 ?? id captures fail; intervening success does not override"
Test 109: "H2 ?? id captures success; intervening fail does not override"
Test 110: "I1 ??! — fires branch on failure"
Test 111: "I2 ?? — fires branch on success"
Test 112: "I3 ?! while: 1d deletes first line each pass until f>yes succeeds"
Test 113: "J1 seq 0 — batch changes undo as one step"
Test 114: "J2 seq -1 — undo tracking disabled; u has no effect"
Test 115: "K1 pr+led 0 — :p output captured into register, then pasted"
Test 116: "L1 '[ marks first changed line"
Test 117: "L2 '] marks last changed line"
Test 118: "L3 '* = cursor saved before previous ex command"
Test 119: "M1 %@47 expands to the previous regex keyword"
Test 120: "N1 $*5/10 — navigate to 50% of file"
Test 121: "N2 ;5;#+10= 3 — second char offset via # rebase is 15"
Test 122: "N3 5;$= — $ offset is the end of line 5"
Test 123: "N4 6;$= — $ offset on the last line"
Test 124: "N5 3,5;$= — $ offset uses the second line address"
Test 125: "N6 5;>ab>= — offset search on line 5"
Test 126: "N7 5;>six>= — match on line 6 is outside line 5"
Test 127: "N8 2,#+2= — # rebases on line 2, giving lines 2-4"
Test 128: "N9 2,#3= — numeric second address is absolute"
Test 129: "N10 2,#+2;$= — $ offset on rebased end line 4"
Test 130: "N11 5;$c X — insert at the end of line 5"
Test 131: "N12 5;>b>c Y — insert before the match on line 5"
Test 132: "N13 2,#+2d — deletes lines 2-4"
Test 133: "N14 0;>L>i X — searching line 0 is an invalid range"
Test 134: "N15 0;'5i X — unset mark after 0 leaves the buffer unchanged"
Test 135: "N16 0;>L>pu — searching line 0 is an invalid range"
Test 136: "O1 vi f(\%x — find (, jump to matching ), delete )"
Test 137: "Y1 :pu 97 \!cmd — pipe register content to external command"
Test 138: "Y2 :w \!cmd — write buffer range to external command"
Test 139: "Q1 1q in nested ??! scope does not propagate quit to vi"
Test 140: "R1 :re word — sets keyword; %@47 returns it"
Test 141: "R2 :re word; :g// uses set keyword to match lines"
Test 142: "R3 :re does not navigate; cursor stays on current line"
Test 143: "R4 range :re — escapes regex chars; %@47 reflects escaped pattern"
Test 144: "S1 >int>p — forward inline-search range address prints found line"
Test 145: "S2 3:<int<p — backward inline-search range address"
Test 146: "S3 .,>int>p — range from current line to forward match"
Test 147: "S4 .-2,.+2p — relative arithmetic prints 5 lines around line 4"
Test 148: "T1 ;5= 2 — print character offset 5"
Test 149: "T2 '97= 0 — print stored row index of mark a"
Test 150: "T3 ;5;+10= 3 — second offset from initial (0+10=10), not from 5"
Test 151: "U1 g/^$/d — removes all blank lines"
Test 152: "U2 g/int/g/;$/& A has a semicolon — nested global appends text"
Test 153: "U3 err=1 — prints error; chain continues"
Test 154: "U4 2??.= — unset id; branch does not run; chain continues"
Test 155: "U5 grp 1:%f+int(.):grp — char offset after "int" is 8"
Test 156: "U6 ;5;#+10= 3 — #+10 relative to 5; offset = 15"
Test 157: "U7 2,4f>int — ranged :f> restricts search to given line range"
Test 158: "U8b marker found — else skipped; :s and :w execute"
Test 159: "U9 :%!sort — pipe buffer through sort; output replaces buffer"
Test 160: "U10 g/int/ya+ 97 — global appends matching lines to register 97"
Test 161: "U11 :%s/(int)|(void)/pre\0after — \0 is the whole match"
Test 162: "U12 3,5r \!printf — read only lines 3-5 from pipe output"
Test 163: "U13 ;$+1!echo world — cmd output inserted at end; original preserved"
Test 164: "V1 1,2?? AND — both succeed → then"
Test 165: "V2 1,2?? AND — first fails → else"
Test 166: "V3 1,2?? AND — second fails → else"
Test 167: "V4 1;2?? OR — first succeeds → then"
Test 168: "V5 1;2?? OR — second succeeds → then"
Test 169: "V6 1;2?? OR — both fail → else"
Test 170: "V7 1,2;3?? — AND group fails, id3 succeeds → then"
Test 171: "V8 1,2;3?? — AND group succeeds, id3 fails → then"
Test 172: "V9 1,2;3?? — all fail → else"
Test 173: "V10 1,99?? — id 99 unset → nop, chain continues"
Test 174: "V11 1;99?? — id 99 unset → nop, chain continues"
Test 175: "V12 99?? — single unset id → nop, chain continues"
Test 176: "V13 1,99;2?? — unset id in AND position → nop"
Test 177: "V14 99;1?? — unset id in first OR position → nop"
Test 178: "V15 1;99;2?? — unset id in middle OR position → nop"
Test 179: "V16 1,2;3,4,5;6?? — first group (1 AND 2) succeeds → then"
Test 180: "V17 1,2;3,4,5;6?? — middle group (3 AND 4 AND 5) succeeds → then"
Test 181: "V18 1,2;3,4,5;6?? — last operand (6) succeeds → then"
Test 182: "V19 1,2;3,4,5;6?? — all groups fail → else"
Test 183: "W1 ??! — success captured as failure → else"
Test 184: "W2 ??! — failure captured as success → then"
Test 185: "W3 ??! in AND — NOT(fail) AND success → then"
Test 186: "W4 ??! in OR — NOT(success) OR success → then"
Test 187: "W5 ??! both inverted — NOT(success) AND NOT(success) → else"
Test 188: "W6 ??! inverted the status of last command"
Test 189: "W7 ?? pass the status of last command"
Test 190: "mark: pure delete before → mark shifts"
Test 191: "mark: undo pure delete before → mark restored"
Test 192: "mark: pure delete after → mark unchanged"
Test 193: "mark: undo pure delete after → mark unchanged"
Test 194: "mark: undo pure delete at mark → mark restored"
Test 195: "mark: replacement covers mark → mark clamped"
Test 196: "mark: undo replacement covering mark → mark restored"
Test 197: "mark: replacement before → mark adjusts"
Test 198: "mark: undo replacement before → mark restored"
Test 199: "mark: replacement after → mark unchanged"
Test 200: "mark: undo replacement after → mark unchanged"
Test 201: "mark: :c lossy zone (n_ins=2,n_del=3) → mark clamped"
Test 202: "mark: undo :c lossy zone → mark restored"
Test 203: "mark: :c mark before lossy zone → mark unchanged"
Test 204: "mark: undo :c; mark was before lossy zone → still unchanged"
Test 205: "mark: :c fully steps over mark (n_ins=1,n_del=3) → mark clamped"
Test 206: "mark: undo :c fully stepping over mark → mark restored"
Test 207: "mark: :c before mark (n_ins<n_del) → mark adjusts down"
Test 208: "mark: undo :c before mark (n_ins<n_del) → mark restored"
Test 209: "mark: :c deleted row within new range (n_ins>n_del) → not invalidated"
Test 210: "mark: undo :c deleted row within new range → mark unchanged"
Test 211: "mark: :c before mark (n_ins>n_del) → mark adjusts up"
Test 212: "mark: undo :c before mark (n_ins>n_del) → mark restored"
Test 213: "X1 \/ — escaped delimiter is literal in pattern"
Test 214: "X2 \/ — escaped delimiter is literal in replacement"
Test 215: "X3 \\\\ — two backslashes become one literal backslash"
Test 216: "X4 \\t — backslash before ordinary char drops; no tab expansion"
Test 217: "X5 \\n — no newline expansion in replacement; literal n"
Test 218: "X6 \& — & is literal anyway; backslash drops"
Test 219: "X7 & — ampersand is literal, not whole-match (nextvi uses \0)"
Test 220: "X8 \. — escaped dot matches literal dot only"
Test 221: "X9 . — unescaped dot is the any-char metachar"
Test 222: "X10 \\\\ in pattern matches one literal backslash"
Test 223: "X11 \1 \2 — backreference group swap"
Test 224: "X12 \0 — backreference to the whole match"
Test 225: "X13 \1 with no such group — backslash drops; literal digit"
Test 226: "X14 , delimiter — / needs no escaping under a comma delimiter"
Test 227: "X15 \/ g — every escaped delimiter replaced"
Test 228: "X16 \/ ends pattern with no replacement section — match deleted"
Test 229: "X17 : — unescaped separator ends replacement at "a""
Test 230: "X18 \: — escaped separator stays literal in replacement"
Test 231: "X19 \\\\: — \\ collapses to one \; the bare : still separates"
Test 232: "X20 trailing \\ before separator — replacement ends in literal \"
Test 233: "X21 trailing \ escapes separator — :%p swallowed; nothing printed"
Test 234: "X22 \. with 2 groups — non-digit escape is literal, not group 2"
Test 235: "X23 \, with 4 groups — non-digit escape is literal, not group 4"
Test 236: "X24 \11 \10 with 11 groups — two-digit backreferences"
Test 237: "X25 \11 with 3 groups — stops at group 1; 1 stays literal"
Test 238: "X26 \12 \110 with 11 groups — highest existing group wins"
Test 239: "X27 \011 — leading zero never extends; whole match + literal 11"
Test 240: "X28 \\\\11 with 11 groups — escaped backslash keeps digits literal"
Test 241: "P1 ? ??p\\\:1q\:p BAD — escapes absorb :1q/:p; current line printed"
Test 242: "P2 >\\> — \\ halves to one \; search runs, no match"
Test 243: "P3 >\\\>> — \> kept literal inside delimiter; search runs, no match"
Test 244: "P4 >\\\\> — two backslashes; search runs, no match"
Test 245: "P5 >\\\\\>> — odd run keeps delimiter literal; search runs, no match"
Test 246: "P6 >\\\\\\> — three backslashes; search runs, no match"
Test 247: "P7 ? >\\\? — 3 \ then a regex "?" in the while body; no match"
Test 248: "P8 ? >\\\\? — 4 \ then a regex "?" in the while body; no match"
Test 249: "P9 ? >\\\\\? — 5 \ then a regex "?" in the while body; no match"
Test 250: "P10 ? >\\\\\\? — 6 \ then a regex "?" in the while body; no match"
Test 251: "P11 ? ?? 1?\:p — ex separator escape"
Test 252: "P12 ? ?? 1?\\:p — ex separator escape"
Test 253: ":0i inserts above first line"
Test 254: ":-1i from line 1 inserts above first line"
Test 255: ":* unknown command reported"
Test 256: ":0c errors (change needs a real line)"
Test 257: ":0pu pastes above first line"
Test 258: ":0i bootstraps empty buffer"
Test 259: ":-1i errors on empty buffer (no referent)"
Test 260: ":0! errors on non-empty buffer (no line 0)"
Test 261: ":0! fills empty buffer"
Test 262: ":-1! errors on empty buffer (no referent)"
Test 263: ":0r errors and keeps buffer"
Test 264: ":99r out-of-range errors and keeps buffer"
Test 265: ":99w out-of-range errors"
Test 266: ":0f> ranged search errors"
Test 267: ":0;pu rejects column range on line 0"
Test 268: ":0;! rejects column range on non-empty buffer"
Test 269: ":0;! rejects column range bootstrapping empty buffer"
Test 270: ":0;c rejects column range on line 0"
Test 271: ":0;i ignores column range, inserts above first line"
Test 272: ":s line range substitutes each line"
Test 273: ":s ;o1 starts the search at the column offset"
Test 274: ":s ;0 is column 0, not an absent offset"
Test 275: ":s ;o1;o2 bounds the line, keeps prefix and suffix"
Test 276: ":s ;o1;o2 window hides text outside it"
Test 277: ":s o1 bounds first line, o2 bounds last line"
Test 278: ":s ;o1 on first line only, later lines unbounded"
Test 279: ":s m flag matches across a newline"
Test 280: ":s m without g substitutes once per region"
Test 281: ":s gm substitutes every match in the region"
Test 282: ":s m with ;o1;o2 rewrites only the bounded window"
Test 283: ":s m with ;o1 spans to end of the last line"
Test 284: ":s gm with ;o1 and ;o2 bounds both ends of the region"
Test 285: ":s ;o1 past end of line matches nothing"
Test 286: ":s m substitution undone in one step"
Test 287: ":s m substitution redone in one step"
Test 288: ":s undo returns the cursor to where the command was issued"
Test 289: ":s m undo returns the cursor to where the command was issued"
Test 290: ":s redo returns the cursor to where the command was issued"
Test 291: ":s m redo returns the cursor to where the command was issued"
Test 292: ":s on a register substitutes once for the whole register"
Test 293: ":s g on a register substitutes every match"
Test 294: ":s on a register matches across a newline"
Test 295: ":s on a register leaves the buffer untouched"
Test 296: ":s on a register records no undo entry"
Test 297: ":s on a register works on an empty buffer"
Test 298: ":s rejects a range with a register"
Test 299: ":s reports an unset register"
Test 300: ":s on a register errors when nothing matches"
Test 301: ":s on a register reports no error when it matched"
Test 302: ":s digit run with trailing junk is not a register spec"
Test 303: ":s m sets '[ and '] to the region bounds"
Test 304: ":s grp keeps a skipped match between two substitutions"
Test 305: ":s grp keeps a skipped match before the first substitution"
Test 306: ":s grp keeps a skipped match after the last substitution"
Test 307: ":s grp keeps skipped matches on both sides"
Test 308: ":s grp errors when the group never participates"
Test 309: ":s gm grp keeps a skipped match inside the region"
Test 310: ":s g does not re-anchor ^ after a match"
Test 311: ":s g matches a bare ^ once per line"
Test 312: ":s g keeps an unanchored branch after ^ stops matching"
Test 313: ":s g anchors ^ at the start of each line"
Test 314: ":s gm anchors ^ at the region start only"
Test 315: ":s g still matches $ after the first search"
Test 316: ":s ^ re-anchors ^ after a match"
Test 317: ":s ^ takes a spelled out g as well"
Test 318: ":s ^ matches a bare ^ at every position"
Test 319: ":s ^ re-anchors an alternation branch too"
Test 320: ":s ^ still matches $ at the line end"
Test 321: ":s m^ re-anchors inside the region only"
Test 322: ":s ^ expands a leading tab run, leaving the interior tab"
Test 323: ":s ^ folds a leading space run into tabs"
Test 324: ":s g substitutes a zero-length match at the line end"
Test 325: ":s g reaches the line end on every line"
Test 326: ":s gm agrees with g on the line end"
Test 327: ":s g takes a zero-length match adjoining a non-empty one"
Test 328: ":s g zero-length match closing a run is its own match"
Test 329: ":s g substitutes a zero-length match on an empty line"
Test 330: ":s g bounded by o2 has no match at the window end"
Test 331: ":s m still substitutes once across the region"
Test 332: ":s g zero-length advance keeps a 2 byte character whole"
Test 333: ":s g zero-length advance keeps a 4 byte character whole"
Test 334: ":s gm zero-length advance keeps a character whole"
Test 335: ":s g zero-length advance is a byte with :uc"
Test 336: ":s grp skip advance does not land inside a character"
Test 337: ":f< zero-width advance keeps the offset on a character"
Test 338: ":f< lookahead advance keeps the offset on a character"
Test 339: ":s g does not re-fire a zero-width match found ahead"
Test 340: ":s g zero-width ahead agrees on the static path"
Test 341: ":s g forward lookahead substitutes once per position"
Test 342: ":s grp stuck advance on an empty target group moves on"
Test 343: ":s grp chains across a zero-width target group"
Test 344: ":s grp zero-width target group between real matches"
Test 345: ":fr cursor inside the range searches from the cursor"
Test 346: ":fr cursor before the range starts at the range start"
Test 347: ":fr cursor after the range starts at the range start"
Test 348: ":fr cursor left of o1 starts at the range start"
Test 349: ":fr f+ past the range end fails instead of wrapping"
Test 350: ":f< cursor below the range pins at the range end"
Test 351: ":f< cursor above the range pins at the range end"
Test 352: ":f< no column-0 match on the pin line falls through to earlier lines"
Test 353: ":f< match past column 0 on the pin line is found"
Test 354: ":f< pin line is the last buffer line"
Test 355: ":f> cursor below the range pins at the range start"
Test 356: ":f> cursor above the range pins at the range start"
Test 357: ":f> out of range searches the last line of the range"
Test 358: ":f> single-line range out of range still searches the line"
Test 359: ":f< single-line range out of range still searches the line"
Test 360: ":f< with a search register armed is rejected"
Test 361: ":m! unsets the given mark"
Test 362: ":m! leaves the marks it was not given"
Test 363: ":m! unsets every mark in the list"
Test 364: ":m! with no argument unsets the first mark"
Test 365: ":m! with no argument unsets the later marks too"
Test 366: "'[ is reachable as mark 91"
Test 367: ":m! with no argument unsets '[ and '] as well"
Test 368: ":m! an unset mark id can be set again"
Test 369: ":m! ignores a range"
Test 370: ":m! on a mark that was never set is a no-op"
Test 371: ":m! with no marks set at all is a no-op"
Test 372: "AA1 address arithmetic runs left to right (1+2*3 = 9)"
Test 373: "AA2 address arithmetic has no precedence (2*3+1 = 7)"
Test 374: "AA3 address division truncates (20/3 = 6)"
Test 375: "AA4 address modulo (20%3 = 2)"
Test 376: "AA5 $ is a term in the expression ($-5 = 15)"
Test 377: "AA6 division by zero is skipped, not fatal"
Test 378: "AA7 modulo by zero is skipped, not fatal"
Test 379: "BB1 mark as variable: assign a computed row, read it back"
Test 380: "BB2 computed assignment: v6 := v3 + 5"
Test 381: "BB3 copy one variable into another"
Test 382: "BB4 increment in place: v3 := v3 + 1"
Test 383: "CC1 v < literal detected by a negative address"
Test 384: "CC2 v >= literal leaves the address valid"
Test 385: "CC3 v1 <= v2 via range validity"
Test 386: "CC4 v2 > v1 detected by the reversed range"
Test 387: "CC5 equality = both range orders valid (AND over two ids)"
Test 388: "CC6 inequality falls out of the same id pair"
Test 389: "DD1 a computed number captured into a register and expanded back"
Test 390: "DD2 expansion assembles new command text from a register"
Test 391: "DD3 two registers compared by pasting one and matching the other"
Test 392: "DD4 unequal registers leave the substitute with no match"
Test 393: "EE1 raise v1 until it passes v2: stops one past v2"
Test 394: "EE2 min into v9 when v1 is smaller"
Test 395: "EE3 min into v9 when v2 is smaller"
Test 396: "FF1 an address subcommand moves the cursor the address then reads"
Test 397: "FF2 arithmetic applies on top of the subcommand result"
Test 398: "FF3 a failing address subcommand reports subcommand error"
Test 399: "FF4 the failed address is an ordinary status the ?? layer reads"
Test 400: "Z1 [id]?~ unsets that id; its branch no longer runs"
Test 401: "Z2 [id]?~ leaves every other id captured"
Test 402: "Z3 bare ?~ frees every capture"
Test 403: "Z4 an id unset by ?~ can be captured again"
Test 404: "Z5 ?~ on an id that was never captured is a no-op"
Test 405: "Z6 ?~ past the allocated ids is a no-op, not an error"
Test 406: "Z7 ?~<arg> keeps captures across separate chains"
Test 407: "Z8 without it captures die with the chain"
Test 408: "Z9 ?~<arg> twice restores the default wipe"
Test 409: "Z10 [id]?~<arg> unsets the id and toggles keeping"
Test 410: "Z11 bare ?~ frees captures even with keeping on"
Test 411: "Z12 ?~ inside a :g body frees the outer captures too"
Test 412: "Z13 ?~ returns success and resets the running status"
Test 413: "GG1 e on an open path keeps its unsaved changes"
Test 414: "GG2 e! on another open path rereads it"
Test 415: "GG3 e! on the current path rereads it"
Test 416: "GG4 ud after e! path restores the discarded changes"

─── Summary ──────────────────────────────────────────────────────────────────

Results: 416 passed, 0 failed
>>> nextvi: Entering fakeroot...
>>> nextvi-doc*: Running split function doc...
'usr/share/man' -> '/home/buildozer/aports/community/nextvi/pkg/nextvi-doc/usr/share/man'
'usr/share/licenses' -> '/home/buildozer/aports/community/nextvi/pkg/nextvi-doc/usr/share/licenses'
>>> nextvi-doc*: Preparing subpackage nextvi-doc...
>>> nextvi-doc*: Running postcheck for nextvi-doc
>>> nextvi-vi*: Running split function _vi...
>>> nextvi-vi*: Preparing subpackage nextvi-vi...
>>> nextvi-vi*: Stripping binaries
>>> WARNING: nextvi-vi*: No arch specific binaries found so arch should probably be set to "noarch"
>>> nextvi-vi*: Running postcheck for nextvi-vi
>>> nextvi-vi-doc*: Running split function _vi_doc...
>>> nextvi-vi-doc*: Preparing subpackage nextvi-vi-doc...
>>> nextvi-vi-doc*: Running postcheck for nextvi-vi-doc
>>> nextvi*: Running postcheck for nextvi
>>> nextvi*: Preparing package nextvi...
>>> nextvi*: Stripping binaries
>>> nextvi*: Scanning shared objects
>>> nextvi-vi*: Scanning shared objects
>>> nextvi*: Tracing dependencies...
	so:libc.musl-x86.so.1
>>> nextvi*: Package size: 174.4 KB
>>> nextvi*: Compressing data...
>>> nextvi*: Create checksum...
>>> nextvi*: Create nextvi-7.9-r0.apk
>>> nextvi-doc*: Tracing dependencies...
>>> nextvi-doc*: Package size: 16.9 KB
>>> nextvi-doc*: Compressing data...
>>> nextvi-doc*: Create checksum...
>>> nextvi-doc*: Create nextvi-doc-7.9-r0.apk
>>> nextvi-vi*: Tracing dependencies...
	nextvi=7.9-r0
	nextvi=7.9-r0
>>> nextvi-vi*: Package size: 1.0 B
>>> nextvi-vi*: Compressing data...
>>> nextvi-vi*: Create checksum...
>>> nextvi-vi*: Create nextvi-vi-7.9-r0.apk
>>> nextvi-vi-doc*: Tracing dependencies...
	nextvi-doc=7.9-r0
	nextvi-doc=7.9-r0
>>> nextvi-vi-doc*: Package size: 1.0 B
>>> nextvi-vi-doc*: Compressing data...
>>> nextvi-vi-doc*: Create checksum...
>>> nextvi-vi-doc*: Create nextvi-vi-doc-7.9-r0.apk
>>> nextvi: Build complete at Thu, 22 Oct 2026 17:00:52 +0000 elapsed time 0h 0m 10s
>>> nextvi: Cleaning up srcdir
>>> nextvi: Cleaning up pkgdir
>>> nextvi: Cleaning up tmpdir
>>> nextvi: Uninstalling dependencies...
(1/1) Purging .makedepends-nextvi (20261022.170042)
OK: 427.4 MiB in 105 packages
>>> nextvi: Updating the community/x86 repository index...
>>> nextvi: Signing the index...