1	#!/usr/bin/env bash
2
3	#### [[ glob matching, [[ has no glob expansion
4	[[ foo.py == *.py ]] && echo true
5	[[ foo.p == *.py ]] || echo false
6	## stdout-json: "true\nfalse\n"
7
8	#### [[ glob matching with escapes
9	[[ 'foo.*' == *."*" ]] && echo true
10	# note that the pattern arg to fnmatch should be '*.\*'
11	## stdout: true
12
13	#### equality
14	[[ '*.py' == '*.py' ]] && echo true
15	[[ foo.py == '*.py' ]] || echo false
16	## stdout-json: "true\nfalse\n"
17
18	#### [[ glob matching with unquoted var
19	pat=*.py
20	[[ foo.py == $pat ]] && echo true
21	[[ foo.p == $pat ]] || echo false
22	## stdout-json: "true\nfalse\n"
23
24	#### [[ regex matching
25	# mksh doesn't have this syntax of regex matching. I guess it comes from perl?
26	regex='.*\.py'
27	[[ foo.py =~ $regex ]] && echo true
28	[[ foo.p =~ $regex ]] || echo false
29	## stdout-json: "true\nfalse\n"
30	## N-I mksh stdout-json: ""
31	## N-I mksh status: 1
32
33	#### [[ regex syntax error
34	# hm, it doesn't show any error, but it exits 2.
35	[[ foo.py =~ * ]] && echo true
36	## status: 2
37	## N-I mksh status: 1
38
39	#### [[ has no word splitting
40	var='one two'
41	[[ 'one two' == $var ]] && echo true
42	## stdout: true
43
44	#### [[ has quote joining
45	var='one two'
46	[[ 'one 'tw"o" == $var ]] && echo true
47	## stdout: true
48
49	#### [[ empty string is false
50	[[ 'a' ]] && echo true
51	[[ '' ]] || echo false
52	## stdout-json: "true\nfalse\n"
53
54	#### && chain
55	[[ t && t && '' ]] || echo false
56	## stdout: false
57
58	#### || chain
59	[[ '' || '' || t ]] && echo true
60	## stdout: true
61
62	#### [[ compound expressions
63	# Notes on whitespace:
64	# - 1 and == need space seprating them, but ! and ( don't.
65	# - [[ needs whitesapce after it, but ]] doesn't need whitespace before it!
66	[[ ''||! (1 == 2)&&(2 == 2)]] && echo true
67	## stdout: true
68
69	# NOTE on the two cases below. We're comparing
70	# (a || b) && c vs. a || (b && c)
71	#
72	# a = true, b = false, c = false is an example where they are different.
73	# && and || have precedence inside
74
75	#### precedence of && and || inside [[
76	[[ True || '' && '' ]] && echo true
77	## stdout: true
78
79	#### precedence of && and || in a command context
80	if test True || test '' && test ''; then
81	echo YES
82	else
83	echo "NO precedence"
84	fi
85	## stdout: NO precedence
86
87	# http://tldp.org/LDP/abs/html/testconstructs.html#DBLBRACKETS
88
89	#### Octal literals with -eq
90	shopt -u strict-arith || true
91	decimal=15
92	octal=017 # = 15 (decimal)
93	[[ $decimal -eq $octal ]] && echo true
94	[[ $decimal -eq ZZZ$octal ]] || echo false
95	## STDOUT:
96	true
97	false
98	## END
99	## N-I mksh stdout: false
100	# mksh doesn't implement this syntax for literals.
101
102	#### Hex literals with -eq
103	shopt -u strict-arith || true
104	decimal=15
105	hex=0x0f # = 15 (decimal)
106	[[ $decimal -eq $hex ]] && echo true
107	[[ $decimal -eq ZZZ$hex ]] || echo false
108	## stdout-json: "true\nfalse\n"
109	## N-I mksh stdout: false
110
111	# TODO: Add tests for this
112	# https://www.gnu.org/software/bash/manual/bash.html#Bash-Conditional-Expressions
113	# When used with [[, the ‘<’ and ‘>’ operators sort lexicographically using the
114	# current locale. The test command uses ASCII ordering.
115
116	#### > on strings
117	# NOTE: < doesn't need space, even though == does? That's silly.
118	[[ b>a ]] && echo true
119	[[ b<a ]] || echo false
120	## stdout-json: "true\nfalse\n"
121
122	#### != on strings
123	# NOTE: b!=a does NOT work
124	[[ b != a ]] && echo true
125	[[ a != a ]] || echo false
126	## stdout-json: "true\nfalse\n"
127
128	#### -eq on strings
129	# This is lame behavior: it does a conversion to 0 first for any string
130	shopt -u strict-arith || true
131	[[ a -eq a ]] && echo true
132	[[ a -eq b ]] && echo true
133	## STDOUT:
134	true
135	true
136	## END
137
138	#### [[ compare with literal -f (compare with test-builtin.test.sh)
139	var=-f
140	[[ $var == -f ]] && echo true
141	[[ '-f' == $var ]] && echo true
142	## stdout-json: "true\ntrue\n"
143
144	#### [[ with op variable (compare with test-builtin.test.sh)
145	# Parse error -- parsed BEFORE evaluation of vars
146	op='=='
147	[[ a $op a ]] && echo true
148	[[ a $op b ]] || echo false
149	## status: 2
150	## OK mksh status: 1
151
152	#### [[ with unquoted empty var (compare with test-builtin.test.sh)
153	empty=''
154	[[ $empty == '' ]] && echo true
155	## stdout: true
156
157	#### [[ at runtime doesn't work
158	dbracket=[[
159	$dbracket foo == foo ]]
160	## status: 127
161
162	#### [[ with env prefix doesn't work
163	FOO=bar [[ foo == foo ]]
164	## status: 127
165
166	#### [[ over multiple lines is OK
167	# Hm it seems you can't split anywhere?
168	[[ foo == foo
169	&& bar == bar
170	]] && echo true
171	## status: 0
172	## STDOUT:
173	true
174	## END
175
176	#### Argument that looks like a command word operator
177	[[ -f -f ]] || echo false
178	[[ -f == ]] || echo false
179	## STDOUT:
180	false
181	false
182	## END
183
184	#### Argument that looks like a real operator
185	[[ -f < ]] && echo 'should be parse error'
186	## status: 2
187	## OK mksh status: 1
188
189	#### User array compared to "$@" (broken unless shopt -s strict-array)
190	# Both are coerced to string! It treats it more like an UNQUOTED ${a[@]}.
191
192	a=('1 3' 5)
193	b=(1 2 3)
194	set -- 1 '3 5'
195	[[ "$@" = "${a[@]}" ]] && echo true
196	[[ "$@" = "${b[@]}" ]] || echo false
197	## STDOUT:
198	true
199	false
200	## END
201
202	#### Array coerces to string (shopt -s strict-array to disallow)
203	a=('1 3' 5)
204	[[ '1 3 5' = "${a[@]}" ]] && echo true
205	[[ '1 3 4' = "${a[@]}" ]] || echo false
206	## STDOUT:
207	true
208	false
209	## END
210
211	#### (( array1 == array2 )) doesn't work
212	a=('1 3' 5)
213	b=('1 3' 5)
214	c=('1' '3 5')
215	d=('1' '3 6')
216
217	# shells EXPAND a and b first
218	(( a == b ))
219	echo status=$?
220
221	(( a == c ))
222	echo status=$?
223
224	(( a == d ))
225	echo status=$?
226
227	## stdout-json: ""
228	## status: 1
229	## BUG bash STDOUT:
230	status=1
231	status=1
232	status=1
233	## END
234	## BUG bash status: 0
235
236	#### Quotes don't matter in comparison
237	[[ '3' = 3 ]] && echo true
238	[[ '3' -eq 3 ]] && echo true
239	## STDOUT:
240	true
241	true
242	## END
243
244	#### -eq does dynamic arithmetic parsing (not supported in OSH)
245	[[ 1+2 -eq 3 ]] && echo true
246	expr='1+2'
247	[[ $expr -eq 3 ]] && echo true # must be dynamically parsed
248	## STDOUT:
249	true
250	true
251	## END
252	## N-I osh stdout-json: ""
253	## N-I osh status: 1
254
255	#### -eq coercion produces weird results
256	shopt -u strict-arith || true
257	[[ '' -eq 0 ]] && echo true
258	## stdout: true
259
260	#### [[ '(' ]] is treated as literal
261	[[ '(' ]]
262	echo status=$?
263	## stdout: status=0
264
265	#### [[ '(' foo ]] is syntax error
266	[[ '(' foo ]]
267	echo status=$?
268	## status: 2
269	## OK mksh status: 1
270
271	#### empty ! is treated as literal
272	[[ '!' ]]
273	echo status=$?
274	## stdout: status=0
275
276	#### [[ -z ]] is syntax error
277	[[ -z ]]
278	echo status=$?
279	## status: 2
280	## OK mksh status: 1
281
282	#### [[ -z '>' ]]
283	[[ -z '>' ]] || echo false # -z is operator
284	## stdout: false
285
286	#### [[ -z '>' a ]] is syntax error
287	[[ -z '>' -- ]]
288	echo status=$?
289	## status: 2
290	## OK mksh status: 1
291
292	#### test whether ']]' is empty
293	[[ ']]' ]]
294	echo status=$?
295	## status: 0
296
297	#### [[ ]] is syntax error
298	[[ ]]
299	echo status=$?
300	## stdout-json: ""
301	## status: 2
302	## OK mksh status: 1
303
304	#### [[ && ]] is syntax error
305	[[ && ]]
306	echo status=$?
307	## stdout-json: ""
308	## status: 2
309	## OK mksh status: 1