about summary refs log tree commit diff
path: root/Misc/globtests
blob: b7d5fd0bd7b518abe5f5f2b824945950a160ff22 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
#!/usr/local/bin/zsh -f

setopt extendedglob badpattern
unsetopt kshglob

failed=0
while read res str pat; do
  [[ $res = '#' ]] && continue
  [[ $str = ${~pat} ]]
  ts=$?
  [[ $1 = -q ]] || print "$ts:  [[ $str = $pat ]]"
  if [[ ( $ts -gt 0 && $res = t) || ($ts -eq 0 && $res = f) ]]; then
    print "Test failed:  [[ $str = $pat ]]"
    (( failed++ ))
  fi
done <<EOT
t fofo                (fo#)#
t ffo                 (fo#)#
t foooofo             (fo#)#
t foooofof            (fo#)#
t fooofoofofooo       (fo#)#
f foooofof            (fo##)#
f xfoooofof           (fo#)#
f foooofofx           (fo#)#
t ofxoofxo            ((ofo#x)#o)#
f ofooofoofofooo      (fo#)#
t foooxfooxfoxfooox   (fo#x)#
f foooxfooxofoxfooox  (fo#x)#
t foooxfooxfxfooox    (fo#x)#
t ofxoofxo            ((ofo#x)#o)#
t ofoooxoofxo         ((ofo#x)#o)#
t ofoooxoofxoofoooxoofxo            ((ofo#x)#o)#
t ofoooxoofxoofoooxoofxoo           ((ofo#x)#o)#
f ofoooxoofxoofoooxoofxofo          ((ofo#x)#o)#
t ofoooxoofxoofoooxoofxooofxofxo    ((ofo#x)#o)#
t aac    ((a))#a(c)
t ac     ((a))#a(c)
f c      ((a))#a(c)
t aaac   ((a))#a(c)
f baaac  ((a))#a(c)
t abcd   ?(a|b)c#d
t abcd   (ab|ab#)c#d
t acd    (ab|ab#)c#d
t abbcd  (ab|ab#)c#d
t effgz  (bc##d|ef#g?|(h|)i(j|k))
t efgz   (bc##d|ef#g?|(h|)i(j|k))
t egz    (bc##d|ef#g?|(h|)i(j|k))
t egzefffgzbcdij    (bc##d|ef#g?|(h|)i(j|k))#
f egz    (bc##d|ef##g?|(h|)i(j|k))
t ofoofo (ofo##)#
t oxfoxoxfox    (oxf(ox)##)#
f oxfoxfox      (oxf(ox)##)#
t ofoofo        (ofo##|f)#
# The following is supposed to match only as fo+ofo+ofo
t foofoofo      (foo|f|fo)(f|ofo##)#
t oofooofo      (of|oofo##)#
t fffooofoooooffoofffooofff     (f#o#)#
# If the following is really slow, that's a bug.
f fffooofoooooffoofffooofffx     (f#o#)#
# The following tests backtracking in alternation matches
t fofoofoofofoo (fo|foo)#
# Exclusion: test both types
t foo           ((^x))
t foo           ((^x)*)
f foo           ((^foo))
t foo           ((^foo)*)
t foobar        ((^foo))
t foobar        ((^foo)*)
f foot          z*~*x
t zoot          z*~*x
f foox          z*~*x
f zoox          z*~*x
t moo.cow       (*~*.*).(*~*.*)
f mad.moo.cow   (*~*.*).(*~*.*)
t moo.cow       (^*.*).(^*.*)
f sane.moo.cow  (^*.*).(^*.*)
f mucca.pazza   mu(^c#)?.pa(^z#)?
t fff           ((^f))
t fff           ((^f)#)
t fff           ((^f)##)
t ooo           ((^f))
t ooo           ((^f)#)
t ooo           ((^f)##)
t foo           ((^f))
t foo           ((^f)#)
t foo           ((^f)##)
f f             ((^f))
f f             ((^f)#)
f f             ((^f)##)
t foot          (^z*|*x)
f zoot          (^z*|*x)
t foox          (^z*|*x)
t zoox          (^z*|*x)
t foo           (^foo)#
f foob          (^foo)b*
t foobb         (^foo)b*
f zsh           ^z*
t a%1X          [[:alpha:][:punct:]]#[[:digit:]][^[:lower:]]
f a%1           [[:alpha:][:punct:]]#[[:digit:]][^[:lower:]]
t [:            [[:]#
t :]            []:]#
t :]            [:]]#
t [             [[]
t ]             []]
t []            [^]]]
t fooxx         (#i)FOOXX
f fooxx         (#l)FOOXX
t FOOXX         (#l)fooxx
f fooxx         (#i)FOO(#I)X(#i)X
t fooXx         (#i)FOO(#I)X(#i)X
t fooxx         ((#i)FOOX)x
f fooxx         ((#i)FOOX)X
f BAR           (bar|(#i)foo)
t FOO           (bar|(#i)foo)
EOT
print "$failed tests failed."