mirror of
https://github.com/zsh-users/zsh
synced 2024-10-14 11:53:24 +00:00
b8dc5a7f6d
Pick number of leading or trailing path components to substitute. Active in history, brace parameters, glob qualifiers. Add tests for all three environments.
731 lines
20 KiB
Plaintext
731 lines
20 KiB
Plaintext
# Tests for globbing
|
||
|
||
%prep
|
||
mkdir glob.tmp
|
||
mkdir glob.tmp/dir{1,2,3,4}
|
||
mkdir glob.tmp/dir3/subdir
|
||
: >glob.tmp/{,{dir1,dir2}/}{a,b,c}
|
||
|
||
globtest () {
|
||
$ZTST_testdir/../Src/zsh -f $ZTST_srcdir/../Misc/$1
|
||
}
|
||
|
||
regress_absolute_path_and_core_dump() {
|
||
local absolute_dir=$(cd glob.tmp && pwd -P)
|
||
[[ -n $absolute_dir ]] || return 1
|
||
setopt localoptions extendedglob nullglob
|
||
print $absolute_dir/**/*~/*
|
||
setopt nonullglob nomatch
|
||
print glob.tmp/**/*~(.)#
|
||
}
|
||
|
||
%test
|
||
|
||
globtest globtests
|
||
0:zsh globbing
|
||
>0: [[ foo~ = foo~ ]]
|
||
>0: [[ foo~ = (foo~) ]]
|
||
>0: [[ foo~ = (foo~|) ]]
|
||
>0: [[ foo.c = *.c~boo* ]]
|
||
>1: [[ foo.c = *.c~boo*~foo* ]]
|
||
>0: [[ fofo = (fo#)# ]]
|
||
>0: [[ ffo = (fo#)# ]]
|
||
>0: [[ foooofo = (fo#)# ]]
|
||
>0: [[ foooofof = (fo#)# ]]
|
||
>0: [[ fooofoofofooo = (fo#)# ]]
|
||
>1: [[ foooofof = (fo##)# ]]
|
||
>1: [[ xfoooofof = (fo#)# ]]
|
||
>1: [[ foooofofx = (fo#)# ]]
|
||
>0: [[ ofxoofxo = ((ofo#x)#o)# ]]
|
||
>1: [[ ofooofoofofooo = (fo#)# ]]
|
||
>0: [[ foooxfooxfoxfooox = (fo#x)# ]]
|
||
>1: [[ foooxfooxofoxfooox = (fo#x)# ]]
|
||
>0: [[ foooxfooxfxfooox = (fo#x)# ]]
|
||
>0: [[ ofxoofxo = ((ofo#x)#o)# ]]
|
||
>0: [[ ofoooxoofxo = ((ofo#x)#o)# ]]
|
||
>0: [[ ofoooxoofxoofoooxoofxo = ((ofo#x)#o)# ]]
|
||
>0: [[ ofoooxoofxoofoooxoofxoo = ((ofo#x)#o)# ]]
|
||
>1: [[ ofoooxoofxoofoooxoofxofo = ((ofo#x)#o)# ]]
|
||
>0: [[ ofoooxoofxoofoooxoofxooofxofxo = ((ofo#x)#o)# ]]
|
||
>0: [[ aac = ((a))#a(c) ]]
|
||
>0: [[ ac = ((a))#a(c) ]]
|
||
>1: [[ c = ((a))#a(c) ]]
|
||
>0: [[ aaac = ((a))#a(c) ]]
|
||
>1: [[ baaac = ((a))#a(c) ]]
|
||
>0: [[ abcd = ?(a|b)c#d ]]
|
||
>0: [[ abcd = (ab|ab#)c#d ]]
|
||
>0: [[ acd = (ab|ab#)c#d ]]
|
||
>0: [[ abbcd = (ab|ab#)c#d ]]
|
||
>0: [[ effgz = (bc##d|ef#g?|(h|)i(j|k)) ]]
|
||
>0: [[ efgz = (bc##d|ef#g?|(h|)i(j|k)) ]]
|
||
>0: [[ egz = (bc##d|ef#g?|(h|)i(j|k)) ]]
|
||
>0: [[ egzefffgzbcdij = (bc##d|ef#g?|(h|)i(j|k))# ]]
|
||
>1: [[ egz = (bc##d|ef##g?|(h|)i(j|k)) ]]
|
||
>0: [[ ofoofo = (ofo##)# ]]
|
||
>0: [[ oxfoxoxfox = (oxf(ox)##)# ]]
|
||
>1: [[ oxfoxfox = (oxf(ox)##)# ]]
|
||
>0: [[ ofoofo = (ofo##|f)# ]]
|
||
>0: [[ foofoofo = (foo|f|fo)(f|ofo##)# ]]
|
||
>0: [[ oofooofo = (of|oofo##)# ]]
|
||
>0: [[ fffooofoooooffoofffooofff = (f#o#)# ]]
|
||
>1: [[ fffooofoooooffoofffooofffx = (f#o#)# ]]
|
||
>0: [[ fofoofoofofoo = (fo|foo)# ]]
|
||
>0: [[ foo = ((^x)) ]]
|
||
>0: [[ foo = ((^x)*) ]]
|
||
>1: [[ foo = ((^foo)) ]]
|
||
>0: [[ foo = ((^foo)*) ]]
|
||
>0: [[ foobar = ((^foo)) ]]
|
||
>0: [[ foobar = ((^foo)*) ]]
|
||
>1: [[ foot = z*~*x ]]
|
||
>0: [[ zoot = z*~*x ]]
|
||
>1: [[ foox = z*~*x ]]
|
||
>1: [[ zoox = z*~*x ]]
|
||
>0: [[ moo.cow = (*~*.*).(*~*.*) ]]
|
||
>1: [[ mad.moo.cow = (*~*.*).(*~*.*) ]]
|
||
>0: [[ moo.cow = (^*.*).(^*.*) ]]
|
||
>1: [[ sane.moo.cow = (^*.*).(^*.*) ]]
|
||
>1: [[ mucca.pazza = mu(^c#)?.pa(^z#)? ]]
|
||
>1: [[ _foo~ = _(|*[^~]) ]]
|
||
>0: [[ fff = ((^f)) ]]
|
||
>0: [[ fff = ((^f)#) ]]
|
||
>0: [[ fff = ((^f)##) ]]
|
||
>0: [[ ooo = ((^f)) ]]
|
||
>0: [[ ooo = ((^f)#) ]]
|
||
>0: [[ ooo = ((^f)##) ]]
|
||
>0: [[ foo = ((^f)) ]]
|
||
>0: [[ foo = ((^f)#) ]]
|
||
>0: [[ foo = ((^f)##) ]]
|
||
>1: [[ f = ((^f)) ]]
|
||
>1: [[ f = ((^f)#) ]]
|
||
>1: [[ f = ((^f)##) ]]
|
||
>0: [[ foot = (^z*|*x) ]]
|
||
>1: [[ zoot = (^z*|*x) ]]
|
||
>0: [[ foox = (^z*|*x) ]]
|
||
>0: [[ zoox = (^z*|*x) ]]
|
||
>0: [[ foo = (^foo)# ]]
|
||
>1: [[ foob = (^foo)b* ]]
|
||
>0: [[ foobb = (^foo)b* ]]
|
||
>1: [[ foob = (*~foo)b* ]]
|
||
>0: [[ foobb = (*~foo)b* ]]
|
||
>1: [[ zsh = ^z* ]]
|
||
>0: [[ a%1X = [[:alpha:][:punct:]]#[[:digit:]][^[:lower:]] ]]
|
||
>1: [[ a%1 = [[:alpha:][:punct:]]#[[:digit:]][^[:lower:]] ]]
|
||
>0: [[ [: = [[:]# ]]
|
||
>0: [[ :] = []:]# ]]
|
||
>0: [[ :] = [:]]# ]]
|
||
>0: [[ [ = [[] ]]
|
||
>0: [[ ] = []] ]]
|
||
>0: [[ [] = [^]]] ]]
|
||
>0: [[ fooxx = (#i)FOOXX ]]
|
||
>1: [[ fooxx = (#l)FOOXX ]]
|
||
>0: [[ FOOXX = (#l)fooxx ]]
|
||
>1: [[ fooxx = (#i)FOO(#I)X(#i)X ]]
|
||
>0: [[ fooXx = (#i)FOO(#I)X(#i)X ]]
|
||
>0: [[ fooxx = ((#i)FOOX)x ]]
|
||
>1: [[ fooxx = ((#i)FOOX)X ]]
|
||
>1: [[ BAR = (bar|(#i)foo) ]]
|
||
>0: [[ FOO = (bar|(#i)foo) ]]
|
||
>0: [[ Modules = (#i)*m* ]]
|
||
>0: [[ fooGRUD = (#i)(bar|(#I)foo|(#i)rod)grud ]]
|
||
>1: [[ FOOGRUD = (#i)(bar|(#I)foo|(#i)rod)grud ]]
|
||
>0: [[ readme = (#i)readme~README|readme ]]
|
||
>0: [[ readme = (#i)readme~README|readme~README ]]
|
||
>0: [[ 633 = <1-1000>33 ]]
|
||
>0: [[ 633 = <-1000>33 ]]
|
||
>0: [[ 633 = <1->33 ]]
|
||
>0: [[ 633 = <->33 ]]
|
||
>0: [[ 12345678901234567890123456789012345678901234567890123456789012345678901234567890foo = <42->foo ]]
|
||
>0: [[ READ.ME = (#ia1)readme ]]
|
||
>1: [[ READ..ME = (#ia1)readme ]]
|
||
>0: [[ README = (#ia1)readm ]]
|
||
>0: [[ READM = (#ia1)readme ]]
|
||
>0: [[ README = (#ia1)eadme ]]
|
||
>0: [[ EADME = (#ia1)readme ]]
|
||
>0: [[ READEM = (#ia1)readme ]]
|
||
>1: [[ ADME = (#ia1)readme ]]
|
||
>1: [[ README = (#ia1)read ]]
|
||
>0: [[ bob = (#a1)[b][b] ]]
|
||
>1: [[ bob = (#a1)[b][b]a ]]
|
||
>0: [[ bob = (#a1)[b]o[b]a ]]
|
||
>1: [[ bob = (#a1)[c]o[b] ]]
|
||
>0: [[ abcd = (#a2)XbcX ]]
|
||
>0: [[ abcd = (#a2)ad ]]
|
||
>0: [[ ad = (#a2)abcd ]]
|
||
>0: [[ abcd = (#a2)bd ]]
|
||
>0: [[ bd = (#a2)abcd ]]
|
||
>0: [[ badc = (#a2)abcd ]]
|
||
>0: [[ adbc = (#a2)abcd ]]
|
||
>1: [[ dcba = (#a2)abcd ]]
|
||
>0: [[ dcba = (#a3)abcd ]]
|
||
>0: [[ aabaXaaabY = (#a1)(a#b)#Y ]]
|
||
>0: [[ aabaXaaabY = (#a1)(a#b)(a#b)Y ]]
|
||
>0: [[ aaXaaaaabY = (#a1)(a#b)(a#b)Y ]]
|
||
>0: [[ aaaXaaabY = (#a1)(a##b)##Y ]]
|
||
>0: [[ aaaXbaabY = (#a1)(a##b)##Y ]]
|
||
>1: [[ read.me = (#ia1)README~READ.ME ]]
|
||
>0: [[ read.me = (#ia1)README~READ_ME ]]
|
||
>1: [[ read.me = (#ia1)README~(#a1)READ_ME ]]
|
||
>0: [[ test = *((#s)|/)test((#e)|/)* ]]
|
||
>0: [[ test/path = *((#s)|/)test((#e)|/)* ]]
|
||
>0: [[ path/test = *((#s)|/)test((#e)|/)* ]]
|
||
>0: [[ path/test/ohyes = *((#s)|/)test((#e)|/)* ]]
|
||
>1: [[ atest = *((#s)|/)test((#e)|/)* ]]
|
||
>1: [[ testy = *((#s)|/)test((#e)|/)* ]]
|
||
>1: [[ testy/path = *((#s)|/)test((#e)|/)* ]]
|
||
>1: [[ path/atest = *((#s)|/)test((#e)|/)* ]]
|
||
>1: [[ atest/path = *((#s)|/)test((#e)|/)* ]]
|
||
>1: [[ path/testy = *((#s)|/)test((#e)|/)* ]]
|
||
>1: [[ path/testy/ohyes = *((#s)|/)test((#e)|/)* ]]
|
||
>1: [[ path/atest/ohyes = *((#s)|/)test((#e)|/)* ]]
|
||
>0: [[ XabcdabcY = X(ab|c|d)(#c5)Y ]]
|
||
>0: [[ XabcdabcY = X(ab|c|d)(#c1,5)Y ]]
|
||
>0: [[ XabcdabcY = X(ab|c|d)(#c5,8)Y ]]
|
||
>0: [[ XabcdabcY = X(ab|c|d)(#c4,)Y ]]
|
||
>1: [[ XabcdabcY = X(ab|c|d)(#c6,)Y ]]
|
||
>1: [[ XabcdabcY = X(ab|c|d)(#c1,4)Y ]]
|
||
>0: [[ ZX = Z(|)(#c1)X ]]
|
||
>0: [[ froofroo = (fro(#c2))(#c2) ]]
|
||
>1: [[ froofroofroo = (fro(#c2))(#c2) ]]
|
||
>1: [[ froofro = (fro(#c2))(#c2) ]]
|
||
>0: [[ ax = ?(#c1,2)x ]]
|
||
>0: [[ ax = ?(#c1,)x ]]
|
||
>0: [[ ax = ?(#c0,1)x ]]
|
||
>1: [[ ax = ?(#c0,0)x ]]
|
||
>1: [[ ax = ?(#c2,)x ]]
|
||
>0: [[ aa = a(#c1,2)a ]]
|
||
>0: [[ aa = a(#c1,)a ]]
|
||
>0: [[ aa = a(#c0,1)a ]]
|
||
>1: [[ aa = a(#c0,0)a ]]
|
||
>1: [[ aa = a(#c2,)a ]]
|
||
>0: [[ test.zsh = *.?(#c1)sh ]]
|
||
>0: [[ test.bash = *.?(#c2)sh ]]
|
||
>0: [[ test.bash = *.?(#c1,2)sh ]]
|
||
>0: [[ test.bash = *.?(#c1,)sh ]]
|
||
>0: [[ test.zsh = *.?(#c1,)sh ]]
|
||
>0 tests failed.
|
||
|
||
globtest globtests.ksh
|
||
0:ksh compatibility
|
||
>0: [[ fofo = *(f*(o)) ]]
|
||
>0: [[ ffo = *(f*(o)) ]]
|
||
>0: [[ foooofo = *(f*(o)) ]]
|
||
>0: [[ foooofof = *(f*(o)) ]]
|
||
>0: [[ fooofoofofooo = *(f*(o)) ]]
|
||
>1: [[ foooofof = *(f+(o)) ]]
|
||
>1: [[ xfoooofof = *(f*(o)) ]]
|
||
>1: [[ foooofofx = *(f*(o)) ]]
|
||
>0: [[ ofxoofxo = *(*(of*(o)x)o) ]]
|
||
>1: [[ ofooofoofofooo = *(f*(o)) ]]
|
||
>0: [[ foooxfooxfoxfooox = *(f*(o)x) ]]
|
||
>1: [[ foooxfooxofoxfooox = *(f*(o)x) ]]
|
||
>0: [[ foooxfooxfxfooox = *(f*(o)x) ]]
|
||
>0: [[ ofxoofxo = *(*(of*(o)x)o) ]]
|
||
>0: [[ ofoooxoofxo = *(*(of*(o)x)o) ]]
|
||
>0: [[ ofoooxoofxoofoooxoofxo = *(*(of*(o)x)o) ]]
|
||
>0: [[ ofoooxoofxoofoooxoofxoo = *(*(of*(o)x)o) ]]
|
||
>1: [[ ofoooxoofxoofoooxoofxofo = *(*(of*(o)x)o) ]]
|
||
>0: [[ ofoooxoofxoofoooxoofxooofxofxo = *(*(of*(o)x)o) ]]
|
||
>0: [[ aac = *(@(a))a@(c) ]]
|
||
>0: [[ ac = *(@(a))a@(c) ]]
|
||
>1: [[ c = *(@(a))a@(c) ]]
|
||
>0: [[ aaac = *(@(a))a@(c) ]]
|
||
>1: [[ baaac = *(@(a))a@(c) ]]
|
||
>0: [[ abcd = ?@(a|b)*@(c)d ]]
|
||
>0: [[ abcd = @(ab|a*@(b))*(c)d ]]
|
||
>0: [[ acd = @(ab|a*(b))*(c)d ]]
|
||
>0: [[ abbcd = @(ab|a*(b))*(c)d ]]
|
||
>0: [[ effgz = @(b+(c)d|e*(f)g?|?(h)i@(j|k)) ]]
|
||
>0: [[ efgz = @(b+(c)d|e*(f)g?|?(h)i@(j|k)) ]]
|
||
>0: [[ egz = @(b+(c)d|e*(f)g?|?(h)i@(j|k)) ]]
|
||
>0: [[ egzefffgzbcdij = *(b+(c)d|e*(f)g?|?(h)i@(j|k)) ]]
|
||
>1: [[ egz = @(b+(c)d|e+(f)g?|?(h)i@(j|k)) ]]
|
||
>0: [[ ofoofo = *(of+(o)) ]]
|
||
>0: [[ oxfoxoxfox = *(oxf+(ox)) ]]
|
||
>1: [[ oxfoxfox = *(oxf+(ox)) ]]
|
||
>0: [[ ofoofo = *(of+(o)|f) ]]
|
||
>0: [[ foofoofo = @(foo|f|fo)*(f|of+(o)) ]]
|
||
>0: [[ oofooofo = *(of|oof+(o)) ]]
|
||
>0: [[ fffooofoooooffoofffooofff = *(*(f)*(o)) ]]
|
||
>1: [[ fffooofoooooffoofffooofffx = *(*(f)*(o)) ]]
|
||
>0: [[ fofoofoofofoo = *(fo|foo) ]]
|
||
>0: [[ foo = !(x) ]]
|
||
>0: [[ foo = !(x)* ]]
|
||
>1: [[ foo = !(foo) ]]
|
||
>0: [[ foo = !(foo)* ]]
|
||
>0: [[ foobar = !(foo) ]]
|
||
>0: [[ foobar = !(foo)* ]]
|
||
>0: [[ moo.cow = !(*.*).!(*.*) ]]
|
||
>1: [[ mad.moo.cow = !(*.*).!(*.*) ]]
|
||
>1: [[ mucca.pazza = mu!(*(c))?.pa!(*(z))? ]]
|
||
>1: [[ _foo~ = _?(*[^~]) ]]
|
||
>0: [[ fff = !(f) ]]
|
||
>0: [[ fff = *(!(f)) ]]
|
||
>0: [[ fff = +(!(f)) ]]
|
||
>0: [[ ooo = !(f) ]]
|
||
>0: [[ ooo = *(!(f)) ]]
|
||
>0: [[ ooo = +(!(f)) ]]
|
||
>0: [[ foo = !(f) ]]
|
||
>0: [[ foo = *(!(f)) ]]
|
||
>0: [[ foo = +(!(f)) ]]
|
||
>1: [[ f = !(f) ]]
|
||
>1: [[ f = *(!(f)) ]]
|
||
>1: [[ f = +(!(f)) ]]
|
||
>0: [[ foot = @(!(z*)|*x) ]]
|
||
>1: [[ zoot = @(!(z*)|*x) ]]
|
||
>0: [[ foox = @(!(z*)|*x) ]]
|
||
>0: [[ zoox = @(!(z*)|*x) ]]
|
||
>0: [[ foo = *(!(foo)) ]]
|
||
>1: [[ foob = !(foo)b* ]]
|
||
>0: [[ foobb = !(foo)b* ]]
|
||
>0: [[ fooxx = (#i)FOOXX ]]
|
||
>1: [[ fooxx = (#l)FOOXX ]]
|
||
>0: [[ FOOXX = (#l)fooxx ]]
|
||
>1: [[ fooxx = (#i)FOO@(#I)X@(#i)X ]]
|
||
>0: [[ fooXx = (#i)FOO@(#I)X@(#i)X ]]
|
||
>0: [[ fooxx = @((#i)FOOX)x ]]
|
||
>1: [[ fooxx = @((#i)FOOX)X ]]
|
||
>1: [[ BAR = @(bar|(#i)foo) ]]
|
||
>0: [[ FOO = @(bar|(#i)foo) ]]
|
||
>0: [[ Modules = (#i)*m* ]]
|
||
>0 tests failed.
|
||
|
||
(unsetopt multibyte
|
||
[[ bj<62>rn = *[<5B><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>]* ]])
|
||
0:single byte match with top bit set
|
||
|
||
( regress_absolute_path_and_core_dump )
|
||
0:exclusions regression test
|
||
>
|
||
>glob.tmp/a glob.tmp/b glob.tmp/c glob.tmp/dir1 glob.tmp/dir1/a glob.tmp/dir1/b glob.tmp/dir1/c glob.tmp/dir2 glob.tmp/dir2/a glob.tmp/dir2/b glob.tmp/dir2/c glob.tmp/dir3 glob.tmp/dir3/subdir glob.tmp/dir4
|
||
|
||
print glob.tmp/*(/)
|
||
0:Just directories
|
||
>glob.tmp/dir1 glob.tmp/dir2 glob.tmp/dir3 glob.tmp/dir4
|
||
|
||
print glob.tmp/*(.)
|
||
0:Just files
|
||
>glob.tmp/a glob.tmp/b glob.tmp/c
|
||
|
||
print glob.tmp/*(.e^'reply=( glob.tmp/*/${REPLY:t} )'^:t)
|
||
0:Globbing used recursively (inside e glob qualifier)
|
||
>a a b b c c
|
||
|
||
print glob.tmp/*/*(e:'reply=( glob.tmp/**/*([1]) )'::t)
|
||
0:Recursive globbing used recursively (inside e glob qualifier)
|
||
>a a a a a a a
|
||
|
||
print glob.tmp/**/(:h)
|
||
0:Head modifier
|
||
>. glob.tmp glob.tmp glob.tmp glob.tmp glob.tmp/dir3
|
||
|
||
print glob.tmp(:r)
|
||
0:Remove extension modifier
|
||
>glob
|
||
|
||
print glob.tmp/*(:s/./_/)
|
||
0:Substitute modifier
|
||
>glob_tmp/a glob_tmp/b glob_tmp/c glob_tmp/dir1 glob_tmp/dir2 glob_tmp/dir3 glob_tmp/dir4
|
||
|
||
print glob.tmp/*(F)
|
||
0:Just full dirs
|
||
>glob.tmp/dir1 glob.tmp/dir2 glob.tmp/dir3
|
||
|
||
print glob.tmp/*(^F)
|
||
0:Omit full dirs
|
||
>glob.tmp/a glob.tmp/b glob.tmp/c glob.tmp/dir4
|
||
|
||
print glob.tmp/*(/^F)
|
||
0:Just empty dirs
|
||
>glob.tmp/dir4
|
||
|
||
setopt extendedglob
|
||
print glob.tmp/**/*~*/dir3(/*|(#e))(/)
|
||
0:Exclusions with complicated path specifications
|
||
>glob.tmp/dir1 glob.tmp/dir2 glob.tmp/dir4
|
||
|
||
print -l -- glob.tmp/*(P:-f:)
|
||
0:Prepending words to each argument
|
||
>-f
|
||
>glob.tmp/a
|
||
>-f
|
||
>glob.tmp/b
|
||
>-f
|
||
>glob.tmp/c
|
||
>-f
|
||
>glob.tmp/dir1
|
||
>-f
|
||
>glob.tmp/dir2
|
||
>-f
|
||
>glob.tmp/dir3
|
||
>-f
|
||
>glob.tmp/dir4
|
||
|
||
print -l -- glob.tmp/*(P:one word:P:another word:)
|
||
0:Prepending two words to each argument
|
||
>one word
|
||
>another word
|
||
>glob.tmp/a
|
||
>one word
|
||
>another word
|
||
>glob.tmp/b
|
||
>one word
|
||
>another word
|
||
>glob.tmp/c
|
||
>one word
|
||
>another word
|
||
>glob.tmp/dir1
|
||
>one word
|
||
>another word
|
||
>glob.tmp/dir2
|
||
>one word
|
||
>another word
|
||
>glob.tmp/dir3
|
||
>one word
|
||
>another word
|
||
>glob.tmp/dir4
|
||
|
||
[[ "" = "" ]] && echo OK
|
||
0:Empty strings
|
||
>OK
|
||
|
||
foo="this string has a : colon in it"
|
||
print ${foo%% #:*}
|
||
0:Must-match arguments in complex patterns
|
||
>this string has a
|
||
|
||
mkdir glob.tmp/ra=1.0_et=3.5
|
||
touch glob.tmp/ra=1.0_et=3.5/foo
|
||
print glob.tmp/ra=1.0_et=3.5/???
|
||
0:Bug with intermediate paths with plain strings but tokenized characters
|
||
>glob.tmp/ra=1.0_et=3.5/foo
|
||
|
||
doesmatch() {
|
||
setopt localoptions extendedglob
|
||
print -n $1 $2\
|
||
if [[ $1 = $~2 ]]; then print yes; else print no; fi;
|
||
}
|
||
doesmatch MY_IDENTIFIER '[[:IDENT:]]##'
|
||
doesmatch YOUR:IDENTIFIER '[[:IDENT:]]##'
|
||
IFS=$'\n' doesmatch $'\n' '[[:IFS:]]'
|
||
IFS=' ' doesmatch $'\n' '[[:IFS:]]'
|
||
IFS=':' doesmatch : '[[:IFSSPACE:]]'
|
||
IFS=' ' doesmatch ' ' '[[:IFSSPACE:]]'
|
||
WORDCHARS="" doesmatch / '[[:WORD:]]'
|
||
WORDCHARS="/" doesmatch / '[[:WORD:]]'
|
||
0:Named character sets handled internally
|
||
>MY_IDENTIFIER [[:IDENT:]]## yes
|
||
>YOUR:IDENTIFIER [[:IDENT:]]## no
|
||
>
|
||
> [[:IFS:]] yes
|
||
>
|
||
> [[:IFS:]] no
|
||
>: [[:IFSSPACE:]] no
|
||
> [[:IFSSPACE:]] yes
|
||
>/ [[:WORD:]] no
|
||
>/ [[:WORD:]] yes
|
||
|
||
[[ foo = (#c0)foo ]]
|
||
2:Misplaced (#c...) flag
|
||
?(eval):1: bad pattern: (#c0)foo
|
||
|
||
mkdir glob.tmp/dir5
|
||
touch glob.tmp/dir5/N123
|
||
print glob.tmp/dir5/N<->(N)
|
||
rm -rf glob.tmp/dir5
|
||
0:Numeric glob is not usurped by process substitution.
|
||
>glob.tmp/dir5/N123
|
||
|
||
tpd() {
|
||
[[ $1 = $~2 ]]
|
||
print -r "$1, $2: $?"
|
||
}
|
||
test_pattern_disables() {
|
||
emulate -L zsh
|
||
tpd 'forthcoming' 'f*g'
|
||
disable -p '*'
|
||
tpd 'forthcoming' 'f*g'
|
||
tpd 'f*g' 'f*g'
|
||
tpd '[frog]' '[frog]'
|
||
tpd '[frog]' '\[[f]rog\]'
|
||
disable -p '['
|
||
tpd '[frog]' '[frog]'
|
||
tpd '[frog]' '\[[f]rog\]'
|
||
setopt extendedglob
|
||
tpd 'foo' '^bar'
|
||
disable -p '^'
|
||
tpd 'foo' '^bar'
|
||
tpd '^bar' '^bar'
|
||
tpd 'rumble' '(rumble|bluster)'
|
||
tpd '(thunder)' '(thunder)'
|
||
disable -p '('
|
||
tpd 'rumble' '(rumble|bluster)'
|
||
tpd '(thunder)' '(thunder)'
|
||
setopt kshglob
|
||
tpd 'scramble' '@(panic|frenzy|scramble)'
|
||
tpd '@(scrimf)' '@(scrimf)'
|
||
disable -p '@('
|
||
tpd 'scramble' '@(panic|frenzy|scramble)'
|
||
tpd '@(scrimf)' '@(scrimf)'
|
||
disable -p
|
||
}
|
||
test_pattern_disables
|
||
print Nothing should be disabled.
|
||
disable -p
|
||
0:disable -p
|
||
>forthcoming, f*g: 0
|
||
>forthcoming, f*g: 1
|
||
>f*g, f*g: 0
|
||
>[frog], [frog]: 1
|
||
>[frog], \[[f]rog\]: 0
|
||
>[frog], [frog]: 0
|
||
>[frog], \[[f]rog\]: 1
|
||
>foo, ^bar: 0
|
||
>foo, ^bar: 1
|
||
>^bar, ^bar: 0
|
||
>rumble, (rumble|bluster): 0
|
||
>(thunder), (thunder): 1
|
||
>rumble, (rumble|bluster): 1
|
||
>(thunder), (thunder): 0
|
||
>scramble, @(panic|frenzy|scramble): 0
|
||
>@(scrimf), @(scrimf): 1
|
||
>scramble, @(panic|frenzy|scramble): 1
|
||
>@(scrimf), @(scrimf): 0
|
||
>'(' '*' '[' '^' '@('
|
||
>Nothing should be disabled.
|
||
|
||
(
|
||
setopt nomatch
|
||
x=( '' )
|
||
print $^x(N)
|
||
)
|
||
0:No error with empty null glob with (N).
|
||
>
|
||
|
||
(setopt kshglob
|
||
test_array=(
|
||
'+fours' '+*'
|
||
'@titude' '@*'
|
||
'!bang' '!*'
|
||
# and check they work in the real kshglob cases too...
|
||
'+bus+bus' '+(+bus|-car)'
|
||
'@sinhats' '@(@sinhats|wrensinfens)'
|
||
'!kerror' '!(!somethingelse)'
|
||
# and these don't match, to be sure
|
||
'+more' '+(+less)'
|
||
'@all@all' '@(@all)'
|
||
'!goesitall' '!(!goesitall)'
|
||
)
|
||
for str pat in $test_array; do
|
||
eval "[[ $str = $pat ]]" && print "$str matches $pat"
|
||
done
|
||
true
|
||
)
|
||
0:kshglob option does not break +, @, ! without following open parenthesis
|
||
>+fours matches +*
|
||
>@titude matches @*
|
||
>!bang matches !*
|
||
>+bus+bus matches +(+bus|-car)
|
||
>@sinhats matches @(@sinhats|wrensinfens)
|
||
>!kerror matches !(!somethingelse)
|
||
|
||
(
|
||
setopt extendedglob
|
||
cd glob.tmp
|
||
[[ -n a*(#qN) ]] && print File beginning with a
|
||
[[ -z z*(#qN) ]] && print No file beginning with z
|
||
setopt nonomatch
|
||
[[ -n z*(#q) ]] && print Normal string if nullglob not set
|
||
)
|
||
0:Force glob expansion in conditions using (#q)
|
||
>File beginning with a
|
||
>No file beginning with z
|
||
>Normal string if nullglob not set
|
||
|
||
(){ print $#@ } glob.tmp/dir*(Y1)
|
||
(){ print $#@ } glob.tmp/file*(NY1)
|
||
(){ [[ "$*" == */dir?\ */dir? ]] && print Returns matching filenames } glob.tmp/dir*(Y2)
|
||
(){ print "Limit is upper bound:" ${(o)@:t} } glob.tmp/dir*(Y5)
|
||
(){ print "Negated:" $@:t } glob.tmp/dir*(Y1^Y)
|
||
(){ print "Sorting:" $@:t } glob.tmp/dir*(Y4On)
|
||
(){ [[ $#@ -eq 1 ]] && print Globs before last path component } glob.tmp/dir?/subdir(NY1)
|
||
(){ [[ $1 == glob.tmp/a ]] } glob.tmp/**/a(Y1) && print Breadth first
|
||
(){ [[ $#@ -eq 0 ]] && print Respects qualifiers } glob.tmp/dir*(NY1.)
|
||
(print -- *(Y)) 2>/dev/null || print "Argument required"
|
||
0:short-circuit modifier
|
||
>1
|
||
>0
|
||
>Returns matching filenames
|
||
>Limit is upper bound: dir1 dir2 dir3 dir4
|
||
>Negated: dir1 dir2 dir3 dir4
|
||
>Sorting: dir4 dir3 dir2 dir1
|
||
>Globs before last path component
|
||
>Breadth first
|
||
>Respects qualifiers
|
||
>Argument required
|
||
|
||
[[ "ce fichier n'existe pas" = (#b)ce\ (f[^ ]#)\ *s(#q./) ]]
|
||
print $match[1]
|
||
0:(#q) is ignored completely in conditional pattern matching
|
||
>fichier
|
||
|
||
# The following should not cause excessive slowdown.
|
||
print glob.tmp/*.*
|
||
print glob.tmp/**************************.*************************
|
||
0:Optimisation to squeeze multiple *'s used as ordinary glob wildcards.
|
||
>glob.tmp/ra=1.0_et=3.5
|
||
>glob.tmp/ra=1.0_et=3.5
|
||
|
||
[[ 1_2_ = (*_)(#c1) ]] && print 1 OK # because * matches 1_2
|
||
[[ 1_2_ = (*_)(#c2) ]] && print 2 OK
|
||
[[ 1_2_ = (*_)(#c3) ]] || print 3 OK
|
||
0:Some more complicated backtracking with match counts.
|
||
>1 OK
|
||
>2 OK
|
||
>3 OK
|
||
|
||
[[ foo = 'f'\o"o" ]]
|
||
0:Stripping of quotes from patterns (1)
|
||
|
||
[[ foo = 'f'('o'|'a')('o'|'b') ]]
|
||
0:Stripping of quotes from patterns (2)
|
||
|
||
[[ fob = 'f'('o'|'a')('o'|'b') ]]
|
||
0:Stripping of quotes from patterns (3)
|
||
|
||
[[ fab = 'f'('o'|'a')('o'|'b') ]]
|
||
0:Stripping of quotes from patterns (4)
|
||
|
||
[[ fib != 'f'('o'|'a')('o'|'b') ]]
|
||
0:Stripping of quotes from patterns (4)
|
||
|
||
[[ - != [a-z] ]]
|
||
0:- is a special character in ranges
|
||
|
||
[[ - = ['a-z'] ]]
|
||
0:- is not a special character in ranges if quoted
|
||
|
||
[[ b-1 = [a-z]-[0-9] ]]
|
||
0:- untokenized following a bracketed subexpression
|
||
|
||
[[ b-1 = []a-z]-[]0-9] ]]
|
||
0:- "]" after "[" is normal range character and - still works
|
||
|
||
headremove="bcdef"
|
||
print ${headremove#[a-z]}
|
||
0:active - works in pattern in parameter
|
||
>cdef
|
||
|
||
headremove="bcdef"
|
||
print ${headremove#['a-z']}
|
||
headremove="-cdef"
|
||
print ${headremove#['a-z']}
|
||
0:quoted - works in pattern in parameter
|
||
>bcdef
|
||
>cdef
|
||
|
||
[[ a != [^a] ]]
|
||
0:^ active in character class if not quoted
|
||
|
||
[[ a = ['^a'] ]]
|
||
0:^ not active in character class if quoted
|
||
|
||
[[ a != [!a] ]]
|
||
0:! active in character class if not quoted
|
||
|
||
[[ a = ['!a'] ]]
|
||
0:! not active in character class if quoted
|
||
|
||
# Actually, we don't need the quoting here,
|
||
# c.f. the next test. This just makes it look
|
||
# more standard.
|
||
cset="^a-z"
|
||
[[ "^" = ["$cset"] ]] || print Fail 1
|
||
[[ "a" = ["$cset"] ]] || print Fail 2
|
||
[[ "-" = ["$cset"] ]] || print Fail 3
|
||
[[ "z" = ["$cset"] ]] || print Fail 4
|
||
[[ "1" != ["$cset"] ]] || print Fail 5
|
||
[[ "b" != ["$cset"] ]] || print Fail 6
|
||
0:character set specified as quoted variable
|
||
|
||
cset="^a-z"
|
||
[[ "^" = [$~cset] ]] || print Fail 1
|
||
[[ "a" != [$~cset] ]] || print Fail 2
|
||
[[ "-" = [$~cset] ]] || print Fail 3
|
||
[[ "z" != [$~cset] ]] || print Fail 4
|
||
[[ "1" = [$~cset] ]] || print Fail 5
|
||
[[ "b" != [$~cset] ]] || print Fail 6
|
||
0:character set specified as active variable
|
||
|
||
() { print -l -- $@:a } / /..{,/} /1 /nonexistent/..{,/} /deeper/nonexistent/..{,/}
|
||
0:modifier ':a' doesn't require existence
|
||
>/
|
||
>/
|
||
>/
|
||
>/1
|
||
>/
|
||
>/
|
||
>/deeper
|
||
>/deeper
|
||
|
||
() { set -- ${PWD}/$^@; print -l -- $@:A } glob.tmp/nonexistent/foo/bar/baz
|
||
0:modifier ':A' doesn't require existence
|
||
*>*/glob.tmp/nonexistent/foo/bar/baz
|
||
|
||
ln -s dir3/subdir glob.tmp/link
|
||
() {
|
||
print ${1:A} | grep glob.tmp
|
||
} glob.tmp/link/../../hello
|
||
rm glob.tmp/link
|
||
0:modifier ':A' resolves '..' components before symlinks
|
||
# There should be no output
|
||
|
||
ln -s dir3/subdir glob.tmp/link
|
||
() {
|
||
print ${1:P}
|
||
} glob.tmp/link/../../hello/world
|
||
rm glob.tmp/link
|
||
0:modifier ':P' resolves symlinks before '..' components
|
||
*>*glob.tmp/hello/world
|
||
|
||
# This is a bit brittle as it depends on PATH_MAX.
|
||
# We could use sysconf..
|
||
bad_pwd="/${(l:16000:: :):-}"
|
||
print ${bad_pwd:P}
|
||
0:modifier ':P' with path too long
|
||
?(eval):4: path expansion failed, using root directory
|
||
>/
|
||
|
||
foo=a
|
||
value="ac"
|
||
print ${value//[${foo}b-z]/x}
|
||
0:handling of - range in complicated pattern context
|
||
>xx
|
||
|
||
pathtotest=glob.tmp/my/test/dir/that/does/not/exist
|
||
mkdir -p $pathtotest
|
||
print $pathtotest(:h)
|
||
print $pathtotest(:h0)
|
||
print $pathtotest(:h10)
|
||
print $pathtotest(:h3)
|
||
print $pathtotest(:h2)
|
||
print $pathtotest(:h1)
|
||
print $pathtotest(:t)
|
||
print $pathtotest(:t0)
|
||
print $pathtotest(:t10)
|
||
print $pathtotest(:t3)
|
||
print $pathtotest(:t2)
|
||
print $pathtotest(:t1)
|
||
0:modifiers :h and :t with numbers (main test is in D04parameter.ztst)
|
||
>glob.tmp/my/test/dir/that/does/not
|
||
>glob.tmp/my/test/dir/that/does/not
|
||
>glob.tmp/my/test/dir/that/does/not/exist
|
||
>glob.tmp/my/test
|
||
>glob.tmp/my
|
||
>glob.tmp
|
||
>exist
|
||
>exist
|
||
>glob.tmp/my/test/dir/that/does/not/exist
|
||
>does/not/exist
|
||
>not/exist
|
||
>exist
|