diff --git a/src/testdir/test_autocmd.vim b/src/testdir/test_autocmd.vim
index cc1f6cd..50fdc41 100644
--- a/src/testdir/test_autocmd.vim
+++ b/src/testdir/test_autocmd.vim
@@ -4495,39 +4495,40 @@
         \ {'term_rows': 10})
   call assert_equal('running', term_getstatus(buf))
   call WaitForAssert({-> assert_true(filereadable('XTextChangedI3'))})
+  defer delete('XTextChangedI3')
   call WaitForAssert({-> assert_equal([''], readfile('XTextChangedI3'))})
 
   " TextChanged should trigger if a mapping enters and leaves Insert mode.
   call term_sendkeys(buf, "\<CR>")
-  call WaitForAssert({-> assert_equal('N4,', readfile('XTextChangedI3')[0])})
+  call WaitForAssert({-> assert_equal('N4,', readfile('XTextChangedI3')->join("\n"))})
 
   call term_sendkeys(buf, "i")
   call WaitForAssert({-> assert_match('^-- INSERT --', term_getline(buf, 10))})
-  call WaitForAssert({-> assert_equal('N4,', readfile('XTextChangedI3')[0])})
+  call WaitForAssert({-> assert_equal('N4,', readfile('XTextChangedI3')->join("\n"))})
   " TextChangedI should trigger if change is done in Insert mode.
   call term_sendkeys(buf, "f")
-  call WaitForAssert({-> assert_equal('N4,I5', readfile('XTextChangedI3')[0])})
+  call WaitForAssert({-> assert_equal('N4,I5', readfile('XTextChangedI3')->join("\n"))})
   call term_sendkeys(buf, "o")
-  call WaitForAssert({-> assert_equal('N4,I6', readfile('XTextChangedI3')[0])})
+  call WaitForAssert({-> assert_equal('N4,I6', readfile('XTextChangedI3')->join("\n"))})
   call term_sendkeys(buf, "o")
-  call WaitForAssert({-> assert_equal('N4,I7', readfile('XTextChangedI3')[0])})
+  call WaitForAssert({-> assert_equal('N4,I7', readfile('XTextChangedI3')->join("\n"))})
   " TextChanged shouldn't trigger when leaving Insert mode and TextChangedI
   " has been triggered.
   call term_sendkeys(buf, "\<Esc>")
   call WaitForAssert({-> assert_notmatch('^-- INSERT --', term_getline(buf, 10))})
-  call WaitForAssert({-> assert_equal('N4,I7', readfile('XTextChangedI3')[0])})
+  call WaitForAssert({-> assert_equal('N4,I7', readfile('XTextChangedI3')->join("\n"))})
 
   " TextChanged should trigger if change is done in Normal mode.
   call term_sendkeys(buf, "yyp")
-  call WaitForAssert({-> assert_equal('N8,I7', readfile('XTextChangedI3')[0])})
+  call WaitForAssert({-> assert_equal('N8,I7', readfile('XTextChangedI3')->join("\n"))})
 
   " TextChangedI shouldn't trigger if change isn't done in Insert mode.
   call term_sendkeys(buf, "i")
   call WaitForAssert({-> assert_match('^-- INSERT --', term_getline(buf, 10))})
-  call WaitForAssert({-> assert_equal('N8,I7', readfile('XTextChangedI3')[0])})
+  call WaitForAssert({-> assert_equal('N8,I7', readfile('XTextChangedI3')->join("\n"))})
   call term_sendkeys(buf, "\<Esc>")
   call WaitForAssert({-> assert_notmatch('^-- INSERT --', term_getline(buf, 10))})
-  call WaitForAssert({-> assert_equal('N8,I7', readfile('XTextChangedI3')[0])})
+  call WaitForAssert({-> assert_equal('N8,I7', readfile('XTextChangedI3')->join("\n"))})
 
   " TextChangedI should trigger if change is a mix of Normal and Insert modes.
   func! s:validate_mixed_textchangedi(buf, keys)
@@ -4537,13 +4538,13 @@
     call term_sendkeys(buf, "\<Esc>")
     call WaitForAssert({-> assert_notmatch('^-- INSERT --', term_getline(buf, 10))})
     call term_sendkeys(buf, ":let [g:autocmd_n, g:autocmd_i] = ['', '']\<CR>")
-    call delete('XTextChangedI3')
+    call writefile([], 'XTextChangedI3')
     call term_sendkeys(buf, a:keys)
     call WaitForAssert({-> assert_match('^-- INSERT --', term_getline(buf, 10))})
-    call WaitForAssert({-> assert_match('^,I\d\+', readfile('XTextChangedI3')[0])})
+    call WaitForAssert({-> assert_match('^,I\d\+', readfile('XTextChangedI3')->join("\n"))})
     call term_sendkeys(buf, "\<Esc>")
     call WaitForAssert({-> assert_notmatch('^-- INSERT --', term_getline(buf, 10))})
-    call WaitForAssert({-> assert_match('^,I\d\+', readfile('XTextChangedI3')[0])})
+    call WaitForAssert({-> assert_match('^,I\d\+', readfile('XTextChangedI3')->join("\n"))})
   endfunc
 
   call s:validate_mixed_textchangedi(buf, "o")
@@ -4556,7 +4557,6 @@
 
   " clean up
   bwipe!
-  call delete('XTextChangedI3')
 endfunc
 
 " Test that filetype detection still works when SwapExists autocommand sets
diff --git a/src/version.c b/src/version.c
index cf57e38..9f9386f 100644
--- a/src/version.c
+++ b/src/version.c
@@ -705,6 +705,8 @@
 static int included_patches[] =
 {   /* Add new patch number below this line */
 /**/
+    269,
+/**/
     268,
 /**/
     267,
