From: Sami Wagiaalla Date: Wed, 20 Oct 2010 18:56:09 +0000 (+0000) Subject: cvs add smartp.cc smartp.exp X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=78c62ceee32fc241da0c1529f896f876c37d61dd;p=binutils-gdb.git cvs add smartp.cc smartp.exp Original changelog: Support overloading of 'operator->'. [...] 2010-10-19 Sami Wagiaalla * gdb.cp/smartp.exp: New test. * gdb.cp/smartp.cc : New test. --- diff --git a/gdb/testsuite/gdb.cp/smartp.cc b/gdb/testsuite/gdb.cp/smartp.cc new file mode 100644 index 00000000000..baa8f463420 --- /dev/null +++ b/gdb/testsuite/gdb.cp/smartp.cc @@ -0,0 +1,163 @@ +/* This test script is part of GDB, the GNU debugger. + + Copyright 1999, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 + Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + */ + +class Type1{ + public: + int foo(){ + return 11; + } +}; + +class Type2{ + public: + int foo(){ + return 22; + } +}; + +class Type3{ + public: + int foo(int){ + return 33; + } + int foo(char){ + return 44; + } +}; + +class Type4 { + public: + int a; + int b; +}; + +int foo (Type3, float) +{ + return 55; +} + +class MyPointer{ + Type1 *p; + public: + MyPointer(Type1 *pointer){ + p = pointer; + } + + Type1 *operator->(){ + return p; + } +}; + +template class SmartPointer{ + T *p; + public: + SmartPointer(T *pointer){ + p = pointer; + } + + T *operator->(){ + return p; + } +}; + + +class A { + public: + int inta; + int foo() { return 66; } +}; + +class B { + public: + A a; + A* operator->(){ + return &a; + } +}; + +class C { + public: + B b; + B& operator->(){ + return b; + } +}; + +class C2 { + public: + B b; + B operator->(){ + return b; + } +}; + +int main(){ + Type1 mt1; + Type2 mt2; + Type3 mt3; + + Type4 mt4; + mt4.a = 11; + mt4.b = 12; + + MyPointer mp(&mt1); + Type1 *mtp = &mt1; + + SmartPointer sp1(&mt1); + SmartPointer sp2(&mt2); + SmartPointer sp3(&mt3); + SmartPointer sp4(&mt4); + + mp->foo(); + mtp->foo(); + + sp1->foo(); + sp2->foo(); + + sp3->foo(1); + sp3->foo('a'); + + sp4->a; + sp4->b; + + Type4 *mt4p = &mt4; + mt4p->a; + mt4p->b; + + A a; + B b; + C c; + C2 c2; + + a.inta = 77; + b.a = a; + c.b = b; + c2.b = b; + + a.foo(); + b->foo(); + c->foo(); + + b->inta = 77; + c->inta = 77; + c2->inta = 77; + + return 0; // end of main +} + diff --git a/gdb/testsuite/gdb.cp/smartp.exp b/gdb/testsuite/gdb.cp/smartp.exp new file mode 100644 index 00000000000..2cea473bc3f --- /dev/null +++ b/gdb/testsuite/gdb.cp/smartp.exp @@ -0,0 +1,77 @@ +# Copyright 2008 Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +set testfile smartp +set srcfile ${testfile}.cc +if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} {debug c++}] } { + return -1 +} + +############################################ + +if ![runto_main] then { + perror "couldn't run to breakpoint main" + continue +} + +gdb_breakpoint [gdb_get_line_number "end of main"] +gdb_continue_to_breakpoint "end of main" + +# Test that overloaded arrow operator works +gdb_test "p mp->foo()" "= 11" + +# Test that regular arrow operator still works +gdb_test "p mtp->foo()" "= 11" + +# Test that normal '.' operator still works. +gdb_test "p mt1.foo()" "= 11" + +# test that gdb extension '.' for pointers still works. +gdb_test "p mt4p.a" "= 11" + +# test that gdb extension '->' for structs still works. +gdb_test "p mt4->a" "= 11" + +# Test that templated smart pointers work +gdb_test "p sp1->foo()" "= 11" +gdb_test "p sp2->foo()" "= 22" + +# Test that overload resolution works properly +# with smart pointers +gdb_test "p sp3->foo(1)" "= 33" +gdb_test "p sp3->foo('a')" "= 44" + +# Test smart pointers work for member references +gdb_test "p sp4->a" "= 11" +gdb_test "p sp4->b" "= 12" + +# Test regular arrow operator still works for +# member references +gdb_test "p mt4p->a" "= 11" +gdb_test "p mt4p->b" "= 12" + +# Test that incorrect use of the arrow operator +# is still handled correctly. +gdb_test "p mt4->fake" "There is no member named fake." +gdb_test "p mt4->fake()" "Couldn't find method Type4::fake" + +# Test that overloading of -> works recursively +gdb_test "p b->foo()" "= 66" +gdb_test "p c->foo()" "= 66" +gdb_test "p c->inta" "= 77" + +setup_kfail "gdb/11606" "*-*-*" +gdb_test "p c2->inta" "= 77" +