diff --git a/src/testdir/test_expand.vim b/src/testdir/test_expand.vim
index 5a51903..d86fea4 100644
--- a/src/testdir/test_expand.vim
+++ b/src/testdir/test_expand.vim
@@ -81,7 +81,11 @@
   call assert_fails('call expandcmd("make <afile>")', 'E495:')
   enew
   call assert_fails('call expandcmd("make %")', 'E499:')
-  close
+  let $FOO="blue\tsky"
+  call setline(1, "$FOO")
+  call assert_equal("grep pat blue\tsky", expandcmd('grep pat <cfile>'))
+  unlet $FOO
+  close!
 endfunc
 
 " Test for expanding <sfile>, <slnum> and <sflnum> outside of sourcing a script
@@ -108,5 +112,17 @@
   call delete('Xresult')
 endfunc
 
+" Test for expanding filenames multiple times in a command line
+func Test_expand_filename_multicmd()
+  edit foo
+  call setline(1, 'foo!')
+  new
+  call setline(1, 'foo!')
+  new <cword> | new <cWORD>
+  call assert_equal(4, winnr('$'))
+  call assert_equal('foo!', bufname(winbufnr(1)))
+  call assert_equal('foo', bufname(winbufnr(2)))
+  %bwipe!
+endfunc
 
 " vim: shiftwidth=2 sts=2 expandtab
