Commit | Line | Data |
---|---|---|
b811d2c2 | 1 | # Copyright 2017-2020 Free Software Foundation, Inc. |
6a3c6ee4 PA |
2 | |
3 | # This program is free software; you can redistribute it and/or modify | |
4 | # it under the terms of the GNU General Public License as published by | |
5 | # the Free Software Foundation; either version 3 of the License, or | |
6 | # (at your option) any later version. | |
7 | # | |
8 | # This program is distributed in the hope that it will be useful, | |
9 | # but WITHOUT ANY WARRANTY; without even the implied warranty of | |
10 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
11 | # GNU General Public License for more details. | |
12 | # | |
13 | # You should have received a copy of the GNU General Public License | |
14 | # along with this program. If not, see <http://www.gnu.org/licenses/>. | |
15 | ||
16 | # This file is part of the gdb testsuite. | |
17 | ||
18 | load_lib completion-support.exp | |
19 | ||
20 | standard_testfile cpls-ops.cc | |
21 | ||
22 | if {[prepare_for_testing "failed to prepare" $testfile \ | |
23 | [list $srcfile] {debug}]} { | |
24 | return -1 | |
25 | } | |
26 | ||
4ee9b0c5 SL |
27 | # Tests below are about tab-completion, which doesn't work if readline |
28 | # library isn't used. Check it first. | |
29 | ||
30 | if { ![readline_is_used] } { | |
31 | untested "no tab completion support without readline" | |
32 | return -1 | |
33 | } | |
34 | ||
6a3c6ee4 PA |
35 | gdb_test_no_output "set max-completions unlimited" |
36 | ||
37 | # Check that the explicit location completer manages to find the next | |
38 | # option name after a "-function function" option. A useful test when | |
39 | # the -function options's argument is a C++ operator, which can | |
40 | # include characters like '-'. | |
41 | ||
42 | proc check_explicit_skips_function_argument {function} { | |
43 | test_gdb_complete_unique \ | |
44 | "b -function $function -sour" \ | |
45 | "b -function $function -source" | |
46 | } | |
47 | ||
48 | # Helper function for the operator new/new[] tests. CLASS_NAME is the | |
49 | # name of the class that contains the operator we're testing. | |
50 | # BRACKETS is set to [] if testing operator new[], and to empty if | |
51 | # testing operator new. | |
52 | ||
53 | proc test_operator_new {class_name brackets} { | |
e3919f3e PA |
54 | global gdb_prompt |
55 | ||
56 | # Extract the type size_t is typedef-ed to. | |
57 | set size_t "" | |
58 | set test "get size_t underlying type" | |
59 | gdb_test_multiple "ptype size_t" $test { | |
60 | -re " = (\[ a-z\]*)\r\n$gdb_prompt $" { | |
61 | set size_t $expect_out(1,string) | |
62 | pass "$test" | |
63 | } | |
64 | } | |
6a3c6ee4 PA |
65 | |
66 | # Complete all prefixes between "operato" and the full prototype. | |
67 | foreach cmd_prefix {"b" "b -function"} { | |
68 | set location "${class_name}::operator new${brackets}($size_t)" | |
69 | set line "$cmd_prefix $location" | |
70 | set start [index_after "operato" $line] | |
71 | test_complete_prefix_range $line $start | |
72 | check_bp_locations_match_list "$cmd_prefix $location" [list $location] | |
73 | ||
74 | # Same, but with extra spaces. Note that the original spaces in | |
75 | # the input line are preserved after completion. | |
76 | ||
77 | test_gdb_complete_unique \ | |
78 | "$cmd_prefix ${class_name}::operator new " \ | |
79 | "$cmd_prefix ${class_name}::operator new ${brackets}($size_t)" | |
80 | test_gdb_complete_unique \ | |
81 | "$cmd_prefix ${class_name}::operator new ${brackets} (" \ | |
82 | "$cmd_prefix ${class_name}::operator new ${brackets} ($size_t)" | |
83 | test_gdb_complete_unique \ | |
84 | "$cmd_prefix ${class_name}::operator new ${brackets} ( $size_t " \ | |
85 | "$cmd_prefix ${class_name}::operator new ${brackets} ( $size_t )" | |
86 | ||
87 | check_setting_bp_fails "$cmd_prefix ${class_name}::operator" | |
88 | ||
89 | set location_list \ | |
90 | [list \ | |
91 | "${class_name}::operator new${brackets}" \ | |
92 | "${class_name}::operator new${brackets} ($size_t)" \ | |
93 | "${class_name}::operator new ${brackets} ( $size_t )"] | |
94 | foreach linespec $location_list { | |
95 | check_bp_locations_match_list \ | |
96 | "$cmd_prefix $linespec" [list $location] | |
97 | } | |
98 | } | |
99 | ||
100 | # Check that the explicit location completer manages to find the | |
101 | # option name after -function, when the -function's argument is a | |
102 | # C++ operator new / new[]. | |
103 | check_explicit_skips_function_argument \ | |
104 | "${class_name}::operator new ${brackets} ( $size_t )" | |
105 | } | |
106 | ||
107 | proc_with_prefix operator-new {} { | |
108 | test_operator_new test_op_new "" | |
109 | } | |
110 | ||
111 | proc_with_prefix operator-new\[\] {} { | |
112 | test_operator_new test_op_new_array "\[\]" | |
113 | } | |
114 | ||
115 | # Helper function for the operator delete/delete[] tests. CLASS_NAME | |
116 | # is the name of the class that contains the operator we're testing. | |
117 | # BRACKETS is set to "[]" if testing operator delete[], and to empty | |
118 | # if testing operator delete. | |
119 | ||
120 | proc test_operator_delete {class_name brackets} { | |
121 | # Complete all prefixes between "operato" and the full prototype. | |
122 | foreach cmd_prefix {"b" "b -function"} { | |
123 | set location "${class_name}::operator delete${brackets}(void*)" | |
124 | set line "$cmd_prefix $location" | |
125 | set start [index_after "operato" $line] | |
126 | test_complete_prefix_range $line $start | |
127 | check_bp_locations_match_list "$cmd_prefix $location" [list $location] | |
128 | ||
129 | # Same, but with extra spaces. Note that the original spaces in | |
130 | # the input line are preserved after completion. | |
131 | ||
132 | test_gdb_complete_unique \ | |
133 | "$cmd_prefix ${class_name}::operator delete " \ | |
134 | "$cmd_prefix ${class_name}::operator delete ${brackets}(void*)" | |
135 | test_gdb_complete_unique \ | |
136 | "$cmd_prefix ${class_name}::operator delete ${brackets} (" \ | |
137 | "$cmd_prefix ${class_name}::operator delete ${brackets} (void*)" | |
138 | test_gdb_complete_unique \ | |
139 | "$cmd_prefix ${class_name}::operator delete ${brackets} ( void* " \ | |
140 | "$cmd_prefix ${class_name}::operator delete ${brackets} ( void* )" | |
141 | test_gdb_complete_unique \ | |
142 | "$cmd_prefix ${class_name}::operator delete ${brackets} ( void * " \ | |
143 | "$cmd_prefix ${class_name}::operator delete ${brackets} ( void * )" | |
144 | ||
145 | check_setting_bp_fails "$cmd_prefix ${class_name}::operator" | |
146 | ||
147 | set location_list \ | |
148 | [list \ | |
149 | "${class_name}::operator delete${brackets}" \ | |
150 | "${class_name}::operator delete${brackets}(void *)" \ | |
151 | "${class_name}::operator delete ${brackets} ( void * )"] | |
152 | foreach linespec $location_list { | |
153 | check_bp_locations_match_list \ | |
154 | "$cmd_prefix $linespec" [list $location] | |
155 | } | |
156 | } | |
157 | ||
158 | # Check that the explicit location completer manages to find the | |
159 | # option name after -function, when the -function's argument is a | |
160 | # C++ operator delete / delete[]. | |
161 | check_explicit_skips_function_argument \ | |
162 | "${class_name}::operator delete ${brackets} ( void * )" | |
163 | } | |
164 | ||
165 | proc_with_prefix operator-delete {} { | |
166 | test_operator_delete test_op_delete "" | |
167 | } | |
168 | ||
169 | proc_with_prefix operator-delete\[\] {} { | |
170 | test_operator_delete test_op_delete_array "\[\]" | |
171 | } | |
172 | ||
173 | # Helper for testing both operator() and operator[]. Tests completion | |
174 | # when the operator match is unique. CLASS_NAME is the class that | |
175 | # holds the operator to test. OPN and CLS are the open and close | |
176 | # characters ("()" or "[]"). | |
177 | ||
178 | proc test_operator_unique {class_name opn cls} { | |
179 | # Complete all prefixes between "oper" and the full prototype. | |
180 | foreach cmd_prefix {"b" "b -function"} { | |
181 | set location "${class_name}::operator${opn}${cls}(int)" | |
182 | set line "$cmd_prefix $location" | |
183 | set start [index_after "${class_name}" $line] | |
184 | test_complete_prefix_range $line $start | |
185 | check_bp_locations_match_list "$cmd_prefix $location" [list $location] | |
186 | ||
187 | # Same, but with extra spaces. Note that the original spaces in | |
188 | # the input line are preserved after completion. | |
189 | ||
190 | test_gdb_complete_unique \ | |
191 | "$cmd_prefix ${class_name}::operator ${opn} ${cls} ( int " \ | |
192 | "$cmd_prefix ${class_name}::operator ${opn} ${cls} ( int )" | |
193 | test_gdb_complete_unique \ | |
194 | "$cmd_prefix ${class_name}::operator ${opn} ${cls}" \ | |
195 | "$cmd_prefix ${class_name}::operator ${opn} ${cls}(int)" | |
196 | test_gdb_complete_unique \ | |
197 | "$cmd_prefix ${class_name}::operator ${opn}${cls}" \ | |
198 | "$cmd_prefix ${class_name}::operator ${opn}${cls}(int)" | |
199 | test_gdb_complete_unique \ | |
200 | "$cmd_prefix ${class_name}::operator ${opn}" \ | |
201 | "$cmd_prefix ${class_name}::operator ${opn}${cls}(int)" | |
202 | ||
203 | check_setting_bp_fails "$cmd_prefix ${class_name}::operator" | |
204 | ||
205 | set location_list \ | |
206 | [list \ | |
207 | "${class_name}::operator${opn}${cls}" \ | |
208 | "${class_name}::operator ${opn}${cls}" \ | |
209 | "${class_name}::operator ${opn}${cls}(int)" \ | |
210 | "${class_name}::operator ${opn} ${cls} ( int )"] | |
211 | foreach linespec $location_list { | |
212 | check_bp_locations_match_list \ | |
213 | "$cmd_prefix $linespec" [list $location] | |
214 | } | |
215 | } | |
216 | ||
217 | # Check that the explicit location completer manages to find the | |
218 | # option name after -function, when the -function's argument is a | |
219 | # C++ operator(). | |
220 | check_explicit_skips_function_argument \ | |
221 | "${class_name}::operator ${opn} ${cls} ( int )" | |
222 | } | |
223 | ||
224 | # Helper for testing both operator() and operator[]. Tests completion | |
225 | # when the operator match is ambiguous. CLASS_NAME is the class that | |
226 | # holds the operator to test. OPN and CLS are the open and close | |
227 | # characters ("()" or "[]"). | |
228 | ||
229 | proc test_operator_ambiguous {class_name opn cls} { | |
230 | foreach cmd_prefix {"b" "b -function"} { | |
231 | check_setting_bp_fails "$cmd_prefix ${class_name}::operator" | |
232 | ||
233 | set linespec_noparams "${class_name}::operator${opn}${cls}" | |
234 | ||
235 | set location_list \ | |
236 | [list \ | |
237 | "${class_name}::operator${opn}${cls}(int)" \ | |
238 | "${class_name}::operator${opn}${cls}(long)" \ | |
239 | "${class_name}::operator${opn}${cls}<int>(int*)"] | |
240 | # The operator[] test can't have a "()" overload, since that | |
241 | # wouldn't compile. | |
242 | if {$opn == "("} { | |
243 | set location_list \ | |
244 | [concat \ | |
245 | [list "${class_name}::operator${opn}${cls}()"] \ | |
246 | $location_list] | |
247 | } | |
248 | test_gdb_complete_multiple \ | |
249 | "$cmd_prefix " "$linespec_noparams" "" $location_list | |
250 | ||
251 | # Setting the breakpoint doesn't create a breakpoint location | |
252 | # for the template, because immediately after | |
253 | # "operator()/operator[]" we have the template parameters, not | |
254 | # the parameter list. | |
255 | set location_list \ | |
256 | [list \ | |
257 | "${class_name}::operator${opn}${cls}(int)" \ | |
258 | "${class_name}::operator${opn}${cls}(long)"] | |
259 | if {$opn == "("} { | |
260 | set location_list \ | |
261 | [concat \ | |
262 | [list "${class_name}::operator${opn}${cls}()"] \ | |
263 | $location_list] | |
264 | } | |
265 | check_bp_locations_match_list "$cmd_prefix $linespec_noparams" \ | |
266 | $location_list | |
267 | check_bp_locations_match_list "$cmd_prefix $linespec_noparams<int>" \ | |
268 | [list "${class_name}::operator${opn}${cls}<int>(int*)"] | |
269 | ||
270 | # Test the template version. Test both with and without | |
271 | # return type. | |
272 | test_gdb_complete_unique \ | |
273 | "$cmd_prefix ${class_name}::operator${opn}${cls}<int>(in" \ | |
274 | "$cmd_prefix ${class_name}::operator${opn}${cls}<int>(int*)" | |
275 | check_bp_locations_match_list \ | |
276 | "$cmd_prefix ${class_name}::operator${opn}${cls}<int>(int*)" \ | |
277 | [list "${class_name}::operator${opn}${cls}<int>(int*)"] | |
278 | test_gdb_complete_unique \ | |
279 | "$cmd_prefix void ${class_name}::operator${opn}${cls}<int>(in" \ | |
280 | "$cmd_prefix void ${class_name}::operator${opn}${cls}<int>(int*)" | |
281 | check_bp_locations_match_list \ | |
282 | "$cmd_prefix void ${class_name}::operator${opn}${cls}<int>(int*)" \ | |
283 | [list "${class_name}::operator${opn}${cls}<int>(int*)"] | |
284 | ||
285 | # Add extra spaces. | |
286 | test_gdb_complete_unique \ | |
287 | "$cmd_prefix ${class_name}::operator ${opn} ${cls} ( in" \ | |
288 | "$cmd_prefix ${class_name}::operator ${opn} ${cls} ( int)" | |
289 | check_bp_locations_match_list \ | |
290 | "$cmd_prefix ${class_name}::operator ${opn} ${cls} ( int )" \ | |
291 | [list "${class_name}::operator${opn}${cls}(int)"] | |
292 | } | |
293 | } | |
294 | ||
295 | proc_with_prefix operator()-unique {} { | |
296 | test_operator_unique test_unique_op_call "(" ")" | |
297 | } | |
298 | ||
299 | proc_with_prefix operator\[\]-unique {} { | |
300 | test_operator_unique test_unique_op_array "\[" "\]" | |
301 | } | |
302 | ||
303 | proc_with_prefix operator()-ambiguous {} { | |
304 | test_operator_ambiguous test_op_call "(" ")" | |
305 | } | |
306 | ||
307 | proc_with_prefix operator\[\]-ambiguous {} { | |
308 | test_operator_ambiguous test_op_array "\[" "\]" | |
309 | } | |
310 | ||
311 | # Test arithmetic/logical operators. Test completing all C++ | |
312 | # arithmetic/logical operators, when all the operators are in the same | |
313 | # class. | |
314 | ||
315 | proc_with_prefix ops-valid-ambiguous {} { | |
316 | set locations { | |
317 | "test_ops::operator!(E)" | |
318 | "test_ops::operator!=(E, E)" | |
319 | "test_ops::operator%(E, E)" | |
320 | "test_ops::operator%=(E, E)" | |
321 | "test_ops::operator&&(E, E)" | |
322 | "test_ops::operator&(E, E)" | |
323 | "test_ops::operator&=(E, E)" | |
324 | "test_ops::operator*(E, E)" | |
325 | "test_ops::operator*=(E, E)" | |
326 | "test_ops::operator+(E, E)" | |
327 | "test_ops::operator++(E)" | |
328 | "test_ops::operator++(E, int)" | |
329 | "test_ops::operator+=(E, E)" | |
330 | "test_ops::operator,(E, E)" | |
331 | "test_ops::operator-(E, E)" | |
332 | "test_ops::operator--(E)" | |
333 | "test_ops::operator--(E, int)" | |
334 | "test_ops::operator-=(E, E)" | |
335 | "test_ops::operator/(E, E)" | |
336 | "test_ops::operator/=(E, E)" | |
337 | "test_ops::operator<(E, E)" | |
338 | "test_ops::operator<<(E, E)" | |
339 | "test_ops::operator<<=(E, E)" | |
340 | "test_ops::operator<=(E, E)" | |
341 | "test_ops::operator==(E, E)" | |
342 | "test_ops::operator>(E, E)" | |
343 | "test_ops::operator>=(E, E)" | |
344 | "test_ops::operator>>(E, E)" | |
345 | "test_ops::operator>>=(E, E)" | |
346 | "test_ops::operator^(E, E)" | |
347 | "test_ops::operator^=(E, E)" | |
348 | "test_ops::operator|(E, E)" | |
349 | "test_ops::operator|=(E, E)" | |
350 | "test_ops::operator||(E, E)" | |
351 | "test_ops::operator~(E)" | |
352 | } | |
353 | foreach linespec $locations { | |
354 | foreach cmd_prefix {"b" "b -function"} { | |
355 | test_gdb_complete_unique \ | |
356 | "$cmd_prefix $linespec" \ | |
357 | "$cmd_prefix $linespec" | |
358 | ||
359 | } | |
360 | ||
361 | check_explicit_skips_function_argument "$linespec" | |
362 | } | |
363 | ||
364 | foreach cmd_prefix {"b" "b -function"} { | |
365 | test_gdb_complete_multiple \ | |
366 | "$cmd_prefix " "test_ops::operator" "" $locations | |
367 | } | |
368 | } | |
369 | ||
370 | # Test completing all C++ operators, with and without spaces. The | |
371 | # test without spaces makes sure the completion matches exactly the | |
372 | # expected prototype. The version with whitespace is a bit more lax | |
373 | # for simplicity. In that case, we only make sure we get back the | |
374 | # terminating ')'. Each operator is defined in a separate class so | |
375 | # that we can exercise unique completion matches. | |
376 | ||
377 | proc_with_prefix ops-valid-unique {} { | |
378 | set locations { | |
379 | "test_op_BIT_AND::operator&(E, E)" | |
380 | "test_op_BIT_AND_A::operator&=(E, E)" | |
381 | "test_op_BIT_O::operator|(E, E)" | |
382 | "test_op_COMMA::operator,(E, E)" | |
383 | "test_op_DIV::operator/(E, E)" | |
384 | "test_op_DIV_A::operator/=(E, E)" | |
385 | "test_op_EQ::operator==(E, E)" | |
386 | "test_op_GT::operator>(E, E)" | |
387 | "test_op_GTE::operator>=(E, E)" | |
388 | "test_op_LAND::operator&&(E, E)" | |
389 | "test_op_LOR::operator||(E, E)" | |
390 | "test_op_LT::operator<(E, E)" | |
391 | "test_op_LTE::operator<=(E, E)" | |
392 | "test_op_MINUS::operator-(E, E)" | |
393 | "test_op_MINUS_A::operator-=(E, E)" | |
394 | "test_op_MOD::operator%(E, E)" | |
395 | "test_op_MOD_A::operator%=(E, E)" | |
396 | "test_op_MUL::operator*(E, E)" | |
397 | "test_op_MUL_A::operator*=(E, E)" | |
398 | "test_op_NEG::operator~(E)" | |
399 | "test_op_NEQ::operator!=(E, E)" | |
400 | "test_op_NOT::operator!(E)" | |
401 | "test_op_OE::operator|=(E, E)" | |
402 | "test_op_PLUS::operator+(E, E)" | |
403 | "test_op_PLUS_A::operator+=(E, E)" | |
404 | "test_op_POST_DEC::operator--(E, int)" | |
405 | "test_op_POST_INC::operator++(E, int)" | |
406 | "test_op_PRE_DEC::operator--(E)" | |
407 | "test_op_PRE_INC::operator++(E)" | |
408 | "test_op_SL::operator<<(E, E)" | |
409 | "test_op_SL_A::operator<<=(E, E)" | |
410 | "test_op_SR::operator>>(E, E)" | |
411 | "test_op_SR_A::operator>>=(E, E)" | |
412 | "test_op_XOR::operator^(E, E)" | |
413 | "test_op_XOR_A::operator^=(E, E)" | |
414 | } | |
415 | set linespecs_ws { | |
416 | "test_op_BIT_AND::operator & ( E , E )" | |
417 | "test_op_BIT_AND_A::operator &= ( E , E )" | |
418 | "test_op_BIT_O::operator | (E , E )" | |
419 | "test_op_COMMA::operator , ( E , E )" | |
420 | "test_op_DIV::operator / (E , E )" | |
421 | "test_op_DIV_A::operator /= ( E , E )" | |
422 | "test_op_EQ::operator == ( E , E )" | |
423 | "test_op_GT::operator > ( E , E )" | |
424 | "test_op_GTE::operator >= ( E , E )" | |
425 | "test_op_LAND::operator && ( E , E )" | |
426 | "test_op_LOR::operator || ( E , E )" | |
427 | "test_op_LT::operator < ( E , E )" | |
428 | "test_op_LTE::operator <= ( E , E )" | |
429 | "test_op_MINUS::operator - ( E , E )" | |
430 | "test_op_MINUS_A::operator -= ( E , E )" | |
431 | "test_op_MOD::operator % ( E , E )" | |
432 | "test_op_MOD_A::operator %= ( E , E )" | |
433 | "test_op_MUL::operator * ( E , E )" | |
434 | "test_op_MUL_A::operator *= ( E , E )" | |
435 | "test_op_NEG::operator ~ ( E )" | |
436 | "test_op_NEQ::operator != ( E , E )" | |
437 | "test_op_NOT::operator ! ( E )" | |
438 | "test_op_OE::operator |= ( E , E )" | |
439 | "test_op_PLUS::operator + ( E , E )" | |
440 | "test_op_PLUS_A::operator += ( E , E )" | |
441 | "test_op_POST_DEC::operator -- ( E , int )" | |
442 | "test_op_POST_INC::operator ++ ( E , int )" | |
443 | "test_op_PRE_DEC::operator -- ( E )" | |
444 | "test_op_PRE_INC::operator ++ ( E )" | |
445 | "test_op_SL::operator << ( E , E )" | |
446 | "test_op_SL_A::operator <<= ( E , E )" | |
447 | "test_op_SR::operator >> ( E , E )" | |
448 | "test_op_SR_A::operator >>= ( E , E )" | |
449 | "test_op_XOR::operator ^ ( E , E )" | |
450 | "test_op_XOR_A::operator ^= ( E , E )" | |
451 | } | |
452 | foreach linespec $locations linespec_ws $linespecs_ws { | |
453 | foreach cmd_prefix {"b" "b -function"} { | |
454 | with_test_prefix "no-whitespace" { | |
455 | set line "$cmd_prefix $linespec" | |
456 | set start [index_after "::operato" $line] | |
457 | test_complete_prefix_range $line $start | |
458 | } | |
459 | ||
460 | with_test_prefix "whitespace" { | |
461 | set line_ws "$cmd_prefix $linespec_ws" | |
462 | set start_ws [index_after "::operator " $line_ws] | |
463 | test_complete_prefix_range_re \ | |
464 | $line_ws "$cmd_prefix test_op_.*::operator .*\\\)" $start_ws | |
465 | } | |
466 | } | |
467 | ||
468 | check_explicit_skips_function_argument "$linespec" | |
469 | check_explicit_skips_function_argument "$linespec_ws" | |
470 | } | |
471 | } | |
472 | ||
473 | # Test completing an invalid (whitespace at the wrong place) operator | |
474 | # name. | |
475 | ||
476 | proc_with_prefix ops-invalid {} { | |
477 | foreach linespec { | |
478 | "test_op_BIT_AND_A::operator& =(E, E)" | |
479 | "test_op_DIV_A::operator/ =(E, E)" | |
480 | "test_op_EQ::operator= =(E, E)" | |
481 | "test_op_GTE::operator> =(E, E)" | |
482 | "test_op_LAND::operator& &(E, E)" | |
483 | "test_op_LOR::operator| |(E, E)" | |
484 | "test_op_LTE::operator< =(E, E)" | |
485 | "test_op_MINUS_A::operator- =(E, E)" | |
486 | "test_op_MOD_A::operator% =(E, E)" | |
487 | "test_op_MUL_A::operator* =(E, E)" | |
488 | "test_op_NEQ::operator! =(E, E)" | |
489 | "test_op_OE::operator| =(E, E)" | |
490 | "test_op_PLUS_A::operator+ =(E, E)" | |
491 | "test_op_POST_DEC::operator- -(E, int)" | |
492 | "test_op_POST_INC::operator+ +(E, int)" | |
493 | "test_op_PRE_DEC::operator- -(E)" | |
494 | "test_op_PRE_INC::operator+ +(E)" | |
495 | "test_op_SL::operator< <(E, E)" | |
496 | "test_op_SL_A::operator< < =(E, E)" | |
497 | "test_op_SR::operator> >(E, E)" | |
498 | "test_op_SR_A::operator> > =(E, E)" | |
499 | "test_op_XOR_A::operator^ =(E, E)" | |
500 | } { | |
501 | foreach cmd_prefix {"b" "b -function"} { | |
502 | test_gdb_complete_tab_none "$cmd_prefix $linespec" | |
503 | check_setting_bp_fails "$cmd_prefix $linespec" | |
504 | } | |
505 | } | |
506 | } | |
507 | ||
508 | # Test completing function/method FUNCTION. Completion is tested at | |
509 | # every point starting after START_AFTER. FUNCTION_WS is a version of | |
510 | # FUNCTION with extra (but valid) whitespace. FUNCTION_INVALID is a | |
511 | # version of FUNCTION with invalid whitespace. Tests that completion | |
512 | # of FUNCTION_WS completes to self, and that a completion of | |
513 | # FUNCTION_INVALID fails. | |
514 | ||
515 | proc test_function {function start_after function_ws {function_invalid ""}} { | |
516 | foreach cmd_prefix {"b" "b -function"} { | |
517 | set line "$cmd_prefix $function" | |
518 | set start [index_after $start_after $line] | |
519 | test_complete_prefix_range $line $start | |
520 | } | |
521 | ||
522 | check_explicit_skips_function_argument $function | |
523 | check_explicit_skips_function_argument $function_ws | |
524 | ||
525 | foreach cmd_prefix {"b" "b -function"} { | |
526 | test_gdb_complete_unique \ | |
527 | "$cmd_prefix $function_ws" \ | |
528 | "$cmd_prefix $function_ws" | |
529 | if {$function_invalid != ""} { | |
530 | test_gdb_complete_tab_none "$cmd_prefix $function_invalid" | |
531 | check_setting_bp_fails "$cmd_prefix $function_invalid" | |
532 | } | |
533 | } | |
534 | } | |
535 | ||
536 | # Test completing a user-defined conversion operator. | |
537 | ||
538 | proc_with_prefix conversion-operator {} { | |
539 | test_function \ | |
540 | "test_op_conversion::operator test_op_conversion_res const volatile**() const volatile" \ | |
541 | "test_op_conversio" \ | |
542 | "test_op_conversion::operator test_op_conversion_res const volatile * * ( ) const volatile"} | |
543 | ||
544 | # Test completing an assignment operator. | |
545 | ||
546 | proc_with_prefix assignment-operator {} { | |
547 | test_function \ | |
548 | "test_op_assign::operator=(test_op_assign const&)" \ | |
549 | "test_op_assig" \ | |
550 | "test_op_assign::operator = ( test_op_assign const & )" \ | |
551 | } | |
552 | ||
553 | # Test completing an arrow operator. | |
554 | ||
555 | proc_with_prefix arrow-operator {} { | |
556 | test_function \ | |
557 | "test_op_arrow::operator->()" \ | |
558 | "test_op_arro" \ | |
559 | "test_op_arrow::operator -> ( )" \ | |
560 | "test_op_arrow::operator - > ( )" | |
561 | } | |
562 | ||
563 | # The testcase driver. Calls all test procedures. | |
564 | ||
565 | proc test_driver {} { | |
566 | operator-delete | |
567 | operator-delete\[\] | |
568 | operator-new | |
569 | operator-new\[\] | |
570 | operator()-unique | |
571 | operator()-ambiguous | |
572 | operator\[\]-unique | |
573 | operator\[\]-ambiguous | |
574 | ops-valid-ambiguous | |
575 | ops-valid-unique | |
576 | ops-invalid | |
577 | conversion-operator | |
578 | assignment-operator | |
579 | arrow-operator | |
580 | } | |
581 | ||
582 | test_driver |