Commit | Line | Data |
---|---|---|
cec808ec KS |
1 | # cpexprs.exp - C++ expressions tests |
2 | # | |
3 | # Copyright 2008, 2009, 2010 Free Software Foundation, Inc. | |
4 | # | |
5 | # Contributed by Red Hat, originally written by Keith Seitz. | |
6 | # | |
7 | # This program is free software; you can redistribute it and/or modify | |
8 | # it under the terms of the GNU General Public License as published by | |
9 | # the Free Software Foundation; either version 3 of the License, or | |
10 | # (at your option) any later version. | |
11 | # | |
12 | # This program is distributed in the hope that it will be useful, | |
13 | # but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | # GNU General Public License for more details. | |
16 | # | |
17 | # You should have received a copy of the GNU General Public License | |
18 | # along with this program. If not, see <http://www.gnu.org/licenses/>. | |
19 | ||
20 | # This file is part of the gdb testsuite. | |
21 | ||
22 | # A helper proc which sets a breakpoint at FUNC and attempts to | |
23 | # run to the breakpoint. | |
24 | proc test_breakpoint {func} { | |
25 | global DEC | |
26 | ||
640617ad DJ |
27 | # Return to the top of the test function every time. |
28 | delete_breakpoints | |
29 | if { ! [gdb_breakpoint test_function] } { | |
30 | fail "set test_function breakpoint for $func" | |
31 | } elseif { [gdb_test "continue" \ | |
32 | "Continuing.\r\n\r\nBreakpoint $DEC+,.*test_function.*" \ | |
33 | ""] != 0 } { | |
34 | fail "continue to test_function for $func" | |
cec808ec KS |
35 | } else { |
36 | gdb_breakpoint "$func" | |
37 | set i [expr {[string last : $func] + 1}] | |
38 | set efunc [string_to_regexp [string range $func $i end]] | |
39 | gdb_test "continue" \ | |
40 | "Continuing.\r\n\r\nBreakpoint $DEC+,.*$efunc.*" \ | |
41 | "continue to $func" | |
42 | } | |
43 | } | |
44 | ||
45 | # Add a function to the list of tested functions | |
46 | # FUNC is the name of the function (which will be passed to gdb commands) | |
47 | # TYPE is the type of the function, as expected from the "print" command | |
48 | # PRINT is the name of the function, as expected result of the print command | |
49 | # *OR* "-", indicating that FUNC should be used (needed for virtual/inherited | |
50 | # funcs) | |
51 | # LST is either the expected result of the list command (the comment from | |
52 | # the source code) *OR* "-", in which case FUNC will be used | |
53 | # | |
54 | # Usage: | |
55 | # add NAME TYPE PRINT LST | |
56 | # add NAME TYPE PRINT - | |
57 | proc add {func type print lst} { | |
58 | global all_functions CONVAR ADDR | |
59 | ||
60 | set all_functions($func,type) $type | |
61 | if {$print == "-"} { | |
62 | set print $func | |
63 | } | |
64 | ||
65 | # An exception: since gdb canonicalizes C++ output, | |
66 | # "(void)" must be mutated to "()". | |
67 | regsub {\(void\)} $print {()} print | |
68 | ||
69 | set all_functions($func,print) \ | |
70 | "$CONVAR = {[string_to_regexp $type]} $ADDR <[string_to_regexp $print].*>" | |
71 | if {$lst == "-"} { | |
72 | set lst "$func" | |
73 | } | |
74 | set all_functions($func,list) ".*// [string_to_regexp $lst]" | |
75 | } | |
76 | ||
77 | proc get {func cmd} { | |
78 | global all_functions | |
79 | return $all_functions($func,$cmd) | |
80 | } | |
81 | ||
82 | # Returns a list of function names for a given command | |
83 | proc get_functions {cmd} { | |
84 | global all_functions | |
85 | set result {} | |
86 | foreach i [array names all_functions *,$cmd] { | |
87 | if {$all_functions($i) != ""} { | |
88 | set idx [string last , $i] | |
89 | if {$idx != -1} { | |
90 | lappend result [string range $i 0 [expr {$idx - 1}]] | |
91 | } | |
92 | } | |
93 | } | |
94 | ||
95 | return [lsort $result] | |
96 | } | |
97 | ||
98 | # Some convenience variables for this test | |
99 | set DEC {[0-9]}; # a decimal number | |
100 | set HEX {[0-9a-fA-F]}; # a hexidecimal number | |
101 | set CONVAR "\\\$$DEC+"; # convenience variable regexp | |
102 | set ADDR "0x$HEX+"; # address | |
103 | ||
104 | # An array of functions/methods that we are testing... | |
105 | # Each element consists is indexed by NAME,COMMAND, where | |
106 | # NAME is the function name and COMMAND is the gdb command that | |
107 | # we are testing. The value of the array for any index pair is | |
108 | # the expected result of running COMMAND with the NAME as argument. | |
109 | ||
110 | # The array holding all functions/methods to test. Valid subindexes | |
111 | # are (none need character escaping -- "add" will take care of that): | |
112 | ||
113 | # add name type print_name list | |
114 | # NAME,type: value is type of function | |
115 | # NAME,print: value is print name of function (careful w/inherited/virtual!) | |
116 | # NAME,list: value is comment in source code on first line of function | |
117 | # (without the leading "//") | |
118 | array set all_functions {} | |
119 | ||
120 | # "Normal" functions/methods | |
640617ad | 121 | add {test_function} \ |
cec808ec KS |
122 | {int (int, char **)} \ |
123 | - \ | |
124 | - | |
125 | add {derived::a_function} \ | |
126 | {void (const derived * const)} \ | |
127 | - \ | |
128 | - | |
129 | add {base1::a_function} \ | |
130 | {void (const base1 * const)} \ | |
131 | - \ | |
132 | - | |
133 | add {base2::a_function} \ | |
134 | {void (const base2 * const)} \ | |
135 | - \ | |
136 | - | |
137 | ||
138 | # Constructors | |
139 | ||
140 | # On targets using the ARM EABI, the constructor is expected to return | |
141 | # "this". | |
142 | proc ctor { type arglist } { | |
143 | if { [istarget arm*-*eabi*] } { | |
144 | set ret "$type *" | |
145 | } else { | |
146 | set ret "void " | |
147 | } | |
148 | if { $arglist != "" } { | |
149 | set arglist ", $arglist" | |
150 | } | |
151 | return "${ret}($type * const$arglist)" | |
152 | } | |
153 | ||
154 | add {derived::derived} \ | |
155 | [ctor derived ""] \ | |
156 | - \ | |
157 | - | |
158 | add {base1::base1(void)} \ | |
159 | [ctor base1 "const void ** const"] \ | |
160 | - \ | |
161 | - | |
162 | add {base1::base1(int)} \ | |
163 | [ctor base1 "int"] \ | |
164 | - \ | |
165 | - | |
166 | add {base2::base2} \ | |
167 | [ctor base2 "const void ** const"] \ | |
168 | - \ | |
169 | - | |
170 | add {base::base(void)} \ | |
171 | [ctor base ""] \ | |
172 | - \ | |
173 | - | |
174 | add {base::base(int)} \ | |
175 | [ctor base "int"] \ | |
176 | - \ | |
177 | - | |
178 | ||
179 | # Destructors | |
180 | ||
181 | # On targets using the ARM EABI, some destructors are expected | |
182 | # to return "this". Others are void. For internal reasons, | |
183 | # GCC returns void * instead of $type *; RealView appears to do | |
184 | # the same. | |
185 | proc dtor { type } { | |
186 | if { [istarget arm*-*eabi*] } { | |
187 | set ret "void *" | |
188 | } else { | |
189 | set ret "void " | |
190 | } | |
191 | return "${ret}($type * const)" | |
192 | } | |
193 | ||
194 | add {base::~base} \ | |
195 | [dtor base] \ | |
196 | - \ | |
197 | - | |
198 | ||
199 | # Overloaded methods (all are const -- we try to use the void | |
200 | # method with and without specifying "const") | |
201 | add {base::overload(void)} \ | |
202 | {int (const base * const)} \ | |
203 | - \ | |
204 | {base::overload(void) const} | |
205 | add {base::overload(void) const} \ | |
206 | {int (const base * const)} \ | |
207 | - \ | |
208 | {base::overload(void) const} | |
209 | add {base::overload(int) const} \ | |
210 | {int (const base * const, int)} \ | |
211 | - \ | |
212 | - | |
213 | add {base::overload(short) const} \ | |
214 | {int (const base * const, short)} \ | |
215 | - \ | |
216 | - | |
217 | add {base::overload(long) const} \ | |
218 | {int (const base * const, long)} \ | |
219 | - \ | |
220 | - | |
221 | add {base::overload(char*) const} \ | |
222 | {int (const base * const, char *)} \ | |
223 | - \ | |
224 | - | |
225 | add {base::overload(base&) const} \ | |
226 | {int (const base * const, base &)} \ | |
227 | - \ | |
228 | - | |
229 | ||
230 | # Operators | |
231 | add {base::operator+} \ | |
232 | {int (const base * const, const base &)} \ | |
233 | - \ | |
234 | - | |
235 | add {base::operator++} \ | |
236 | {base (base * const)} \ | |
237 | - \ | |
238 | - | |
239 | add {base::operator+=} \ | |
240 | {base (base * const, const base &)} \ | |
241 | - \ | |
242 | - | |
243 | add {base::operator-} \ | |
244 | {int (const base * const, const base &)} \ | |
245 | - \ | |
246 | - | |
247 | add {base::operator--} \ | |
248 | {base (base * const)} \ | |
249 | - \ | |
250 | - | |
251 | add {base::operator-=} \ | |
252 | {base (base * const, const base &)} \ | |
253 | - \ | |
254 | - | |
255 | add {base::operator*} \ | |
256 | {int (const base * const, const base &)} \ | |
257 | - \ | |
258 | - | |
259 | add {base::operator*=} \ | |
260 | {base (base * const, const base &)} \ | |
261 | - \ | |
262 | - | |
263 | add {base::operator/} \ | |
264 | {int (const base * const, const base &)} \ | |
265 | - \ | |
266 | - | |
267 | add {base::operator/=} \ | |
268 | {base (base * const, const base &)} \ | |
269 | - \ | |
270 | - | |
271 | add {base::operator%} \ | |
272 | {int (const base * const, const base &)} \ | |
273 | - \ | |
274 | - | |
275 | add {base::operator%=} \ | |
276 | {base (base * const, const base &)} \ | |
277 | - \ | |
278 | - | |
279 | add {base::operator<} \ | |
280 | {bool (const base * const, const base &)} \ | |
281 | - \ | |
282 | - | |
283 | add {base::operator<=} \ | |
284 | {bool (const base * const, const base &)} \ | |
285 | - \ | |
286 | - | |
287 | add {base::operator>} \ | |
288 | {bool (const base * const, const base &)} \ | |
289 | - \ | |
290 | - | |
291 | add {base::operator>=} \ | |
292 | {bool (const base * const, const base &)} \ | |
293 | - \ | |
294 | - | |
295 | add {base::operator!=} \ | |
296 | {bool (const base * const, const base &)} \ | |
297 | - \ | |
298 | - | |
299 | add {base::operator==} \ | |
300 | {bool (const base * const, const base &)} \ | |
301 | - \ | |
302 | - | |
303 | add {base::operator!} \ | |
304 | {bool (const base * const)} \ | |
305 | - \ | |
306 | - | |
307 | add {base::operator&&} \ | |
308 | {bool (const base * const, const base &)} \ | |
309 | - \ | |
310 | - | |
311 | add {base::operator||} \ | |
312 | {bool (const base * const, const base &)} \ | |
313 | - \ | |
314 | - | |
315 | add {base::operator<<} \ | |
316 | {int (const base * const, int)} \ | |
317 | - \ | |
318 | - | |
319 | add {base::operator<<=} \ | |
320 | {base (base * const, int)} \ | |
321 | - \ | |
322 | - | |
323 | add {base::operator>>} \ | |
324 | {int (const base * const, int)} \ | |
325 | - \ | |
326 | - | |
327 | add {base::operator>>=} \ | |
328 | {base (base * const, int)} \ | |
329 | - \ | |
330 | - | |
331 | add {base::operator~} \ | |
332 | {int (const base * const)} \ | |
333 | - \ | |
334 | - | |
335 | add {base::operator&} \ | |
336 | {int (const base * const, const base &)} \ | |
337 | - \ | |
338 | - | |
339 | add {base::operator&=} \ | |
340 | {base (base * const, const base &)} \ | |
341 | - \ | |
342 | - | |
343 | add {base::operator|} \ | |
344 | {int (const base * const, const base &)} \ | |
345 | - \ | |
346 | - | |
347 | add {base::operator|=} \ | |
348 | {base (base * const, const base &)} \ | |
349 | - \ | |
350 | - | |
351 | add {base::operator^} \ | |
352 | {int (const base * const, const base &)} \ | |
353 | - \ | |
354 | - | |
355 | add {base::operator^=} \ | |
356 | {base (base * const, const base &)} \ | |
357 | - \ | |
358 | - | |
359 | add {base::operator=} \ | |
360 | {base (base * const, const base &)} \ | |
361 | - \ | |
362 | - | |
363 | add {base::operator()} \ | |
364 | {void (const base * const)} \ | |
365 | - \ | |
366 | - | |
367 | add {base::operator[]} \ | |
368 | {int (const base * const, int)} \ | |
369 | - \ | |
370 | - | |
371 | add {base::operator new} \ | |
372 | {void *(size_t)} \ | |
373 | - \ | |
374 | - | |
375 | add {base::operator delete} \ | |
376 | {void (void *)} \ | |
377 | - \ | |
378 | - | |
379 | add {base::operator new[]} \ | |
380 | {void *(size_t)} \ | |
381 | - \ | |
382 | - | |
383 | add {base::operator delete[]} \ | |
384 | {void (void *)} \ | |
385 | - \ | |
386 | - | |
387 | add {base::operator char*} \ | |
388 | {char *(const base * const)} \ | |
389 | - \ | |
390 | - | |
391 | add {base::operator fluff*} \ | |
392 | {fluff *(const base * const)} \ | |
393 | - \ | |
394 | - | |
395 | add {base::operator fluff**} \ | |
396 | {fluff **(const base * const)} \ | |
397 | - \ | |
398 | - | |
399 | add {base::operator int} \ | |
400 | {int (const base * const)} \ | |
401 | - \ | |
402 | - | |
403 | ||
404 | # Templates | |
405 | add {tclass<char>::do_something} \ | |
406 | {void (tclass<char> * const)} \ | |
407 | - \ | |
408 | - | |
409 | add {tclass<int>::do_something} \ | |
410 | {void (tclass<int> * const)} \ | |
411 | - \ | |
412 | - | |
413 | add {tclass<long>::do_something} \ | |
414 | {void (tclass<long> * const)} \ | |
415 | - \ | |
416 | - | |
417 | add {tclass<short>::do_something} \ | |
418 | {void (tclass<short> * const)} \ | |
419 | - \ | |
420 | - | |
421 | add {tclass<base>::do_something} \ | |
422 | {void (tclass<base> * const)} \ | |
423 | - \ | |
424 | - | |
425 | add {flubber<int, int, int, int, int>} \ | |
426 | {void (void)} \ | |
427 | - \ | |
428 | flubber | |
429 | add {flubber<int, int, int, int, short>} \ | |
430 | {void (void)} \ | |
431 | - \ | |
432 | flubber | |
433 | add {flubber<int, int, int, int, long>} \ | |
434 | {void (void)} \ | |
435 | - \ | |
436 | flubber | |
437 | add {flubber<int, int, int, int, char>} \ | |
438 | {void (void)} \ | |
439 | - \ | |
440 | flubber | |
441 | add {flubber<int, int, int, short, int>} \ | |
442 | {void (void)} \ | |
443 | - \ | |
444 | flubber | |
445 | add {flubber<int, int, int, short, short>} \ | |
446 | {void (void)} \ | |
447 | - \ | |
448 | flubber | |
449 | add {flubber<int, int, int, short, long>} \ | |
450 | {void (void)} \ | |
451 | - \ | |
452 | flubber | |
453 | add {flubber<int, int, int, short, char>} \ | |
454 | {void (void)} \ | |
455 | - \ | |
456 | flubber | |
457 | add {flubber<int, int, int, long, int>} \ | |
458 | {void (void)} \ | |
459 | - \ | |
460 | flubber | |
461 | add {flubber<int, int, int, long, short>} \ | |
462 | {void (void)} \ | |
463 | - \ | |
464 | flubber | |
465 | add {flubber<int, int, int, long, long>} \ | |
466 | {void (void)} \ | |
467 | - \ | |
468 | flubber | |
469 | add {flubber<int, int, int, long, char>} \ | |
470 | {void (void)} \ | |
471 | - \ | |
472 | flubber | |
473 | add {flubber<int, int, int, char, int>} \ | |
474 | {void (void)} \ | |
475 | - \ | |
476 | flubber | |
477 | add {flubber<int, int, int, char, short>} \ | |
478 | {void (void)} \ | |
479 | - \ | |
480 | flubber | |
481 | add {flubber<int, int, int, char, long>} \ | |
482 | {void (void)} \ | |
483 | - \ | |
484 | flubber | |
485 | add {flubber<int, int, int, char, char>} \ | |
486 | {void (void)} \ | |
487 | - \ | |
488 | flubber | |
489 | add {flubber<int, int, short, int, int>} \ | |
490 | {void (void)} \ | |
491 | - \ | |
492 | flubber | |
493 | add {flubber<int, int, short, int, short>} \ | |
494 | {void (void)} \ | |
495 | - \ | |
496 | flubber | |
497 | add {flubber<int, int, short, int, long>} \ | |
498 | {void (void)} \ | |
499 | - \ | |
500 | flubber | |
501 | add {flubber<int, int, short, int, char>} \ | |
502 | {void (void)} \ | |
503 | - \ | |
504 | flubber | |
505 | add {flubber<int, int, short, short, int>} \ | |
506 | {void (void)} \ | |
507 | - \ | |
508 | flubber | |
509 | add {flubber<short, int, short, int, short>} \ | |
510 | {void (void)} \ | |
511 | - \ | |
512 | flubber | |
513 | add {flubber<long, short, long, short, long>} \ | |
514 | {void (void)} \ | |
515 | - \ | |
516 | flubber | |
517 | add {tclass<base>::do_something} \ | |
518 | {void (tclass<base> * const)} \ | |
519 | - \ | |
520 | {tclass<T>::do_something} | |
521 | add {policy1::policy} \ | |
522 | [ctor "policy<int, operation_1<void*> >" "int"] \ | |
523 | {policy<int, operation_1<void*> >::policy} \ | |
524 | {policy<T, Policy>::policy} | |
525 | add {policy2::policy} \ | |
526 | [ctor "policy<int, operation_2<void*> >" int] \ | |
527 | {policy<int, operation_2<void*> >::policy} \ | |
528 | {policy<T, Policy>::policy} | |
529 | add {policy3::policy} \ | |
530 | [ctor "policy<int, operation_3<void*> >" "int"] \ | |
531 | {policy<int, operation_3<void*> >::policy} \ | |
532 | {policy<T, Policy>::policy} | |
533 | add {policy4::policy} \ | |
534 | [ctor "policy<int, operation_4<void*> >" "int"] \ | |
535 | {policy<int, operation_4<void*> >::policy} \ | |
536 | {policy<T, Policy>::policy} | |
537 | add {policy1::function} \ | |
538 | {void (void)} \ | |
539 | {operation_1<void*>::function} \ | |
540 | {operation_1<T>::function} | |
541 | add {policy2::function} \ | |
542 | {void (void)} \ | |
543 | {operation_2<void*>::function} \ | |
544 | {operation_2<T>::function} | |
545 | add {policy3::function} \ | |
546 | {void (void)} \ | |
547 | {operation_3<void*>::function} \ | |
548 | {operation_3<T>::function} | |
549 | add {policy4::function} \ | |
550 | {void (void)} \ | |
551 | {operation_4<void*>::function} \ | |
552 | {operation_4<T>::function} | |
553 | add {policyd<int, operation_1<int> >::policyd} \ | |
554 | [ctor "policyd<int, operation_1<int> >" "int"] \ | |
555 | - \ | |
556 | {policyd<T, Policy>::policyd} | |
557 | add {policyd1::policyd} \ | |
558 | [ctor "policyd<int, operation_1<int> >" "int"] \ | |
559 | {policyd<int, operation_1<int> >::policyd} \ | |
560 | {policyd<T, Policy>::policyd} | |
561 | add {policyd<int, operation_1<int> >::~policyd} \ | |
562 | [dtor "policyd<int, operation_1<int> >"] \ | |
563 | - \ | |
564 | {policyd<T, Policy>::~policyd} | |
565 | add {policyd1::~policyd} \ | |
566 | [dtor "policyd<int, operation_1<int> >"] \ | |
567 | {policyd<int, operation_1<int> >::~policyd} \ | |
568 | {policyd<T, Policy>::~policyd} | |
569 | add {policyd<long, operation_1<long> >::policyd} \ | |
570 | [ctor "policyd<long, operation_1<long> >" "long"] \ | |
571 | - \ | |
572 | {policyd<T, Policy>::policyd} | |
573 | add {policyd2::policyd} \ | |
574 | [ctor "policyd<long, operation_1<long> >" "long"] \ | |
575 | {policyd<long, operation_1<long> >::policyd} \ | |
576 | {policyd<T, Policy>::policyd} | |
577 | add {policyd<long, operation_1<long> >::~policyd} \ | |
578 | [dtor "policyd<long, operation_1<long> >"] \ | |
579 | - \ | |
580 | {policyd<T, Policy>::~policyd} | |
581 | add {policyd2::~policyd} \ | |
582 | [dtor "policyd<long, operation_1<long> >"] \ | |
583 | {policyd<long, operation_1<long> >::~policyd} \ | |
584 | {policyd<T, Policy>::~policyd} | |
585 | add {policyd<char, operation_1<char> >::policyd} \ | |
586 | [ctor "policyd<char, operation_1<char> >" "char"] \ | |
587 | - \ | |
588 | {policyd<T, Policy>::policyd} | |
589 | add {policyd3::policyd} \ | |
590 | [ctor "policyd<char, operation_1<char> >" "char"] \ | |
591 | {policyd<char, operation_1<char> >::policyd} \ | |
592 | {policyd<T, Policy>::policyd} | |
593 | add {policyd<char, operation_1<char> >::~policyd} \ | |
594 | [dtor "policyd<char, operation_1<char> >"] \ | |
595 | - \ | |
596 | {policyd<T, Policy>::~policyd} | |
597 | add {policyd3::~policyd} \ | |
598 | [dtor "policyd<char, operation_1<char> >"] \ | |
599 | {policyd<char, operation_1<char> >::~policyd} \ | |
600 | {policyd<T, Policy>::~policyd} | |
601 | add {policyd<base, operation_1<base> >::policyd} \ | |
602 | [ctor "policyd<base, operation_1<base> >" "base"] \ | |
603 | - \ | |
604 | {policyd<T, Policy>::policyd} | |
605 | add {policyd4::policyd} \ | |
606 | [ctor "policyd<base, operation_1<base> >" "base"] \ | |
607 | {policyd<base, operation_1<base> >::policyd} \ | |
608 | {policyd<T, Policy>::policyd} | |
609 | add {policyd<base, operation_1<base> >::~policyd} \ | |
610 | [dtor "policyd<base, operation_1<base> >"] \ | |
611 | - \ | |
612 | {policyd<T, Policy>::~policyd} | |
613 | add {policyd4::~policyd} \ | |
614 | [dtor "policyd<base, operation_1<base> >"] \ | |
615 | {policyd<base, operation_1<base> >::~policyd} \ | |
616 | {policyd<T, Policy>::~policyd} | |
617 | add {policyd<tclass<int>, operation_1<tclass<int> > >::policyd} \ | |
618 | [ctor "policyd<tclass<int>, operation_1<tclass<int> > >" "tclass<int>"] \ | |
619 | - \ | |
620 | {policyd<T, Policy>::policyd} | |
621 | add {policyd5::policyd} \ | |
622 | [ctor "policyd<tclass<int>, operation_1<tclass<int> > >" "tclass<int>"] \ | |
623 | {policyd<tclass<int>, operation_1<tclass<int> > >::policyd} \ | |
624 | {policyd<T, Policy>::policyd} | |
625 | add {policyd<tclass<int>, operation_1<tclass<int> > >::~policyd} \ | |
626 | [dtor "policyd<tclass<int>, operation_1<tclass<int> > >"] \ | |
627 | - \ | |
628 | {policyd<T, Policy>::~policyd} | |
629 | add {policyd5::~policyd} \ | |
630 | [dtor "policyd<tclass<int>, operation_1<tclass<int> > >"] \ | |
631 | {policyd<tclass<int>, operation_1<tclass<int> > >::~policyd} \ | |
632 | {policyd<T, Policy>::~policyd} | |
633 | add {policyd<int, operation_1<int> >::function} \ | |
634 | {void (void)} \ | |
635 | {operation_1<int>::function}\ | |
636 | {operation_1<T>::function} | |
637 | add {policyd1::function} \ | |
638 | {void (void)} \ | |
639 | {operation_1<int>::function} \ | |
640 | {operation_1<T>::function} | |
641 | add {policyd2::function} \ | |
642 | {void (void)} \ | |
643 | {operation_1<long>::function} \ | |
644 | {operation_1<T>::function} | |
645 | add {policyd<char, operation_1<char> >::function} \ | |
646 | {void (void)} \ | |
647 | {operation_1<char>::function} \ | |
648 | {operation_1<T>::function} | |
649 | add {policyd3::function} \ | |
650 | {void (void)} \ | |
651 | {operation_1<char>::function} \ | |
652 | {operation_1<T>::function} | |
653 | add {policyd<base, operation_1<base> >::function} \ | |
654 | {void (void)} \ | |
655 | {operation_1<base>::function} \ | |
656 | {operation_1<T>::function} | |
657 | add {policyd4::function} \ | |
658 | {void (void)} \ | |
659 | {operation_1<base>::function} \ | |
660 | {operation_1<T>::function} | |
661 | add {policyd<tclass<int>, operation_1<tclass<int> > >::function} \ | |
662 | {void (void)} \ | |
663 | {operation_1<tclass<int> >::function} \ | |
664 | {operation_1<T>::function} | |
665 | add {policyd5::function} \ | |
666 | {void (void)} \ | |
667 | {operation_1<tclass<int> >::function} \ | |
668 | {operation_1<T>::function} | |
669 | ||
670 | # Start the test | |
671 | if {$tracelevel} { | |
672 | strace $tracelevel | |
673 | } | |
674 | ||
675 | if {[skip_cplus_tests]} { continue } | |
676 | ||
caddefa4 UW |
677 | # On SPU this test fails because the executable exceeds local storage size. |
678 | if { [istarget "spu*-*-*"] } { | |
679 | return 0 | |
680 | } | |
681 | ||
cec808ec KS |
682 | # |
683 | # test running programs | |
684 | # | |
cec808ec KS |
685 | |
686 | set testfile "cpexprs" | |
687 | set srcfile "${testfile}.cc" | |
688 | set binfile [file join $objdir $subdir $testfile] | |
689 | ||
690 | if {[gdb_compile [file join $srcdir $subdir $srcfile] $binfile \ | |
691 | executable {debug c++}] != "" } { | |
692 | untested "$testfile.exp" | |
693 | return -1 | |
694 | } | |
695 | ||
696 | if {[get_compiler_info $binfile "c++"]} { | |
697 | return -1 | |
698 | } | |
699 | ||
700 | gdb_exit | |
701 | gdb_start | |
702 | gdb_reinitialize_dir [file join $srcdir $subdir] | |
703 | gdb_load $binfile | |
704 | ||
705 | if {![runto_main]} { | |
706 | perror "couldn't run to breakpoint" | |
707 | continue | |
708 | } | |
709 | ||
710 | # Set the listsize to one. This will help with testing "list". | |
711 | gdb_test "set listsize 1" | |
712 | ||
713 | # "print METHOD" | |
714 | foreach name [get_functions print] { | |
715 | gdb_test "print $name" [get $name print] "print $name" | |
716 | } | |
717 | ||
718 | # "list METHOD" | |
719 | foreach name [get_functions list] { | |
720 | gdb_test "list $name" [get $name list] "list $name" | |
721 | } | |
722 | ||
723 | # Running to breakpoint -- use any function we can "list" | |
724 | foreach name [get_functions list] { | |
640617ad DJ |
725 | # Skip "test_function", since test_breakpoint uses it |
726 | if {[string compare $name "test_function"] != 0} { | |
cec808ec KS |
727 | test_breakpoint $name |
728 | } | |
729 | } | |
730 | ||
731 | gdb_exit | |
732 | return 0 |