akkartik/pong.love - Change WB66TPZSJ6SPPZKQVDON56URAO3XPKSY7CE5WKDSE4S36U2ZE6PAC

Merge text.love

Created by Kartik K. Agaram on May 13, 2023

WB66TPZSJ6SPPZKQVDON56URAO3XPKSY7CE5WKDSE4S36U2ZE6PAC

Dependencies

In channels

main

Change contents

Replacement in text_tests.lua at line 1861 [6.2]

B:BD[5.79768] → [5.79768:79830]

  Editor_state.lines = load_array{'abc', 'def', 'ghi', 'deg'}

[5.79768]

[5.79830]

  Editor_state.lines = load_array{'abc', 'def', 'ghi', '’deg'}  -- contains unicode quote in final line

Replacement in text_tests.lua at line 1882 [6.2]

B:BD[5.80681] → [5.80681:80737]

  check_eq(Editor_state.cursor1.pos, 1, '2/cursor:pos')

[5.80681]

[5.80737]

  check_eq(Editor_state.cursor1.pos, 2, '2/cursor:pos')

Replacement in text_tests.lua at line 1888 [6.2]

B:BD[5.80859] → [5.80859:80904]

  Editor_state.lines = load_array{'abc abd'}

[5.80859]

[5.80904]

  Editor_state.lines = load_array{'’abc', 'abd'}  -- contains unicode quote

Replacement in text_tests.lua at line 1890 [6.2]
B:BD[5.80936] → [5.80936:80977]
```
  Editor_state.cursor1 = {line=1, pos=2}
```
[5.80936]
[5.80977]
```
  Editor_state.cursor1 = {line=2, pos=1}
```

Replacement in text_tests.lua at line 1900 [6.2]

B:BD[5.81342] → [5.81342:81398]

  check_eq(Editor_state.cursor1.pos, 1, '2/cursor:pos')

[5.81342]

[5.81398]

  check_eq(Editor_state.cursor1.pos, 2, '2/cursor:pos')

Replacement in text_tests.lua at line 1906 [6.2]

B:BD[5.81517] → [5.81517:81558]

  Editor_state.lines = load_array{'abc'}

[5.81517]

[5.81558]

  Editor_state.lines = load_array{'’abc', 'def'}  -- contains unicode quote in first line

Replacement in text_tests.lua at line 1908 [6.2]
B:BD[5.81590] → [5.81590:81631]
```
  Editor_state.cursor1 = {line=1, pos=3}
```
[5.81590]
[5.81631]
```
  Editor_state.cursor1 = {line=2, pos=1}
```

Replacement in text_tests.lua at line 1918 [6.2]

B:BD[5.81982] → [5.81982:82038]

  check_eq(Editor_state.cursor1.pos, 1, '1/cursor:pos')

[5.81982]

[5.82038]

  check_eq(Editor_state.cursor1.pos, 2, '1/cursor:pos')

Replacement in text_tests.lua at line 1924 [6.2]

B:BD[5.82165] → [5.82165:82210]

  Editor_state.lines = load_array{'abc abd'}

[5.82165]

[5.82210]

  Editor_state.lines = load_array{'abc ’abd'}  -- contains unicode quote

Replacement in text_tests.lua at line 1936 [6.2]

B:BD[5.82638] → [5.82638:82694]

  check_eq(Editor_state.cursor1.pos, 5, '1/cursor:pos')

[5.82638]

[5.82694]

  check_eq(Editor_state.cursor1.pos, 6, '1/cursor:pos')

Deletion in text_tests.lua at line 1938 [6.2]
B:BD[7.22894] → [8.121:177]
BD:BD[7.22894] → [8.121:177]
BD:BD[7.22894] → [8.121:177]
B:BD[11.155] → [8.178:256]
BD:BD[11.155] → [8.178:256]
B:BD[11.232] → [8.257:298]
BD:BD[11.232] → [8.257:298]
B:BD[7.23009] → [8.299:355]
BD:BD[7.23009] → [8.299:355]
BD:BD[7.23009] → [8.299:355]
B:BD[12.150] → [8.356:448]
BD:BD[12.150] → [8.356:448]
B:BD[12.223] → [8.449:490]
BD:BD[12.223] → [8.449:490]
B:BD[7.23124] → [8.491:547]
BD:BD[7.23124] → [8.491:547]
BD:BD[7.23124] → [8.491:547]
B:BD[13.166] → [8.548:623]
BD:BD[13.166] → [8.548:623]
B:BD[7.23239] → [8.624:680]
BD:BD[7.23239] → [8.624:680]
BD:BD[7.23239] → [8.624:680]
B:BD[14.140] → [4.2:108]
BD:BD[14.140] → [4.2:108]
```
  check_eq(Editor_state.cursor1.pos, 2, '2/cursor:pos')
  Editor_state.lines = load_array{'’abc', 'abd'}  -- contains unicode quote
  Editor_state.cursor1 = {line=2, pos=1}
  check_eq(Editor_state.cursor1.pos, 2, '2/cursor:pos')
  Editor_state.lines = load_array{'’abc', 'def'}  -- contains unicode quote in first line
  Editor_state.cursor1 = {line=2, pos=1}
  check_eq(Editor_state.cursor1.pos, 2, '1/cursor:pos')
  Editor_state.lines = load_array{'abc ’abd'}  -- contains unicode quote
  check_eq(Editor_state.cursor1.pos, 6, '1/cursor:pos')
  Editor_state.lines = load_array{'abc', 'def', 'ghi', '’deg'}  -- contains unicode quote in final line
```
Solving an order conflict in text_tests.lua at line 1938 [6.2]
[5.82698]

Resurrecting zombie bytes in source_text_tests.lua at line 953 [15.3561]

∅:∅[10.7235] → [9.34082:34156]

B:B[16.3806] → [9.34082:34156]

BD:B[16.3806] → [9.34082:34156]

BD:B[10.7235] → [9.34082:34156]

B:B[9.34230] → [9.34230:34695]

BD:B[9.34230] → [9.34230:34695]

end
function test_pagedown_can_start_from_middle_of_long_wrapping_line()
  -- draw a few lines starting from a very long wrapping line
  App.screen.init{width=Editor_state.left+30, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc def ghi jkl mno pqr stu vwx yza bcd efg hij', 'XYZ'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=1, pos=2}
  Editor_state.screen_top1 = {line=1, pos=1}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  local y = Editor_state.top

Resurrecting zombie bytes in source_text_tests.lua at line 967 [15.3561]
∅:∅[10.7287] → [9.34808:34843]
B:B[9.34808] → [9.34808:34843]
BD:B[9.34808] → [9.34808:34843]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 969 [15.3561]
∅:∅[10.7339] → [9.34956:34991]
B:B[9.34956] → [9.34956:34991]
BD:B[9.34956] → [9.34956:34991]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 971 [15.3561]
∅:∅[10.7391] → [9.35104:35219]
B:B[9.35104] → [9.35104:35219]
BD:B[9.35104] → [9.35104:35219]
```
  -- after pagedown we scroll down the very long wrapping line
  edit.run_after_keychord(Editor_state, 'pagedown')
```
Resurrecting zombie bytes in source_text_tests.lua at line 975 [15.3561]
∅:∅[10.7518] → [9.35469:35492]
B:B[9.35469] → [9.35469:35492]
BD:B[9.35469] → [9.35469:35492]
```
  y = Editor_state.top
```
Resurrecting zombie bytes in source_text_tests.lua at line 977 [15.3561]
∅:∅[10.7561] → [9.35596:35631]
B:B[9.35596] → [9.35596:35631]
BD:B[9.35596] → [9.35596:35631]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 979 [15.3561]
∅:∅[10.7604] → [9.35735:35770]
B:B[9.35735] → [9.35735:35770]
BD:B[9.35735] → [9.35735:35770]
```
  y = y + Editor_state.line_height
```

Resurrecting zombie bytes in source_text_tests.lua at line 981 [15.3561]

∅:∅[3.151] → [9.35874:35919]

∅:∅[10.7647] → [9.35874:35919]

B:B[9.35874] → [9.35874:35919]

BD:B[9.35874] → [9.35874:35919]

B:B[9.35964] → [9.35964:36428]

BD:B[9.35964] → [9.35964:36428]

end
function test_pagedown_never_moves_up()
  -- draw the final screen line of a wrapping line
  App.screen.init{width=Editor_state.left+30, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc def ghi'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=1, pos=9}
  Editor_state.screen_top1 = {line=1, pos=9}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  -- pagedown makes no change
  edit.run_after_keychord(Editor_state, 'pagedown')

Resurrecting zombie bytes in source_text_tests.lua at line 997 [15.3561]

∅:∅[10.7774] → [9.36620:36665]

B:B[9.36620] → [9.36620:36665]

BD:B[9.36620] → [9.36620:36665]

B:B[9.36710] → [9.36710:37117]

BD:B[9.36710] → [9.36710:37117]

end
function test_down_arrow_moves_cursor()
  App.screen.init{width=120, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'ghi', 'jkl'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=1, pos=1}
  Editor_state.screen_top1 = {line=1, pos=1}
  Editor_state.screen_bottom1 = {}
  -- initially the first three lines are displayed
  edit.draw(Editor_state)
  local y = Editor_state.top

Resurrecting zombie bytes in source_text_tests.lua at line 1011 [15.3561]
∅:∅[10.7825] → [9.37200:37235]
B:B[9.37200] → [9.37200:37235]
BD:B[9.37200] → [9.37200:37235]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1013 [15.3561]
∅:∅[10.7876] → [9.37318:37353]
B:B[9.37318] → [9.37318:37353]
BD:B[9.37318] → [9.37318:37353]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1015 [15.3561]
∅:∅[10.7927] → [9.37436:37551]
B:B[9.37436] → [9.37436:37551]
BD:B[9.37436] → [9.37436:37551]
```
  -- after hitting the down arrow, the cursor moves down by 1 line
  edit.run_after_keychord(Editor_state, 'down')
```
Resurrecting zombie bytes in source_text_tests.lua at line 1019 [15.3561]
∅:∅[10.8038] → [9.37727:37779]
B:B[9.37727] → [9.37727:37779]
BD:B[9.37727] → [9.37727:37779]
```
  -- the screen is unchanged
  y = Editor_state.top
```
Resurrecting zombie bytes in source_text_tests.lua at line 1022 [15.3561]
∅:∅[10.8080] → [9.37853:37888]
B:B[9.37853] → [9.37853:37888]
BD:B[9.37853] → [9.37853:37888]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1024 [15.3561]
∅:∅[10.8122] → [9.37962:37997]
B:B[9.37962] → [9.37962:37997]
BD:B[9.37962] → [9.37962:37997]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1026 [15.3561]
∅:∅[10.8164] → [9.38071:38076]
B:B[9.38071] → [9.38071:38076]
BD:B[9.38071] → [9.38071:38076]
```
end
```

Resurrecting zombie bytes in source_text_tests.lua at line 1053 [15.3561]

∅:∅[17.1104] → [9.38076:38128]

B:B[9.38076] → [9.38076:38128]

BD:B[9.38076] → [9.38076:38128]

B:B[9.38185] → [9.38185:38611]

BD:B[9.38185] → [9.38185:38611]

function test_down_arrow_scrolls_down_by_one_line()
  -- display the first three lines with the cursor on the bottom line
  App.screen.init{width=120, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'ghi', 'jkl'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=3, pos=1}
  Editor_state.screen_top1 = {line=1, pos=1}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  local y = Editor_state.top

Resurrecting zombie bytes in source_text_tests.lua at line 1065 [15.3561]
∅:∅[10.8215] → [9.38706:38741]
B:B[9.38706] → [9.38706:38741]
BD:B[9.38706] → [9.38706:38741]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1067 [15.3561]
∅:∅[10.8266] → [9.38836:38871]
B:B[9.38836] → [9.38836:38871]
BD:B[9.38836] → [9.38836:38871]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1069 [15.3561]
∅:∅[10.8317] → [9.38966:39084]
B:B[9.38966] → [9.38966:39084]
BD:B[9.38966] → [9.38966:39084]
```
  -- after hitting the down arrow the screen scrolls down by one line
  edit.run_after_keychord(Editor_state, 'down')
```
Resurrecting zombie bytes in source_text_tests.lua at line 1073 [15.3561]
∅:∅[10.8428] → [9.39284:39307]
B:B[9.39284] → [9.39284:39307]
BD:B[9.39284] → [9.39284:39307]
```
  y = Editor_state.top
```
Resurrecting zombie bytes in source_text_tests.lua at line 1075 [15.3561]
∅:∅[10.8470] → [9.39393:39428]
B:B[9.39393] → [9.39393:39428]
BD:B[9.39393] → [9.39393:39428]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1077 [15.3561]
∅:∅[10.8512] → [9.39514:39549]
B:B[9.39514] → [9.39514:39549]
BD:B[9.39514] → [9.39514:39549]
```
  y = y + Editor_state.line_height
```

Resurrecting zombie bytes in source_text_tests.lua at line 1079 [15.3561]

∅:∅[10.8554] → [9.39635:39699]

B:B[9.39635] → [9.39635:39699]

BD:B[9.39635] → [9.39635:39699]

B:B[9.39763] → [9.39763:40210]

BD:B[9.39763] → [9.39763:40210]

end
function test_down_arrow_scrolls_down_by_one_screen_line()
  -- display the first three lines with the cursor on the bottom line
  App.screen.init{width=Editor_state.left+30, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'ghi jkl', 'mno'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=3, pos=1}
  Editor_state.screen_top1 = {line=1, pos=1}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  local y = Editor_state.top

Resurrecting zombie bytes in source_text_tests.lua at line 1093 [15.3561]
∅:∅[10.8605] → [9.40312:40347]
B:B[9.40312] → [9.40312:40347]
BD:B[9.40312] → [9.40312:40347]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1095 [15.3561]
∅:∅[10.8656] → [9.40449:40484]
B:B[9.40449] → [9.40449:40484]
BD:B[9.40449] → [9.40449:40484]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1097 [15.3561]
∅:∅[10.8755] → [9.40634:40752]
B:B[9.40634] → [9.40634:40752]
BD:B[9.40634] → [9.40634:40752]
```
  -- after hitting the down arrow the screen scrolls down by one line
  edit.run_after_keychord(Editor_state, 'down')
```
Resurrecting zombie bytes in source_text_tests.lua at line 1102 [15.3561]
∅:∅[10.8925] → [9.41077:41100]
B:B[9.41077] → [9.41077:41100]
BD:B[9.41077] → [9.41077:41100]
```
  y = Editor_state.top
```
Resurrecting zombie bytes in source_text_tests.lua at line 1104 [15.3561]
∅:∅[10.8967] → [9.41193:41228]
B:B[9.41193] → [9.41193:41228]
BD:B[9.41193] → [9.41193:41228]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1106 [15.3561]
∅:∅[10.9010] → [9.41322:41357]
B:B[9.41322] → [9.41322:41357]
BD:B[9.41322] → [9.41322:41357]
```
  y = y + Editor_state.line_height
```

Resurrecting zombie bytes in source_text_tests.lua at line 1108 [15.3561]

∅:∅[10.9052] → [9.41450:41542]

B:B[9.41450] → [9.41450:41542]

BD:B[9.41450] → [9.41450:41542]

B:B[9.41634] → [9.41634:42080]

BD:B[9.41634] → [9.41634:42080]

end
function test_down_arrow_scrolls_down_by_one_screen_line_after_splitting_within_word()
  -- display the first three lines with the cursor on the bottom line
  App.screen.init{width=Editor_state.left+30, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'ghijkl', 'mno'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=3, pos=1}
  Editor_state.screen_top1 = {line=1, pos=1}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  local y = Editor_state.top

Resurrecting zombie bytes in source_text_tests.lua at line 1122 [15.3561]
∅:∅[10.9103] → [9.42210:42245]
B:B[9.42210] → [9.42210:42245]
BD:B[9.42210] → [9.42210:42245]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1124 [15.3561]
∅:∅[10.9154] → [9.42375:42410]
B:B[9.42375] → [9.42375:42410]
BD:B[9.42375] → [9.42375:42410]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1126 [15.3561]
∅:∅[10.9206] → [9.42541:42659]
B:B[9.42541] → [9.42541:42659]
BD:B[9.42541] → [9.42541:42659]
```
  -- after hitting the down arrow the screen scrolls down by one line
  edit.run_after_keychord(Editor_state, 'down')
```
Resurrecting zombie bytes in source_text_tests.lua at line 1131 [15.3561]
∅:∅[10.9376] → [9.43068:43091]
B:B[9.43068] → [9.43068:43091]
BD:B[9.43068] → [9.43068:43091]
```
  y = Editor_state.top
```
Resurrecting zombie bytes in source_text_tests.lua at line 1133 [15.3561]
∅:∅[10.9418] → [9.43212:43247]
B:B[9.43212] → [9.43212:43247]
BD:B[9.43212] → [9.43212:43247]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1135 [15.3561]
∅:∅[10.9461] → [9.43369:43404]
B:B[9.43369] → [9.43369:43404]
BD:B[9.43369] → [9.43369:43404]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1137 [15.3561]
∅:∅[10.9502] → [9.43524:43529]
B:B[9.43524] → [9.43524:43529]
BD:B[9.43524] → [9.43524:43529]
```
end
```

Resurrecting zombie bytes in source_text_tests.lua at line 1140 [15.3561]

∅:∅[18.3236] → [9.43684:44060]

B:B[9.43684] → [9.43684:44060]

BD:B[9.43684] → [9.43684:44060]

  App.screen.init{width=Editor_state.left+30, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'ghijkl', 'mno'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=3, pos=1}
  Editor_state.screen_top1 = {line=1, pos=1}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  local y = Editor_state.top

Resurrecting zombie bytes in source_text_tests.lua at line 1150 [15.3561]
∅:∅[18.3354] → [9.44178:44213]
∅:∅[10.9553] → [9.44178:44213]
B:B[9.44178] → [9.44178:44213]
BD:B[9.44178] → [9.44178:44213]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1152 [15.3561]
∅:∅[18.3472] → [9.44331:44366]
∅:∅[10.9604] → [9.44331:44366]
B:B[9.44331] → [9.44331:44366]
BD:B[9.44331] → [9.44331:44366]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1154 [15.3561]
∅:∅[18.3591] → [9.44485:44613]
∅:∅[10.9656] → [9.44485:44613]
B:B[9.44485] → [9.44485:44613]
BD:B[9.44485] → [9.44485:44613]
```
  -- after hitting pagedown the screen scrolls down to start of a long line
  edit.run_after_keychord(Editor_state, 'pagedown')
```
Resurrecting zombie bytes in source_text_tests.lua at line 1159 [15.3561]
∅:∅[18.3992] → [9.45016:45166]
∅:∅[10.9856] → [9.45016:45166]
B:B[9.45016] → [9.45016:45166]
BD:B[9.45016] → [9.45016:45166]
```
  -- after hitting down arrow the screen doesn't scroll down further, and certainly doesn't scroll up
  edit.run_after_keychord(Editor_state, 'down')
```
Resurrecting zombie bytes in source_text_tests.lua at line 1164 [15.3561]
∅:∅[18.4363] → [9.45539:45562]
∅:∅[10.10026] → [9.45539:45562]
B:B[9.45539] → [9.45539:45562]
BD:B[9.45539] → [9.45539:45562]
```
  y = Editor_state.top
```
Resurrecting zombie bytes in source_text_tests.lua at line 1166 [15.3561]
∅:∅[18.4473] → [9.45672:45707]
∅:∅[10.10069] → [9.45672:45707]
B:B[9.45672] → [9.45672:45707]
BD:B[9.45672] → [9.45672:45707]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1168 [15.3561]
∅:∅[18.4581] → [9.45815:45850]
∅:∅[10.10110] → [9.45815:45850]
B:B[9.45815] → [9.45815:45850]
BD:B[9.45815] → [9.45815:45850]
```
  y = y + Editor_state.line_height
```

Resurrecting zombie bytes in source_text_tests.lua at line 1170 [15.3561]

∅:∅[18.4690] → [9.45959:46002]

∅:∅[10.10152] → [9.45959:46002]

B:B[9.45959] → [9.45959:46002]

BD:B[9.45959] → [9.45959:46002]

B:B[9.46045] → [9.46045:46467]

BD:B[9.46045] → [9.46045:46467]

end
function test_up_arrow_moves_cursor()
  -- display the first 3 lines with the cursor on the bottom line
  App.screen.init{width=120, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'ghi', 'jkl'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=3, pos=1}
  Editor_state.screen_top1 = {line=1, pos=1}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  local y = Editor_state.top

Resurrecting zombie bytes in source_text_tests.lua at line 1184 [15.3561]
∅:∅[10.10203] → [9.46548:46583]
B:B[9.46548] → [9.46548:46583]
BD:B[9.46548] → [9.46548:46583]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1186 [15.3561]
∅:∅[10.10254] → [9.46664:46699]
B:B[9.46664] → [9.46664:46699]
BD:B[9.46664] → [9.46664:46699]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1188 [15.3561]
∅:∅[10.10305] → [9.46780:46888]
B:B[9.46780] → [9.46780:46888]
BD:B[9.46780] → [9.46780:46888]
```
  -- after hitting the up arrow the cursor moves up by 1 line
  edit.run_after_keychord(Editor_state, 'up')
```
Resurrecting zombie bytes in source_text_tests.lua at line 1192 [15.3561]
∅:∅[10.10416] → [9.47060:47112]
B:B[9.47060] → [9.47060:47112]
BD:B[9.47060] → [9.47060:47112]
```
  -- the screen is unchanged
  y = Editor_state.top
```
Resurrecting zombie bytes in source_text_tests.lua at line 1195 [15.3561]
∅:∅[10.10458] → [9.47184:47219]
B:B[9.47184] → [9.47184:47219]
BD:B[9.47184] → [9.47184:47219]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1197 [15.3561]
∅:∅[10.10500] → [9.47291:47326]
B:B[9.47291] → [9.47291:47326]
BD:B[9.47291] → [9.47291:47326]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1199 [15.3561]
∅:∅[10.10542] → [9.47398:47403]
B:B[9.47398] → [9.47398:47403]
BD:B[9.47398] → [9.47398:47403]
```
end
```

Resurrecting zombie bytes in source_text_tests.lua at line 1226 [15.3561]

∅:∅[17.2198] → [9.47403:47451]

B:B[9.47403] → [9.47403:47451]

BD:B[9.47403] → [9.47403:47451]

B:B[9.47504] → [9.47504:47915]

BD:B[9.47504] → [9.47504:47915]

function test_up_arrow_scrolls_up_by_one_line()
  -- display the lines 2/3/4 with the cursor on line 2
  App.screen.init{width=120, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'ghi', 'jkl'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=2, pos=1}
  Editor_state.screen_top1 = {line=2, pos=1}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  local y = Editor_state.top

Resurrecting zombie bytes in source_text_tests.lua at line 1238 [15.3561]
∅:∅[10.10593] → [9.48006:48041]
B:B[9.48006] → [9.48006:48041]
BD:B[9.48006] → [9.48006:48041]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1240 [15.3561]
∅:∅[10.10644] → [9.48132:48167]
B:B[9.48132] → [9.48132:48167]
BD:B[9.48132] → [9.48132:48167]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1242 [15.3561]
∅:∅[10.10695] → [9.48258:48370]
B:B[9.48258] → [9.48258:48370]
BD:B[9.48258] → [9.48258:48370]
```
  -- after hitting the up arrow the screen scrolls up by one line
  edit.run_after_keychord(Editor_state, 'up')
```
Resurrecting zombie bytes in source_text_tests.lua at line 1246 [15.3561]
∅:∅[10.10806] → [9.48562:48585]
B:B[9.48562] → [9.48562:48585]
BD:B[9.48562] → [9.48562:48585]
```
  y = Editor_state.top
```
Resurrecting zombie bytes in source_text_tests.lua at line 1248 [15.3561]
∅:∅[10.10848] → [9.48667:48702]
B:B[9.48667] → [9.48667:48702]
BD:B[9.48667] → [9.48667:48702]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1250 [15.3561]
∅:∅[10.10890] → [9.48784:48819]
B:B[9.48784] → [9.48784:48819]
BD:B[9.48784] → [9.48784:48819]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1252 [15.3561]
∅:∅[10.10932] → [9.48901:48906]
B:B[9.48901] → [9.48901:48906]
BD:B[9.48901] → [9.48901:48906]
```
end
```

Resurrecting zombie bytes in source_text_tests.lua at line 1276 [15.3561]

∅:∅[19.966] → [9.48906:48961]

B:B[9.48906] → [9.48906:48961]

BD:B[9.48906] → [9.48906:48961]

B:B[9.49021] → [9.49021:49460]

BD:B[9.49021] → [9.49021:49460]

function test_up_arrow_scrolls_up_by_one_screen_line()
  -- display lines starting from second screen line of a line
  App.screen.init{width=Editor_state.left+30, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'ghi jkl', 'mno'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=3, pos=6}
  Editor_state.screen_top1 = {line=3, pos=5}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  local y = Editor_state.top

Resurrecting zombie bytes in source_text_tests.lua at line 1288 [15.3561]
∅:∅[10.10983] → [9.49558:49593]
B:B[9.49558] → [9.49558:49593]
BD:B[9.49558] → [9.49558:49593]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1290 [15.3561]
∅:∅[10.11034] → [9.49691:49835]
B:B[9.49691] → [9.49691:49835]
BD:B[9.49691] → [9.49691:49835]
```
  -- after hitting the up arrow the screen scrolls up to first screen line
  edit.run_after_keychord(Editor_state, 'up')
  y = Editor_state.top
```
Resurrecting zombie bytes in source_text_tests.lua at line 1294 [15.3561]
∅:∅[10.11077] → [9.49925:49960]
B:B[9.49925] → [9.49925:49960]
BD:B[9.49925] → [9.49925:49960]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1296 [15.3561]
∅:∅[10.11119] → [9.50049:50084]
B:B[9.50049] → [9.50049:50084]
BD:B[9.50049] → [9.50049:50084]
```
  y = y + Editor_state.line_height
```

Resurrecting zombie bytes in source_text_tests.lua at line 1302 [15.3561]

∅:∅[10.11397] → [9.50592:50654]

B:B[9.50592] → [9.50592:50654]

BD:B[9.50592] → [9.50592:50654]

B:B[9.50716] → [9.50716:51144]

BD:B[9.50716] → [9.50716:51144]

end
function test_up_arrow_scrolls_up_to_final_screen_line()
  -- display lines starting just after a long line
  App.screen.init{width=Editor_state.left+30, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc def', 'ghi', 'jkl', 'mno'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=2, pos=1}
  Editor_state.screen_top1 = {line=2, pos=1}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  local y = Editor_state.top

Resurrecting zombie bytes in source_text_tests.lua at line 1316 [15.3561]
∅:∅[10.11448] → [9.51244:51279]
B:B[9.51244] → [9.51244:51279]
BD:B[9.51244] → [9.51244:51279]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1318 [15.3561]
∅:∅[10.11499] → [9.51379:51414]
B:B[9.51379] → [9.51379:51414]
BD:B[9.51379] → [9.51379:51414]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1320 [15.3561]
∅:∅[10.11550] → [9.51514:51675]
B:B[9.51514] → [9.51514:51675]
BD:B[9.51514] → [9.51514:51675]
```
  -- after hitting the up arrow the screen scrolls up to final screen line of previous line
  edit.run_after_keychord(Editor_state, 'up')
  y = Editor_state.top
```
Resurrecting zombie bytes in source_text_tests.lua at line 1324 [15.3561]
∅:∅[10.11592] → [9.51766:51801]
B:B[9.51766] → [9.51766:51801]
BD:B[9.51766] → [9.51766:51801]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1326 [15.3561]
∅:∅[10.11634] → [9.51892:51927]
B:B[9.51892] → [9.51892:51927]
BD:B[9.51892] → [9.51892:51927]
```
  y = y + Editor_state.line_height
```

Resurrecting zombie bytes in source_text_tests.lua at line 1332 [15.3561]

∅:∅[10.11912] → [9.52445:52500]

B:B[9.52445] → [9.52445:52500]

BD:B[9.52445] → [9.52445:52500]

B:B[9.52555] → [9.52555:53000]

BD:B[9.52555] → [9.52555:53000]

end
function test_up_arrow_scrolls_up_to_empty_line()
  -- display a screenful of text with an empty line just above it outside the screen
  App.screen.init{width=120, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'', 'abc', 'def', 'ghi', 'jkl'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=2, pos=1}
  Editor_state.screen_top1 = {line=2, pos=1}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  local y = Editor_state.top

Resurrecting zombie bytes in source_text_tests.lua at line 1346 [15.3561]
∅:∅[10.11963] → [9.53093:53128]
B:B[9.53093] → [9.53093:53128]
BD:B[9.53093] → [9.53093:53128]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1348 [15.3561]
∅:∅[10.12014] → [9.53221:53256]
B:B[9.53221] → [9.53221:53256]
BD:B[9.53221] → [9.53221:53256]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1350 [15.3561]
∅:∅[10.12065] → [9.53349:53461]
B:B[9.53349] → [9.53349:53461]
BD:B[9.53349] → [9.53349:53461]
```
  -- after hitting the up arrow the screen scrolls up by one line
  edit.run_after_keychord(Editor_state, 'up')
```
Resurrecting zombie bytes in source_text_tests.lua at line 1354 [15.3561]
∅:∅[10.12176] → [9.53657:53737]
B:B[9.53657] → [9.53657:53737]
BD:B[9.53657] → [9.53657:53737]
```
  y = Editor_state.top
  -- empty first line
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1358 [15.3561]
∅:∅[10.12218] → [9.53821:53856]
B:B[9.53821] → [9.53821:53856]
BD:B[9.53821] → [9.53821:53856]
```
  y = y + Editor_state.line_height
```

Resurrecting zombie bytes in source_text_tests.lua at line 1360 [15.3561]

∅:∅[10.12260] → [9.53940:53968]

B:B[9.53940] → [9.53940:53968]

BD:B[9.53940] → [9.53940:53968]

B:B[9.53996] → [9.53996:54393]

BD:B[9.53996] → [9.53996:54393]

end
function test_pageup()
  App.screen.init{width=120, height=45}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'ghi'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=2, pos=1}
  Editor_state.screen_top1 = {line=2, pos=1}
  Editor_state.screen_bottom1 = {}
  -- initially the last two lines are displayed
  edit.draw(Editor_state)
  local y = Editor_state.top

Resurrecting zombie bytes in source_text_tests.lua at line 1374 [15.3561]
∅:∅[10.12311] → [9.54459:54494]
B:B[9.54459] → [9.54459:54494]
BD:B[9.54459] → [9.54459:54494]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1376 [15.3561]
∅:∅[10.12362] → [9.54560:54658]
B:B[9.54560] → [9.54560:54658]
BD:B[9.54560] → [9.54560:54658]
```
  -- after pageup the cursor goes to first line
  edit.run_after_keychord(Editor_state, 'pageup')
```
Resurrecting zombie bytes in source_text_tests.lua at line 1380 [15.3561]
∅:∅[10.12473] → [9.54800:54823]
B:B[9.54800] → [9.54800:54823]
BD:B[9.54800] → [9.54800:54823]
```
  y = Editor_state.top
```
Resurrecting zombie bytes in source_text_tests.lua at line 1382 [15.3561]
∅:∅[10.12515] → [9.54880:54915]
B:B[9.54880] → [9.54880:54915]
BD:B[9.54880] → [9.54880:54915]
```
  y = y + Editor_state.line_height
```

Resurrecting zombie bytes in source_text_tests.lua at line 1384 [15.3561]

∅:∅[10.12557] → [9.54972:55026]

B:B[9.54972] → [9.54972:55026]

BD:B[9.54972] → [9.54972:55026]

B:B[9.55080] → [9.55080:55527]

BD:B[9.55080] → [9.55080:55527]

end
function test_pageup_scrolls_up_by_screen_line()
  -- display the first three lines with the cursor on the bottom line
  App.screen.init{width=Editor_state.left+30, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc def', 'ghi', 'jkl', 'mno'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=2, pos=1}
  Editor_state.screen_top1 = {line=2, pos=1}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  local y = Editor_state.top

Resurrecting zombie bytes in source_text_tests.lua at line 1398 [15.3561]
∅:∅[10.12608] → [9.55619:55654]
B:B[9.55619] → [9.55619:55654]
BD:B[9.55619] → [9.55619:55654]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1400 [15.3561]
∅:∅[10.12659] → [9.55746:55781]
B:B[9.55746] → [9.55746:55781]
BD:B[9.55746] → [9.55746:55781]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1402 [15.3561]
∅:∅[10.12757] → [9.55920:56034]
B:B[9.55920] → [9.55920:56034]
BD:B[9.55920] → [9.55920:56034]
```
  -- after hitting the page-up key the screen scrolls up to top
  edit.run_after_keychord(Editor_state, 'pageup')
```
Resurrecting zombie bytes in source_text_tests.lua at line 1407 [15.3561]
∅:∅[10.12927] → [9.56329:56352]
B:B[9.56329] → [9.56329:56352]
BD:B[9.56329] → [9.56329:56352]
```
  y = Editor_state.top
```
Resurrecting zombie bytes in source_text_tests.lua at line 1409 [15.3561]
∅:∅[10.12970] → [9.56436:56471]
B:B[9.56436] → [9.56436:56471]
BD:B[9.56436] → [9.56436:56471]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1411 [15.3561]
∅:∅[10.13012] → [9.56554:56589]
B:B[9.56554] → [9.56554:56589]
BD:B[9.56554] → [9.56554:56589]
```
  y = y + Editor_state.line_height
```

Resurrecting zombie bytes in source_text_tests.lua at line 1413 [15.3561]

∅:∅[10.13054] → [9.56672:56735]

B:B[9.56672] → [9.56672:56735]

BD:B[9.56672] → [9.56672:56735]

B:B[9.56798] → [9.56798:57263]

BD:B[9.56798] → [9.56798:57263]

end
function test_pageup_scrolls_up_from_middle_screen_line()
  -- display a few lines starting from the middle of a line (Editor_state.cursor1.pos > 1)
  App.screen.init{width=Editor_state.left+30, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc def', 'ghi jkl', 'mno'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=2, pos=5}
  Editor_state.screen_top1 = {line=2, pos=5}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  local y = Editor_state.top

Resurrecting zombie bytes in source_text_tests.lua at line 1427 [15.3561]
∅:∅[10.13105] → [9.57364:57399]
B:B[9.57364] → [9.57364:57399]
BD:B[9.57364] → [9.57364:57399]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1429 [15.3561]
∅:∅[10.13203] → [9.57547:57661]
B:B[9.57547] → [9.57547:57661]
BD:B[9.57547] → [9.57547:57661]
```
  -- after hitting the page-up key the screen scrolls up to top
  edit.run_after_keychord(Editor_state, 'pageup')
```
Resurrecting zombie bytes in source_text_tests.lua at line 1434 [15.3561]
∅:∅[10.13373] → [9.57983:58006]
B:B[9.57983] → [9.57983:58006]
BD:B[9.57983] → [9.57983:58006]
```
  y = Editor_state.top
```
Resurrecting zombie bytes in source_text_tests.lua at line 1436 [15.3561]
∅:∅[10.13416] → [9.58099:58134]
B:B[9.58099] → [9.58099:58134]
BD:B[9.58099] → [9.58099:58134]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1438 [15.3561]
∅:∅[10.13458] → [9.58226:58261]
B:B[9.58226] → [9.58226:58261]
BD:B[9.58226] → [9.58226:58261]
```
  y = y + Editor_state.line_height
```

Resurrecting zombie bytes in source_text_tests.lua at line 1440 [15.3561]

∅:∅[10.13501] → [9.58354:58409]

B:B[9.58354] → [9.58354:58409]

BD:B[9.58354] → [9.58354:58409]

B:B[9.58464] → [9.58464:58889]

BD:B[9.58464] → [9.58464:58889]

end
function test_enter_on_bottom_line_scrolls_down()
  -- display a few lines with cursor on bottom line
  App.screen.init{width=Editor_state.left+30, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'ghi', 'jkl'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=3, pos=2}
  Editor_state.screen_top1 = {line=1, pos=1}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  local y = Editor_state.top

Resurrecting zombie bytes in source_text_tests.lua at line 1454 [15.3561]
∅:∅[10.13552] → [9.58982:59017]
B:B[9.58982] → [9.58982:59017]
BD:B[9.58982] → [9.58982:59017]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1456 [15.3561]
∅:∅[10.13603] → [9.59110:59145]
B:B[9.59110] → [9.59110:59145]
BD:B[9.59110] → [9.59110:59145]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1458 [15.3561]
∅:∅[10.13654] → [9.59238:59345]
B:B[9.59238] → [9.59238:59345]
BD:B[9.59238] → [9.59238:59345]
```
  -- after hitting the enter key the screen scrolls down
  edit.run_after_keychord(Editor_state, 'return')
```
Resurrecting zombie bytes in source_text_tests.lua at line 1463 [15.3561]
∅:∅[10.13824] → [9.59643:59666]
B:B[9.59643] → [9.59643:59666]
BD:B[9.59643] → [9.59643:59666]
```
  y = Editor_state.top
```
Resurrecting zombie bytes in source_text_tests.lua at line 1465 [15.3561]
∅:∅[10.13866] → [9.59750:59785]
B:B[9.59750] → [9.59750:59785]
BD:B[9.59750] → [9.59750:59785]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1467 [15.3561]
∅:∅[10.13906] → [9.59867:59902]
B:B[9.59867] → [9.59867:59902]
BD:B[9.59867] → [9.59867:59902]
```
  y = y + Editor_state.line_height
```

Resurrecting zombie bytes in source_text_tests.lua at line 1469 [15.3561]

∅:∅[10.13947] → [9.59985:60067]

B:B[9.59985] → [9.59985:60067]

BD:B[9.59985] → [9.59985:60067]

B:B[9.60149] → [9.60149:60566]

BD:B[9.60149] → [9.60149:60566]

end
function test_enter_on_final_line_avoids_scrolling_down_when_not_at_bottom()
  -- display just the bottom line on screen
  App.screen.init{width=Editor_state.left+30, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'ghi', 'jkl'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=4, pos=2}
  Editor_state.screen_top1 = {line=4, pos=1}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  local y = Editor_state.top

Resurrecting zombie bytes in source_text_tests.lua at line 1483 [15.3561]
∅:∅[10.13998] → [9.60686:60801]
B:B[9.60686] → [9.60686:60801]
BD:B[9.60686] → [9.60686:60801]
```
  -- after hitting the enter key the screen does not scroll down
  edit.run_after_keychord(Editor_state, 'return')
```
Resurrecting zombie bytes in source_text_tests.lua at line 1488 [15.3561]
∅:∅[10.14168] → [9.61180:61203]
B:B[9.61180] → [9.61180:61203]
BD:B[9.61180] → [9.61180:61203]
```
  y = Editor_state.top
```
Resurrecting zombie bytes in source_text_tests.lua at line 1490 [15.3561]
∅:∅[10.14208] → [9.61312:61347]
B:B[9.61312] → [9.61312:61347]
BD:B[9.61312] → [9.61312:61347]
```
  y = y + Editor_state.line_height
```

Resurrecting zombie bytes in source_text_tests.lua at line 1492 [15.3561]

∅:∅[10.14249] → [9.61457:61548]

B:B[9.61457] → [9.61457:61548]

BD:B[9.61457] → [9.61457:61548]

B:B[9.61639] → [9.61639:62089]

BD:B[9.61639] → [9.61639:62089]

end
function test_inserting_text_on_final_line_avoids_scrolling_down_when_not_at_bottom()
  -- display just an empty bottom line on screen
  App.screen.init{width=Editor_state.left+30, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', ''}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=2, pos=1}
  Editor_state.screen_top1 = {line=2, pos=1}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  -- after hitting the inserting_text key the screen does not scroll down

Resurrecting zombie bytes in source_text_tests.lua at line 1509 [15.3561]
∅:∅[10.14419] → [9.62541:62570]
∅:∅[9.62541] → [9.62541:62570]
B:B[9.62541] → [9.62541:62570]
BD:B[9.62541] → [9.62541:62570]
```
  local y = Editor_state.top
```

Resurrecting zombie bytes in source_text_tests.lua at line 1511 [15.3561]

∅:∅[10.14459] → [9.62688:62744]

B:B[9.62688] → [9.62688:62744]

BD:B[9.62688] → [9.62688:62744]

B:B[9.62800] → [9.62800:63225]

BD:B[9.62800] → [9.62800:63225]

end
function test_typing_on_bottom_line_scrolls_down()
  -- display a few lines with cursor on bottom line
  App.screen.init{width=Editor_state.left+30, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'ghi', 'jkl'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=3, pos=4}
  Editor_state.screen_top1 = {line=1, pos=1}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  local y = Editor_state.top

Resurrecting zombie bytes in source_text_tests.lua at line 1525 [15.3561]
∅:∅[10.14510] → [9.63319:63354]
B:B[9.63319] → [9.63319:63354]
BD:B[9.63319] → [9.63319:63354]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1527 [15.3561]
∅:∅[10.14561] → [9.63448:63483]
B:B[9.63448] → [9.63448:63483]
BD:B[9.63448] → [9.63448:63483]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1529 [15.3561]
∅:∅[10.14612] → [9.63577:63648]
B:B[9.63577] → [9.63577:63648]
BD:B[9.63577] → [9.63577:63648]
```
  -- after typing something the line wraps and the screen scrolls down
```
Resurrecting zombie bytes in source_text_tests.lua at line 1536 [15.3561]
∅:∅[10.14782] → [9.64087:64110]
∅:∅[9.64087] → [9.64087:64110]
B:B[9.64087] → [9.64087:64110]
BD:B[9.64087] → [9.64087:64110]
```
  y = Editor_state.top
```
Resurrecting zombie bytes in source_text_tests.lua at line 1538 [15.3561]
∅:∅[10.14824] → [9.64195:64230]
B:B[9.64195] → [9.64195:64230]
BD:B[9.64195] → [9.64195:64230]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1540 [15.3561]
∅:∅[10.14867] → [9.64316:64351]
B:B[9.64316] → [9.64316:64351]
BD:B[9.64316] → [9.64316:64351]
```
  y = y + Editor_state.line_height
```

Resurrecting zombie bytes in source_text_tests.lua at line 1542 [15.3561]

∅:∅[10.14908] → [9.64435:64494]

B:B[9.64435] → [9.64435:64494]

BD:B[9.64435] → [9.64435:64494]

B:B[9.64553] → [9.64553:65024]

BD:B[9.64553] → [9.64553:65024]

end
function test_left_arrow_scrolls_up_in_wrapped_line()
  -- display lines starting from second screen line of a line
  App.screen.init{width=Editor_state.left+30, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'ghi jkl', 'mno'}
  Text.redraw_all(Editor_state)
  Editor_state.screen_top1 = {line=3, pos=5}
  Editor_state.screen_bottom1 = {}
  -- cursor is at top of screen
  Editor_state.cursor1 = {line=3, pos=5}
  edit.draw(Editor_state)
  local y = Editor_state.top

Resurrecting zombie bytes in source_text_tests.lua at line 1557 [15.3561]
∅:∅[10.14959] → [9.65121:65156]
B:B[9.65121] → [9.65121:65156]
BD:B[9.65121] → [9.65121:65156]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1559 [15.3561]
∅:∅[10.15010] → [9.65253:65401]
B:B[9.65253] → [9.65253:65401]
BD:B[9.65253] → [9.65253:65401]
```
  -- after hitting the left arrow the screen scrolls up to first screen line
  edit.run_after_keychord(Editor_state, 'left')
  y = Editor_state.top
```
Resurrecting zombie bytes in source_text_tests.lua at line 1563 [15.3561]
∅:∅[10.15053] → [9.65490:65525]
B:B[9.65490] → [9.65490:65525]
BD:B[9.65490] → [9.65490:65525]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1565 [15.3561]
∅:∅[10.15095] → [9.65613:65648]
B:B[9.65613] → [9.65613:65648]
BD:B[9.65613] → [9.65613:65648]
```
  y = y + Editor_state.line_height
```

Resurrecting zombie bytes in source_text_tests.lua at line 1571 [15.3561]

∅:∅[10.15373] → [9.66151:66213]

B:B[9.66151] → [9.66151:66213]

BD:B[9.66151] → [9.66151:66213]

B:B[9.66275] → [9.66275:66763]

BD:B[9.66275] → [9.66275:66763]

end
function test_right_arrow_scrolls_down_in_wrapped_line()
  -- display the first three lines with the cursor on the bottom line
  App.screen.init{width=Editor_state.left+30, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'ghi jkl', 'mno'}
  Text.redraw_all(Editor_state)
  Editor_state.screen_top1 = {line=1, pos=1}
  Editor_state.screen_bottom1 = {}
  -- cursor is at bottom right of screen
  Editor_state.cursor1 = {line=3, pos=5}
  edit.draw(Editor_state)
  local y = Editor_state.top

Resurrecting zombie bytes in source_text_tests.lua at line 1586 [15.3561]
∅:∅[10.15424] → [9.66863:66898]
B:B[9.66863] → [9.66863:66898]
BD:B[9.66863] → [9.66863:66898]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1588 [15.3561]
∅:∅[10.15475] → [9.66998:67033]
B:B[9.66998] → [9.66998:67033]
BD:B[9.66998] → [9.66998:67033]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1590 [15.3561]
∅:∅[10.15574] → [9.67181:67301]
B:B[9.67181] → [9.67181:67301]
BD:B[9.67181] → [9.67181:67301]
```
  -- after hitting the right arrow the screen scrolls down by one line
  edit.run_after_keychord(Editor_state, 'right')
```
Resurrecting zombie bytes in source_text_tests.lua at line 1595 [15.3561]
∅:∅[10.15744] → [9.67620:67643]
B:B[9.67620] → [9.67620:67643]
BD:B[9.67620] → [9.67620:67643]
```
  y = Editor_state.top
```
Resurrecting zombie bytes in source_text_tests.lua at line 1597 [15.3561]
∅:∅[10.15786] → [9.67734:67769]
B:B[9.67734] → [9.67734:67769]
BD:B[9.67734] → [9.67734:67769]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1599 [15.3561]
∅:∅[10.15829] → [9.67861:67896]
B:B[9.67861] → [9.67861:67896]
BD:B[9.67861] → [9.67861:67896]
```
  y = y + Editor_state.line_height
```

Resurrecting zombie bytes in source_text_tests.lua at line 1601 [15.3561]

∅:∅[10.15871] → [9.67987:68040]

B:B[9.67987] → [9.67987:68040]

BD:B[9.67987] → [9.67987:68040]

B:B[9.68093] → [9.68093:68564]

BD:B[9.68093] → [9.68093:68564]

end
function test_home_scrolls_up_in_wrapped_line()
  -- display lines starting from second screen line of a line
  App.screen.init{width=Editor_state.left+30, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'ghi jkl', 'mno'}
  Text.redraw_all(Editor_state)
  Editor_state.screen_top1 = {line=3, pos=5}
  Editor_state.screen_bottom1 = {}
  -- cursor is at top of screen
  Editor_state.cursor1 = {line=3, pos=5}
  edit.draw(Editor_state)
  local y = Editor_state.top

Resurrecting zombie bytes in source_text_tests.lua at line 1616 [15.3561]
∅:∅[10.15922] → [9.68655:68690]
B:B[9.68655] → [9.68655:68690]
BD:B[9.68655] → [9.68655:68690]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1618 [15.3561]
∅:∅[10.15973] → [9.68781:68919]
B:B[9.68781] → [9.68781:68919]
BD:B[9.68781] → [9.68781:68919]
```
  -- after hitting home the screen scrolls up to first screen line
  edit.run_after_keychord(Editor_state, 'home')
  y = Editor_state.top
```
Resurrecting zombie bytes in source_text_tests.lua at line 1622 [15.3561]
∅:∅[10.16016] → [9.69002:69037]
B:B[9.69002] → [9.69002:69037]
BD:B[9.69002] → [9.69002:69037]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1624 [15.3561]
∅:∅[10.16058] → [9.69119:69154]
B:B[9.69119] → [9.69119:69154]
BD:B[9.69119] → [9.69119:69154]
```
  y = y + Editor_state.line_height
```

Resurrecting zombie bytes in source_text_tests.lua at line 1630 [15.3561]

∅:∅[10.16336] → [9.69627:69681]

B:B[9.69627] → [9.69627:69681]

BD:B[9.69627] → [9.69627:69681]

B:B[9.69735] → [9.69735:70223]

BD:B[9.69735] → [9.69735:70223]

end
function test_end_scrolls_down_in_wrapped_line()
  -- display the first three lines with the cursor on the bottom line
  App.screen.init{width=Editor_state.left+30, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'ghi jkl', 'mno'}
  Text.redraw_all(Editor_state)
  Editor_state.screen_top1 = {line=1, pos=1}
  Editor_state.screen_bottom1 = {}
  -- cursor is at bottom right of screen
  Editor_state.cursor1 = {line=3, pos=5}
  edit.draw(Editor_state)
  local y = Editor_state.top

Resurrecting zombie bytes in source_text_tests.lua at line 1645 [15.3561]
∅:∅[10.16387] → [9.70315:70350]
B:B[9.70315] → [9.70315:70350]
BD:B[9.70315] → [9.70315:70350]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1647 [15.3561]
∅:∅[10.16438] → [9.70442:70477]
B:B[9.70442] → [9.70442:70477]
BD:B[9.70442] → [9.70442:70477]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1649 [15.3561]
∅:∅[10.16537] → [9.70617:70723]
B:B[9.70617] → [9.70617:70723]
BD:B[9.70617] → [9.70617:70723]
```
  -- after hitting end the screen scrolls down by one line
  edit.run_after_keychord(Editor_state, 'end')
```
Resurrecting zombie bytes in source_text_tests.lua at line 1654 [15.3561]
∅:∅[10.16707] → [9.71018:71041]
B:B[9.71018] → [9.71018:71041]
BD:B[9.71018] → [9.71018:71041]
```
  y = Editor_state.top
```
Resurrecting zombie bytes in source_text_tests.lua at line 1656 [15.3561]
∅:∅[10.16749] → [9.71124:71159]
B:B[9.71124] → [9.71124:71159]
BD:B[9.71124] → [9.71124:71159]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1658 [15.3561]
∅:∅[10.16792] → [9.71243:71278]
B:B[9.71243] → [9.71243:71278]
BD:B[9.71243] → [9.71243:71278]
```
  y = y + Editor_state.line_height
```

Resurrecting zombie bytes in source_text_tests.lua at line 1660 [15.3561]

∅:∅[10.16834] → [9.71361:71477]

B:B[9.71361] → [9.71361:71477]

BD:B[9.71361] → [9.71361:71477]

B:B[9.71547] → [9.71547:71912]

BD:B[9.71547] → [9.71547:71912]

end
function test_position_cursor_on_recently_edited_wrapping_line()
  -- draw a line wrapping over 2 screen lines
  App.screen.init{width=100, height=200}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc def ghi jkl mno pqr ', 'xyz'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=1, pos=25}
  Editor_state.screen_top1 = {line=1, pos=1}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  local y = Editor_state.top

Resurrecting zombie bytes in source_text_tests.lua at line 1674 [15.3561]
∅:∅[10.16895] → [9.72030:72065]
B:B[9.72030] → [9.72030:72065]
BD:B[9.72030] → [9.72030:72065]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1676 [15.3561]
∅:∅[10.16956] → [9.72183:72218]
B:B[9.72183] → [9.72183:72218]
BD:B[9.72183] → [9.72183:72218]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1678 [15.3561]
∅:∅[10.17008] → [9.72327:72388]
B:B[9.72327] → [9.72327:72388]
BD:B[9.72327] → [9.72327:72388]
```
  -- add to the line until it's wrapping over 3 screen lines
```
Resurrecting zombie bytes in source_text_tests.lua at line 1683 [15.3561]
∅:∅[10.17064] → [9.72639:72662]
∅:∅[9.72639] → [9.72639:72662]
B:B[9.72639] → [9.72639:72662]
BD:B[9.72639] → [9.72639:72662]
```
  y = Editor_state.top
```
Resurrecting zombie bytes in source_text_tests.lua at line 1685 [15.3561]
∅:∅[10.17125] → [9.72780:72815]
B:B[9.72780] → [9.72780:72815]
BD:B[9.72780] → [9.72780:72815]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1687 [15.3561]
∅:∅[10.17186] → [9.72933:72968]
B:B[9.72933] → [9.72933:72968]
BD:B[9.72933] → [9.72933:72968]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1689 [15.3561]
∅:∅[10.17238] → [9.73077:73160]
B:B[9.73077] → [9.73077:73160]
BD:B[9.73077] → [9.73077:73160]
```
  -- try to move the cursor earlier in the third screen line by clicking the mouse
```
Resurrecting zombie bytes in source_text_tests.lua at line 1691 [15.3561]
∅:∅[20.13322] → [9.73273:73297]
B:B[9.73273] → [9.73273:73297]
BD:B[9.73273] → [9.73273:73297]
```
  -- cursor should move
```

Resurrecting zombie bytes in source_text_tests.lua at line 1694 [15.3561]

∅:∅[10.17350] → [9.73524:73569]

B:B[9.73524] → [9.73524:73569]

BD:B[9.73524] → [9.73524:73569]

B:B[9.73614] → [9.73614:74025]

BD:B[9.73614] → [9.73614:74025]

end
function test_backspace_can_scroll_up()
  -- display the lines 2/3/4 with the cursor on line 2
  App.screen.init{width=120, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'ghi', 'jkl'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=2, pos=1}
  Editor_state.screen_top1 = {line=2, pos=1}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  local y = Editor_state.top

Resurrecting zombie bytes in source_text_tests.lua at line 1708 [15.3561]
∅:∅[10.17401] → [9.74108:74143]
B:B[9.74108] → [9.74108:74143]
BD:B[9.74108] → [9.74108:74143]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1710 [15.3561]
∅:∅[10.17452] → [9.74226:74261]
B:B[9.74226] → [9.74226:74261]
BD:B[9.74226] → [9.74226:74261]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1712 [15.3561]
∅:∅[10.17503] → [9.74344:74460]
B:B[9.74344] → [9.74344:74460]
BD:B[9.74344] → [9.74344:74460]
```
  -- after hitting backspace the screen scrolls up by one line
  edit.run_after_keychord(Editor_state, 'backspace')
```
Resurrecting zombie bytes in source_text_tests.lua at line 1716 [15.3561]
∅:∅[10.17614] → [9.74636:74659]
B:B[9.74636] → [9.74636:74659]
BD:B[9.74636] → [9.74636:74659]
```
  y = Editor_state.top
```
Resurrecting zombie bytes in source_text_tests.lua at line 1718 [15.3561]
∅:∅[10.17659] → [9.74736:74771]
B:B[9.74736] → [9.74736:74771]
BD:B[9.74736] → [9.74736:74771]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1720 [15.3561]
∅:∅[10.17701] → [9.74845:74880]
B:B[9.74845] → [9.74845:74880]
BD:B[9.74845] → [9.74845:74880]
```
  y = y + Editor_state.line_height
```

Resurrecting zombie bytes in source_text_tests.lua at line 1722 [15.3561]

∅:∅[10.17743] → [9.74954:75011]

B:B[9.74954] → [9.74954:75011]

BD:B[9.74954] → [9.74954:75011]

B:B[9.75068] → [9.75068:75507]

BD:B[9.75068] → [9.75068:75507]

end
function test_backspace_can_scroll_up_screen_line()
  -- display lines starting from second screen line of a line
  App.screen.init{width=Editor_state.left+30, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'ghi jkl', 'mno'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=3, pos=5}
  Editor_state.screen_top1 = {line=3, pos=5}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  local y = Editor_state.top

Resurrecting zombie bytes in source_text_tests.lua at line 1736 [15.3561]
∅:∅[10.17794] → [9.75602:75637]
B:B[9.75602] → [9.75602:75637]
BD:B[9.75602] → [9.75602:75637]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1738 [15.3561]
∅:∅[10.17845] → [9.75732:75878]
B:B[9.75732] → [9.75732:75878]
BD:B[9.75732] → [9.75732:75878]
```
  -- after hitting backspace the screen scrolls up by one screen line
  edit.run_after_keychord(Editor_state, 'backspace')
  y = Editor_state.top
```
Resurrecting zombie bytes in source_text_tests.lua at line 1742 [15.3561]
∅:∅[10.17888] → [9.75965:76000]
B:B[9.75965] → [9.75965:76000]
BD:B[9.75965] → [9.75965:76000]
```
  y = y + Editor_state.line_height
```
Resurrecting zombie bytes in source_text_tests.lua at line 1744 [15.3561]
∅:∅[10.17929] → [9.76085:76120]
B:B[9.76085] → [9.76085:76120]
BD:B[9.76085] → [9.76085:76120]
```
  y = y + Editor_state.line_height
```

Resurrecting zombie bytes in source_text_tests.lua at line 1750 [15.3561]

∅:∅[10.18207] → [9.76613:76663]

B:B[9.76613] → [9.76613:76663]

BD:B[9.76613] → [9.76613:76663]

B:B[9.76713] → [9.76713:77082]

BD:B[9.76713] → [9.76713:77082]

end
function test_backspace_past_line_boundary()
  -- position cursor at start of a (non-first) line
  App.screen.init{width=Editor_state.left+30, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=2, pos=1}
  -- backspace joins with previous line
  edit.run_after_keychord(Editor_state, 'backspace')

Resurrecting zombie bytes in source_text_tests.lua at line 1762 [15.3561]
∅:∅[10.18266] → [9.77172:77177]
B:B[9.77172] → [9.77172:77177]
BD:B[9.77172] → [9.77172:77177]
```
end
```

Resurrecting zombie bytes in source_text_tests.lua at line 1955 [15.3561]

B:B[21.20765] → [20.16338:16361]

BD:B[21.20765] → [20.16338:16361]

B:B[20.16389] → [20.16389:16475]

BD:B[20.16389] → [20.16389:16475]

B:B[16.3881] → [9.80323:80574]

BD:B[16.3881] → [9.80323:80574]

function test_search()
  App.screen.init{width=120, height=60}
  Editor_state = edit.initialize_test_state()
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=1, pos=1}
  Editor_state.screen_top1 = {line=1, pos=1}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  -- search for a string
  edit.run_after_keychord(Editor_state, 'C-f')

Replacement in source_text_tests.lua at line 1958 [15.3561]
∅:D[20.16475] → [16.3807:3881]
∅:D[9.80322] → [16.3807:3881]
B:BD[15.80491] → [16.3807:3881]
BD:BD[15.80491] → [16.3807:3881]
```
  Editor_state.lines = load_array{'```lines', '```', 'def', 'ghi', 'deg'}
```
[20.16475]
[9.80323]
```
  Editor_state.lines = load_array{'```lines', '```', 'def', 'ghi', '’deg'}  -- contains unicode quote in final line
```
Resurrecting zombie bytes in source_text_tests.lua at line 1967 [15.3561]
∅:∅[18.5122] → [9.80620:80670]
B:B[9.80620] → [9.80620:80670]
BD:B[9.80620] → [9.80620:80670]
```
  edit.run_after_keychord(Editor_state, 'return')
```

Resurrecting zombie bytes in source_text_tests.lua at line 1970 [15.3561]

∅:∅[10.19506] → [9.80816:81001]

B:B[9.80816] → [9.80816:81001]

BD:B[9.80816] → [9.80816:81001]

  -- reset cursor
  Editor_state.cursor1 = {line=1, pos=1}
  Editor_state.screen_top1 = {line=1, pos=1}
  -- search for second occurrence
  edit.run_after_keychord(Editor_state, 'C-f')

Resurrecting zombie bytes in source_text_tests.lua at line 1976 [15.3561]
∅:∅[18.5171] → [9.81048:81146]
B:B[9.81048] → [9.81048:81146]
BD:B[9.81048] → [9.81048:81146]
```
  edit.run_after_keychord(Editor_state, 'down')
  edit.run_after_keychord(Editor_state, 'return')
```
Deletion in source_text_tests.lua at line 1979 [15.3561]
B:BD[10.19565] → [10.19565:19621]
```
  check_eq(Editor_state.cursor1.pos, 1, '2/cursor:pos')
```
Resurrecting zombie bytes in source_text_tests.lua at line 1979 [15.3561]
∅:∅[10.19621] → [9.81292:81328]
B:B[9.81292] → [9.81292:81328]
BD:B[9.81292] → [9.81292:81328]
B:B[9.81364] → [9.81364:81450]
BD:B[9.81364] → [9.81364:81450]
```
end
function test_search_upwards()
  App.screen.init{width=120, height=60}
  Editor_state = edit.initialize_test_state()
```
Insertion in source_text_tests.lua at line 1979 [15.3561]
[10.19565]
[9.81292]
```
  check_eq(Editor_state.cursor1.pos, 2, '2/cursor:pos')
```
Replacement in source_text_tests.lua at line 1985 [15.3561]
B:BD[9.81450] → [9.81450:81495]
BD:BD[9.81450] → [9.81450:81495]
```
  Editor_state.lines = load_array{'abc abd'}
```
[9.81450]
[9.81495]
```
  Editor_state.lines = load_array{'’abc', 'abd'}  -- contains unicode quote
```
Replacement in source_text_tests.lua at line 1987 [15.3561]
B:BD[9.81527] → [9.81527:81568]
BD:BD[9.81527] → [9.81527:81568]
```
  Editor_state.cursor1 = {line=1, pos=2}
```
[9.81527]
[9.81568]
```
  Editor_state.cursor1 = {line=2, pos=1}
```
Resurrecting zombie bytes in source_text_tests.lua at line 1994 [15.3561]
∅:∅[18.5219] → [9.81792:81874]
B:B[9.81792] → [9.81792:81874]
BD:B[9.81792] → [9.81792:81874]
```
  -- search for previous occurrence
  edit.run_after_keychord(Editor_state, 'up')
```
Deletion in source_text_tests.lua at line 1997 [15.3561]
B:BD[10.19680] → [10.19680:19736]
```
  check_eq(Editor_state.cursor1.pos, 1, '2/cursor:pos')
```
Resurrecting zombie bytes in source_text_tests.lua at line 1997 [15.3561]
∅:∅[10.19736] → [9.82036:82069]
B:B[9.82036] → [9.82036:82069]
BD:B[9.82036] → [9.82036:82069]
B:B[9.82102] → [9.82102:82188]
BD:B[9.82102] → [9.82102:82188]
```
end
function test_search_wrap()
  App.screen.init{width=120, height=60}
  Editor_state = edit.initialize_test_state()
```
Insertion in source_text_tests.lua at line 1997 [15.3561]
[10.19680]
[9.82036]
```
  check_eq(Editor_state.cursor1.pos, 2, '2/cursor:pos')
```
Replacement in source_text_tests.lua at line 2003 [15.3561]
B:BD[9.82188] → [9.82188:82229]
BD:BD[9.82188] → [9.82188:82229]
```
  Editor_state.lines = load_array{'abc'}
```
[9.82188]
[9.82229]
```
  Editor_state.lines = load_array{'’abc', 'def'}  -- contains unicode quote in first line
```
Replacement in source_text_tests.lua at line 2005 [15.3561]
B:BD[9.82261] → [9.82261:82302]
BD:BD[9.82261] → [9.82261:82302]
```
  Editor_state.cursor1 = {line=1, pos=3}
```
[9.82261]
[9.82302]
```
  Editor_state.cursor1 = {line=2, pos=1}
```
Resurrecting zombie bytes in source_text_tests.lua at line 2012 [15.3561]
∅:∅[18.5267] → [9.82526:82594]
B:B[9.82526] → [9.82526:82594]
BD:B[9.82526] → [9.82526:82594]
```
  edit.run_after_keychord(Editor_state, 'return')
  -- cursor wraps
```
Deletion in source_text_tests.lua at line 2015 [15.3561]
B:BD[10.19795] → [10.19795:19851]
```
  check_eq(Editor_state.cursor1.pos, 1, '1/cursor:pos')
```
Resurrecting zombie bytes in source_text_tests.lua at line 2015 [15.3561]
∅:∅[10.19851] → [9.82750:82791]
B:B[9.82750] → [9.82750:82791]
BD:B[9.82750] → [9.82750:82791]
B:B[9.82832] → [9.82832:82918]
BD:B[9.82832] → [9.82832:82918]
```
end
function test_search_wrap_upwards()
  App.screen.init{width=120, height=60}
  Editor_state = edit.initialize_test_state()
```
Insertion in source_text_tests.lua at line 2015 [15.3561]
[10.19795]
[9.82750]
```
  check_eq(Editor_state.cursor1.pos, 2, '1/cursor:pos')
```
Replacement in source_text_tests.lua at line 2021 [15.3561]
B:BD[9.82918] → [9.82918:82963]
BD:BD[9.82918] → [9.82918:82963]
```
  Editor_state.lines = load_array{'abc abd'}
```
[9.82918]
[9.82963]
```
  Editor_state.lines = load_array{'abc ’abd'}  -- contains unicode quote
```
Resurrecting zombie bytes in source_text_tests.lua at line 2030 [15.3561]
∅:∅[18.5315] → [9.83268:83332]
B:B[9.83268] → [9.83268:83332]
BD:B[9.83268] → [9.83268:83332]
```
  edit.run_after_keychord(Editor_state, 'up')
  -- cursor wraps
```
Deletion in source_text_tests.lua at line 2032 [15.3561]
B:BD[9.83332] → [10.19853:19853]
B:BD[15.80491] → [4.113:231]
BD:BD[15.80491] → [4.113:231]
B:BD[23.22380] → [4.232:288]
BD:BD[23.22380] → [4.232:288]
BD:BD[23.22380] → [4.232:288]
B:BD[15.81680] → [4.289:367]
BD:BD[15.81680] → [4.289:367]
B:BD[15.81757] → [4.368:409]
BD:BD[15.81757] → [4.368:409]
B:BD[23.22495] → [4.410:466]
BD:BD[23.22495] → [4.410:466]
BD:BD[23.22495] → [4.410:466]
B:BD[15.82418] → [4.467:559]
BD:BD[15.82418] → [4.467:559]
B:BD[15.82491] → [4.560:601]
BD:BD[15.82491] → [4.560:601]
```
  Editor_state.lines = load_array{'```lines', '```', 'def', 'ghi', '’deg'}  -- contains unicode quote in final line
  check_eq(Editor_state.cursor1.pos, 2, '2/cursor:pos')
  Editor_state.lines = load_array{'’abc', 'abd'}  -- contains unicode quote
  Editor_state.cursor1 = {line=2, pos=1}
  check_eq(Editor_state.cursor1.pos, 2, '2/cursor:pos')
  Editor_state.lines = load_array{'’abc', 'def'}  -- contains unicode quote in first line
  Editor_state.cursor1 = {line=2, pos=1}
```
Solving an order conflict in source_text_tests.lua at line 2032 [15.3561]
[9.83332]
[23.22552]
Deletion in source_text_tests.lua at line 2033 [15.3561]
B:BD[23.22610] → [4.602:658]
BD:BD[23.22610] → [4.602:658]
B:BD[15.83148] → [4.659:734]
BD:BD[15.83148] → [4.659:734]
B:BD[23.22725] → [23.22725:22781]
BD:BD[23.22725] → [23.22725:22781]
B:BD[23.22781] → [10.19854:19858]
BD:BD[23.22781] → [10.19854:19858]
B:BD[10.19858] → [3.153:153]
```
  check_eq(Editor_state.cursor1.pos, 2, '1/cursor:pos')
  Editor_state.lines = load_array{'abc ’abd'}  -- contains unicode quote
  check_eq(Editor_state.cursor1.pos, 5, '1/cursor:pos')
end
```
Resurrecting zombie bytes in source_text_tests.lua at line 2033 [15.3561]
B:B[23.22725] → [4.735:791]
BD:B[23.22725] → [4.735:791]
BD:B[23.22725] → [4.735:791]
```
  check_eq(Editor_state.cursor1.pos, 6, '1/cursor:pos')
```
Insertion in source_text_tests.lua at line 2034 [15.3561]
[4.791]
```
end
```

Merge text.love

Dependencies

In channels

Change contents

Replacement in text_tests.lua at line 1861 [6.2]

Replacement in text_tests.lua at line 1882 [6.2]

Replacement in text_tests.lua at line 1888 [6.2]

Replacement in text_tests.lua at line 1890 [6.2]

Replacement in text_tests.lua at line 1900 [6.2]

Replacement in text_tests.lua at line 1906 [6.2]

Replacement in text_tests.lua at line 1908 [6.2]

Replacement in text_tests.lua at line 1918 [6.2]

Replacement in text_tests.lua at line 1924 [6.2]

Replacement in text_tests.lua at line 1936 [6.2]

Deletion in text_tests.lua at line 1938 [6.2]

Solving an order conflict in text_tests.lua at line 1938 [6.2]

Resurrecting zombie bytes in source_text_tests.lua at line 953 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 967 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 969 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 971 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 975 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 977 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 979 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 981 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 997 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1011 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1013 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1015 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1019 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1022 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1024 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1026 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1053 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1065 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1067 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1069 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1073 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1075 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1077 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1079 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1093 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1095 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1097 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1102 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1104 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1106 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1108 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1122 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1124 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1126 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1131 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1133 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1135 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1137 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1140 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1150 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1152 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1154 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1159 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1164 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1166 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1168 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1170 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1184 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1186 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1188 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1192 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1195 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1197 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1199 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1226 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1238 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1240 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1242 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1246 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1248 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1250 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1252 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1276 [15.3561]

Resurrecting zombie bytes in source_text_tests.lua at line 1288 [15.3561]