githubmirror/vim-plug

test/workflow.vader
772 строки20 KB
Junegunn Choi
Forced run of post-update hooks using bang commands
02 авг 2014, 07:13
02 авг 2014, 07:1393628b1
Execute (Initialize test environment):
  Save &rtp, g:plugs, g:plug_home

  let first_rtp = split(&rtp, ',')[0]
  let last_rtp  = split(&rtp, ',')[-1]

  let vader = fnamemodify(globpath(&rtp, 'autoload/vader.vim'), ':h:h')
  let plug  = fnamemodify(globpath(&rtp, 'autoload/plug.vim'), ':h:h')
  set rtp=$HOME/.vim,$VIM/vimfiles,$VIMRUNTIME,$VIM/vimfiles/after,$HOME/.vim/after
  execute 'set rtp^='.vader
  execute 'set rtp^='.plug
  let basertp = &rtp

  unlet! g:plugs
  unlet! g:plug_home

  set t_Co=256
  colo default
  pclose

  function! PlugStatusSorted()
    PlugStatus
    %y
    q
    normal! P
    %sort
    g/^$/d
  endfunction

  function! AssertExpect(bang, pat, cnt)
    let op = a:bang ? '==' : '=~'
    AssertEqual a:cnt, len(filter(getline(1, '$'), "v:val ".op." '".a:pat."'"))
  endfunction
  command! -nargs=+ -bang AssertExpect call AssertExpect('<bang>' == '!', <args>)

Execute (plug#end() before plug#begin() should fail):
  redir => out
  AssertEqual 0, plug#end()
  redir END
  Assert stridx(out, 'Call plug#begin() first') >= 0

Execute (plug#begin() without path argument):
  call plug#begin()
  AssertEqual split(&rtp, ',')[0].'/plugged', g:plug_home
  unlet g:plug_home

Execute (plug#begin() without path argument with empty &rtp):
  let save_rtp = &rtp
  set rtp=
  redir => out
  AssertEqual 0, plug#begin()
  redir END
  Assert stridx(out, 'Unable to determine plug home') >= 0
  let &rtp = save_rtp

Execute (plug#begin(path)):
  let temp_plugged = tempname()
  call plug#begin(temp_plugged.'/')
  Assert g:plug_home !~ '[/\\]$', 'Trailing / should be stripped from g:plug_home'

  AssertEqual 0, len(g:plugs)
  AssertEqual temp_plugged, g:plug_home
  AssertEqual basertp, &rtp

Execute (Subsequent plug#begin() calls will reuse g:plug_home):
  call plug#begin()
  AssertEqual temp_plugged, g:plug_home

Execute (Test Plug command):
  " Git repo with branch
  Plug 'junegunn/seoul256.vim', 'yes-t_co'
  AssertEqual 'https://git:@github.com/junegunn/seoul256.vim.git', g:plugs['seoul256.vim'].uri
  AssertEqual join([temp_plugged, 'seoul256.vim/'], '/'), g:plugs['seoul256.vim'].dir
  AssertEqual 'yes-t_co', g:plugs['seoul256.vim'].branch

  Plug 'junegunn/seoul256.vim', { 'branch': 'no-t_co' } " Using branch option
  AssertEqual 'no-t_co', g:plugs['seoul256.vim'].branch

  " Git repo with tag
  Plug 'junegunn/goyo.vim', '1.5.2'
  AssertEqual 'https://git:@github.com/junegunn/goyo.vim.git', g:plugs['goyo.vim'].uri
  AssertEqual join([temp_plugged, 'goyo.vim/'], '/'), g:plugs['goyo.vim'].dir
  AssertEqual '1.5.2', g:plugs['goyo.vim'].branch

  Plug 'junegunn/goyo.vim', { 'tag': '1.5.3' } " Using tag option
  AssertEqual '1.5.3', g:plugs['goyo.vim'].branch

  " Git URI
  Plug 'https://bitbucket.org/junegunn/vim-emoji.git'
  AssertEqual 'https://bitbucket.org/junegunn/vim-emoji.git', g:plugs['vim-emoji'].uri
  AssertEqual 'master', g:plugs['vim-emoji'].branch
  AssertEqual join([temp_plugged, 'vim-emoji/'], '/'), g:plugs['vim-emoji'].dir

  " vim-scripts/
  Plug 'beauty256'
  AssertEqual 'https://git:@github.com/vim-scripts/beauty256.git', g:plugs.beauty256.uri
  AssertEqual 'master', g:plugs.beauty256.branch

  AssertEqual 4, len(g:plugs)

Execute (Plug command with dictionary option):
  Log string(g:plugs)
  Plug 'junegunn/seoul256.vim', { 'branch': 'no-t_co', 'rtp': '././' }
  AssertEqual join([temp_plugged, 'seoul256.vim/'], '/'), g:plugs['seoul256.vim'].dir
  AssertEqual '././', g:plugs['seoul256.vim'].rtp

  Log string(g:plugs)
  AssertEqual 4, len(g:plugs)

Execute (PlugStatus before installation):
  PlugStatus
  AssertExpect 'Not found', 4
  q

Execute (PlugClean before installation):
  PlugClean
  AssertExpect 'Already clean', 1
  q

Execute (plug#end() updates &rtp):
  call plug#end()
  Assert len(&rtp) > len(basertp)
  AssertEqual first_rtp, split(&rtp, ',')[0]
  AssertEqual last_rtp, split(&rtp, ',')[-1]

Execute (Yet, plugins are not available):
  Assert empty(globpath(&rtp, 'autoload/emoji.vim'))

Execute (PlugInstall):
  PlugInstall
  q

Execute (Plugin available after installation):
  Assert !empty(globpath(&rtp, 'autoload/emoji.vim'))

Execute (PlugClean after installation):
  PlugClean
  AssertExpect 'Already clean', 1
  q

Execute (PlugStatus after installation):
  PlugStatus
  Log getline(1, '$')
  AssertExpect 'OK', 4
  q

Execute (Change tag of goyo.vim):
  call plug#begin()
  Plug 'junegunn/goyo.vim'
  call plug#end()

Execute (PlugStatus):
  call PlugStatusSorted()

Expect:
      Invalid branch/tag: 1.5.3 (expected: master). Try PlugUpdate.
  Finished. 1 error(s).
  [=]
  x goyo.vim:

Execute (PlugUpdate to set the right branch):
  PlugUpdate
  call PlugStatusSorted()

Expect:
  - goyo.vim: OK
  Finished. 0 error(s).
  [=]

Execute (Change branch of seoul256.vim):
  call plug#begin()
  Plug 'junegunn/seoul256.vim'
  Plug 'https://bitbucket.org/junegunn/vim-emoji.git'
  call plug#end()

Execute (PlugStatus):
  call PlugStatusSorted()

Expect:
      Invalid branch/tag: no-t_co (expected: master). Try PlugUpdate.
  - vim-emoji: OK
  Finished. 1 error(s).
  [==]
  x seoul256.vim:

Execute (Change URI of seoul256.vim):
  call plug#begin()
  Plug 'junegunn.choi/seoul256.vim'
  Plug 'https://bitbucket.org/junegunn/vim-emoji.git'
  call plug#end()

Execute (PlugStatus):
  call PlugStatusSorted()

Expect:
      Expected:    https://git:@github.com/junegunn.choi/seoul256.vim.git
      Invalid URI: https://git:@github.com/junegunn/seoul256.vim.git
      PlugClean required.
  - vim-emoji: OK
  Finished. 1 error(s).
  [==]
  x seoul256.vim:

# TODO: does not work due to inputsave()
# Do (PlugClean):
#   :PlugClean\<Enter>y\<Enter>
#   ggyG
#   q
#   PGdd

Execute (PlugClean! to remove seoul256.vim):
  PlugClean!
  " Three removed, emoji left
  AssertExpect '^- ', 3
  AssertExpect 'Removed', 1
  Assert empty(globpath(&rtp, 'colors/seoul256.vim'))
  Assert !empty(globpath(&rtp, 'autoload/emoji.vim'))
  q

Execute (Change GIT URI of vim-emoji):
  call plug#begin()
  Plug 'junegunn/seoul256.vim'
  Plug 'junegunn/vim-emoji'
  call plug#end()

Execute (PlugStatus):
  call PlugStatusSorted()

Expect:
      Expected:    https://git:@github.com/junegunn/vim-emoji.git
      Invalid URI: https://bitbucket.org/junegunn/vim-emoji.git
      Not found. Try PlugInstall.
      PlugClean required.
  Finished. 2 error(s).
  [==]
  x seoul256.vim:
  x vim-emoji:

Execute (PlugClean! to remove vim-emoji):
  PlugClean!
  AssertExpect '^- ', 1
  AssertExpect 'Removed', 1
  Assert empty(globpath(&rtp, 'colors/seoul256.vim'))
  Assert empty(globpath(&rtp, 'autoload/emoji.vim'))
  q

Execute (PlugUpdate to install both again):
  PlugUpdate
  AssertExpect '^- [^:]*:', 2
  Assert !empty(globpath(&rtp, 'colors/seoul256.vim')), 'seoul256.vim should be found'
  Assert !empty(globpath(&rtp, 'autoload/emoji.vim')), 'vim-emoji should be found'
  q

Execute (PlugUpdate only to find out plugins are up-to-date, D key to check):
  PlugUpdate
  AssertExpect 'Already up-to-date', 2
  normal D
  AssertEqual 'No updates.', getline(1)
  q

Execute (PlugDiff - 'No updates.'):
  PlugDiff
  AssertEqual 'No updates.', getline(1)
  q

Execute (Rollback recent updates, PlugUpdate, then PlugDiff):
  for repo in ['seoul256.vim', 'vim-emoji']
    call system(printf('cd %s/%s && git reset HEAD^^ --hard', g:plug_home, repo))
  endfor
  PlugUpdate

  " Now we have updates
  normal D
  AssertEqual 'Last update:', getline(1)

  " Preview commit
  silent! wincmd P
  AssertEqual 0, &previewwindow

  " ]] motion
  execute 'normal ]]'
  let lnum = line('.')
  AssertEqual 3, col('.')

  " Open commit preview
  execute "normal j\<cr>"
  wincmd P
  AssertEqual 1, &previewwindow
  AssertEqual 'git', &filetype

  " Back to plug window
  wincmd p

  " ]] motion
  execute 'normal $]]'
  AssertEqual lnum + 4, line('.')
  AssertEqual 3, col('.')

  " [[ motion
  execute 'normal 0[['
  AssertEqual lnum, line('.')
  AssertEqual 3, col('.')

  " q will close preview window as well
  normal q

  " We no longer have preview window
  silent! wincmd P
  AssertEqual 0, &previewwindow

  " q should not close preview window if it's already open
  pedit
  PlugDiff
  execute "normal ]]j\<cr>"
  normal q

  silent! wincmd P
  AssertEqual 1, &previewwindow
  pclose

Execute (Plug window in a new tab):
  PlugDiff
  tab new new-tab
  set buftype=nofile
  PlugUpdate
  normal D
  AssertEqual 'No updates.', getline(1)
  q
  AssertEqual 'new-tab', expand('%')
  q
  q

**********************************************************************
~ On-demand loading / Partial installation/update ~
**********************************************************************

Execute (Trying to execute on-demand commands when plugin is not installed):
  call plug#begin()
  Plug 'junegunn/vim-easy-align', { 'on': ['EasyAlign', 'LiveEasyAlign'] }
  call plug#end()

  Assert exists(':EasyAlign')
  Assert exists(':LiveEasyAlign')
  AssertThrows EasyAlign
  AssertThrows LiveEasyAlign
  Assert !exists(':EasyAlign')
  Assert !exists(':LiveEasyAlign')

Execute (New set of plugins):
  call plug#begin()
  Plug 'junegunn/vim-fnr'
  Plug 'junegunn/vim-pseudocl'
  Plug 'junegunn/vim-easy-align', { 'on': 'EasyAlign' }
  Plug 'junegunn/vim-redis',      { 'for': 'redis' }
  call plug#end()

Execute (Check commands):
  Assert !exists(':FNR'),          'FNR command should not be found'
  Assert !exists(':RedisExecute'), 'RedisExecute command should not be found'

Execute (Partial PlugInstall):
  PlugInstall vim-fnr vim-easy-align
  AssertExpect 'vim-fnr', 1
  q

  PlugInstall vim-fnr vim-easy-align 1
  AssertExpect 'vim-fnr', 1
  AssertExpect 'vim-easy-align', 1
  AssertEqual first_rtp, split(&rtp, ',')[0]
  AssertEqual last_rtp, split(&rtp, ',')[-1]
  q

Given (Unaligned code):
  a=1
  aa=2

Execute (Check installed plugins):
  if has('vim_starting')
    Log 'Vader is run from commandline'
    runtime! plugin/**/*.vim
  endif
  Assert exists(':FNR'),           'FNR command should be found'
  Assert !exists(':RedisExecute'), 'RedisExecute command still should not be found'

  Assert exists(':EasyAlign'), 'EasyAlign command should be found'
  %EasyAlign=

Expect (Aligned code):
  a  = 1
  aa = 2

Given:
Execute (Partial PlugUpdate):
  PlugUpdate vim-redis
  q

Execute (On-demand loading based on filetypes):
  Assert !exists(':RedisExecute'), 'RedisExecute command still should not be found'
  set ft=redis
  Assert exists(':RedisExecute'), 'RedisExecute command is now found'

**********************************************************************
~ Local (unmanaged) plugins
**********************************************************************

Execute (Add unmanaged plugin):
  let fzf = fnamemodify(g:vader_file, ':h') . '/fzf'
  Log fzf

  call plug#begin()
  Plug fzf, { 'on': 'SomeCommand' }
  call plug#end()

  " Check uri field
  Assert !has_key(g:plugs.fzf, 'uri'), 'Should not have uri field'

  " Check dir field
  AssertEqual fzf.'/', g:plugs.fzf.dir

  " Trailing slashes and backslashes should be stripped
  for suffix in ['///', '/\/\/']
    call plug#begin()
    Plug fzf.suffix, { 'on': 'SomeCommand' }
    call plug#end()

    " Check dir field
    AssertEqual fzf.'/', g:plugs.fzf.dir
  endfor

Execute (Plug block for following tests):
  call plug#begin()
  Plug 'junegunn/vim-easy-align'
  Plug fzf, { 'on': 'SomeCommand' }
  call plug#end()
  " Remove plugins from previous tests
  PlugClean!

Execute (PlugInstall will only install vim-easy-align):
  PlugInstall
  Log getline(1, '$')
  AssertExpect 'fzf', 0
  q

Execute (PlugUpdate will only update vim-easy-align):
  PlugUpdate
  Log getline(1, '$')
  AssertExpect 'fzf', 0
  q

Execute (PlugClean should not care about unmanaged plugins):
  PlugClean
  Log getline(1, '$')
  AssertExpect 'fzf', 0
  q

Execute (PlugStatus should point out that the plugin is missing):
  PlugStatus
  Log getline(1, '$')
  AssertExpect 'x fzf', 1
  AssertExpect 'Not found', 1
  q

Execute (Deploy unmanaged plugin):
  Assert !exists(':FZF'), ':FZF command should not exist'
  call rename('fzf-staged', 'fzf')

Execute (PlugUpdate still should not care):
  PlugUpdate
  Log getline(1, '$')
  AssertExpect 'fzf', 0
  q

Execute (PlugStatus with no error):
  PlugStatus
  Log getline(1, '$')
  AssertExpect 'x fzf', 0
  AssertExpect 'Not found', 0
  q

Execute (Check &rtp after SomeCommand):
  Log &rtp
  Assert &rtp !~ 'fzf'
  silent! SomeCommand
  Assert &rtp =~ 'fzf'
  AssertEqual first_rtp, split(&rtp, ',')[0]
  AssertEqual last_rtp, split(&rtp, ',')[-1]

Execute (Common parent):
  call plug#begin()
  Plug 'junegunn/vim-pseudocl'
  Plug 'junegunn/vim-fnr'
  Plug 'junegunn/vim-oblique'
  call plug#end()

  PlugInstall
  Log getline(1, '$')
  AssertExpect! '[===]', 1
  q

**********************************************************************
~ Frozen plugins
**********************************************************************

Execute (Frozen plugin are not installed nor updated):
  call plug#begin()
  Plug 'junegunn/vim-easy-align', { 'frozen': 1 }
  call plug#end()

  redir => output
  silent PlugInstall
  redir END
  Assert output =~ 'No plugin to install'

  redir => output
  silent PlugUpdate
  redir END
  Assert output =~ 'No plugin to update'

Execute (But you can still install it if the name is given as the argument):
  PlugInstall vim-easy-align
  Log getline(1, '$')
  AssertEqual 1, len(filter(getline(1, '$'), 'v:val =~ "vim-easy-align"'))
  q

  PlugUpdate vim-easy-align
  Log getline(1, '$')
  AssertEqual 1, len(filter(getline(1, '$'), 'v:val =~ "vim-easy-align"'))
  q

**********************************************************************
~ Retry
**********************************************************************

Execute (Retry failed tasks):
  call plug#begin()
  Plug 'junegunn/vim-easy-align'
  Plug 'junegunn/aaaaaaaaaaaaaa'
  call plug#end()

  PlugInstall
  Log getline(1, '$')
  AssertExpect 'x aaa', 1
  AssertExpect '- vim-easy-align', 1
  normal R
  Log getline(1, '$')
  AssertExpect 'x aaa', 1
  AssertExpect '- vim-easy-align', 0
  AssertExpect! '[x]', 1
  q

  call plug#begin()
  Plug 'junegunn/vim-easy-align'
  Plug 'junegunn/aaaaaaaaaaaaaa'
  Plug 'junegunn/bbbbbbbbbbbbbb'
  Plug 'junegunn/cccccccccccccc'
  call plug#end()

  " Ruby installer
  PlugUpdate
  normal R
  AssertExpect '- vim-easy-align', 0
  AssertExpect! '[xxx]', 1
  q

  " Vim installer
  PlugUpdate 1
  normal R
  AssertExpect '- vim-easy-align', 0
  AssertExpect! '[xxx]', 1
  q

**********************************************************************
~ Post-update hook (`do` option)
**********************************************************************

Execute (Cleanup):
  call plug#begin()
  call plug#end()
  PlugClean!

Execute (On install):
  call plug#begin()
  Plug 'junegunn/vim-easy-align', { 'do': 'touch installed' }
  Plug 'junegunn/vim-pseudocl'
  call plug#end()

  PlugInstall
  q

  Assert filereadable(g:plugs['vim-easy-align'].dir.'/installed'),
    \ 'vim-easy-align/installed should exist'
  Assert !filereadable(g:plugs['vim-pseudocl'].dir.'/installed'),
    \ 'vim-pseudocl/installed should not exist'

Execute (On update):
  call plug#begin()
  Plug 'junegunn/vim-easy-align', { 'do': 'touch updated' }
  Plug 'junegunn/vim-pseudocl', { 'do': 'touch updated' }
  call plug#end()

  " Reset for updates
  call system('cd '.g:plugs['vim-pseudocl'].dir.' && git reset --hard HEAD^')

  PlugUpdate
  Log getline(1, '$')
  q

  Assert !filereadable(g:plugs['vim-easy-align'].dir.'/updated'),
    \ 'vim-easy-align/updated should not exist'
  Assert filereadable(g:plugs['vim-pseudocl'].dir.'/updated'),
    \ 'vim-pseudocl/updated should exist'

Execute (When already installed):
  call plug#begin()
  Plug 'junegunn/vim-easy-align', { 'do': 'touch installed2' }
  Plug 'junegunn/vim-pseudocl', { 'do': 'touch installed2' }
  call plug#end()

  PlugInstall
  q
  Assert !filereadable(g:plugs['vim-easy-align'].dir.'/installed2'),
    \ 'vim-easy-align/installed2 should not exist'
  Assert !filereadable(g:plugs['vim-pseudocl'].dir.'/installed2'),
    \ 'vim-pseudocl/installed2 should not exist'

Execute (PlugInstall!):
  PlugInstall!
  q
  Assert filereadable(g:plugs['vim-easy-align'].dir.'/installed2'),
    \ 'vim-easy-align/installed2 should exist'
  Assert filereadable(g:plugs['vim-pseudocl'].dir.'/installed2'),
    \ 'vim-pseudocl/installed2 should exist'

Execute (When already updated):
  call plug#begin()
  Plug 'junegunn/vim-easy-align', { 'do': 'touch updated2' }
  Plug 'junegunn/vim-pseudocl', { 'do': 'touch updated2' }
  call plug#end()

  PlugUpdate
  q
  Assert !filereadable(g:plugs['vim-easy-align'].dir.'/updated2'),
    \ 'vim-easy-align/updated2 should not exist'
  Assert !filereadable(g:plugs['vim-pseudocl'].dir.'/updated2'),
    \ 'vim-pseudocl/updated2 should not exist'

Execute (PlugUpdate!):
  PlugUpdate!
  q
  Assert filereadable(g:plugs['vim-easy-align'].dir.'/updated2'),
    \ 'vim-easy-align/updated2 should exist'
  Assert filereadable(g:plugs['vim-pseudocl'].dir.'/updated2'),
    \ 'vim-pseudocl/updated2 should exist'

Execute (Using Funcref):
  function! PlugUpdated(info)
    call system('touch '. a:info.name . a:info.status . a:info.force . len(a:info))
  endfunction

  call plug#begin()
  Plug 'junegunn/vim-easy-align', { 'do': function('PlugUpdated') }
  Plug 'junegunn/vim-pseudocl',   { 'do': function('PlugUpdated') }
  call plug#end()

  call system('cd '.g:plugs['vim-easy-align'].dir.' && git reset --hard HEAD^')
  call system('rm -rf '.g:plugs['vim-pseudocl'].dir)

  PlugUpdate
  Log getline(1, '$')
  q
  Assert filereadable(g:plugs['vim-easy-align'].dir.'/vim-easy-alignupdated03'),
    \ 'vim-easy-align/vim-easy-alignupdated03 should exist'
  Assert filereadable(g:plugs['vim-pseudocl'].dir.'/vim-pseudoclinstalled03'),
    \ 'vim-pseudocl/vim-pseudoclinstalled03 should exist'

  call system('rm -rf '.g:plugs['vim-pseudocl'].dir)
  PlugInstall!
  q
  Assert filereadable(g:plugs['vim-easy-align'].dir.'/vim-easy-alignunchanged13'),
    \ 'vim-easy-align/vim-easy-alignunchanged13 should exist'
  Assert filereadable(g:plugs['vim-pseudocl'].dir.'/vim-pseudoclinstalled13'),
    \ 'vim-pseudocl/vim-pseudoclinstalled13 should exist'

  call system('cd '.g:plugs['vim-easy-align'].dir.' && git reset --hard HEAD^')
  PlugUpdate!
  q
  Assert filereadable(g:plugs['vim-easy-align'].dir.'/vim-easy-alignupdated13'),
    \ 'vim-easy-align/vim-easy-alignupdated13 should exist'
  Assert filereadable(g:plugs['vim-pseudocl'].dir.'/vim-pseudoclunchanged13'),
    \ 'vim-pseudocl/vim-pseudoclunchanged13 should exist'

**********************************************************************
~ Overriding `dir`
**********************************************************************

Execute (Using custom dir):
  Assert isdirectory(g:plugs['vim-easy-align'].dir)

  call system('rm -rf '.$TMPDIR.'easy-align')
  call plug#begin()
  Plug 'junegunn/vim-easy-align', { 'dir': $TMPDIR.'easy-align' }
  call plug#end()
  AssertEqual $TMPDIR.'easy-align/', g:plugs['vim-easy-align'].dir

  PlugClean!
  Assert !isdirectory(g:plugs['vim-easy-align'].dir)
  q

  PlugInstall
  q
  Assert isdirectory(g:plugs['vim-easy-align'].dir)

**********************************************************************
~ On-demand loading load order
**********************************************************************
Before (Clear global vars):
  let g:xxx = []
  set rtp-=$PWD/xxx/
  set rtp-=$PWD/xxx/after

Execute (Immediate loading):
  call plug#begin()
  Plug '$PWD/xxx'
  call plug#end()

  " FIXME:
  " Different result when Vader is run from commandline with `-c` option
  Log g:xxx
  if has('vim_starting')
    AssertEqual ['/ftdetect', 'after/ftdetect'], g:xxx
  else
    AssertEqual ['/plugin', 'after/plugin', '/ftdetect', 'after/ftdetect'], g:xxx
  endif

Execute (Command-based on-demand loading):
  call plug#begin()
  Plug '$PWD/xxx', { 'on': 'XXX' }
  call plug#end()

  AssertEqual [], g:xxx

  silent! XXX
  AssertEqual ['/ftdetect', 'after/ftdetect', '/plugin', 'after/plugin'], g:xxx

  setf xxx
  AssertEqual ['/ftdetect', 'after/ftdetect', '/plugin', 'after/plugin', '/ftplugin', 'after/ftplugin', '/indent', 'after/indent', '/syntax', 'after/syntax'], g:xxx

Execute (Filetype-based on-demand loading):
  call plug#begin()
  Plug '$PWD/xxx', { 'for': 'xxx' }
  call plug#end()

  AssertEqual ['/ftdetect', 'after/ftdetect'], g:xxx

  setf xxx
  AssertEqual ['/ftdetect', 'after/ftdetect', '/plugin', 'after/plugin', '/ftplugin', 'after/ftplugin', '/indent', 'after/indent', '/syntax', 'after/syntax'], g:xxx

Before:
Execute (Cleanup):
  silent! call system('rm -rf '.temp_plugged)
  silent! call rename('fzf', 'fzf-staged')
  silent! unlet g:plugs
  silent! unlet g:plug_home
  silent! unlet temp_plugged vader plug basertp save_rtp repo lnum fzf out
  silent! delf PlugStatusSorted
  silent! delf AssertExpect
  silent! delf PlugUpdated
  silent! delc AssertExpect
  silent! unmap /
  silent! unmap ?

  Restore