Re: gdb.c++ testsuite 1: member data

Re: gdb.c++ testsuite 1: member data

[Michael Elizabeth Chastain]

Jim Blandy asks:

> So, does Benjamin have approval to commit these tests?

No, not yet.

> Or will you add the kfails and commit the tests yourself?

That's quite likely, as I don't expect Benjamin K to be familiar
with the process of filing bug reports.

Michael C

Re: gdb.c++ testsuite 1: member data

[Benjamin Kosnik]

> > Or will you add the kfails and commit the tests yourself?
> 
> That's quite likely, as I don't expect Benjamin K to be familiar
> with the process of filing bug reports.

Thanks for taking over on the final bits Michael, I appreciate it. I was
mostly concerned with the expect tests themselves, as I'm pretty weak
WRT expect/dejagnu. If the testcases are ok in regards to this, then
I'll proceed to add further testcases in the same style. I'll probably
add a series of try/catch tests, and then go through and add test for
derivation and more visibility-type tests for derived templates.

Thanks for your help.

-benjamin

Re: gdb.c++ testsuite 1: member data

[Andrew Cagney]

Benjamin,

Can I strongly encourage you to tweak your mail tool so that it attaches 
files as something more friendly such as text/plain :-)  I got:

Content-Type: application/octet-stream;
  name="member_data.cc"
Content-Disposition: attachment;
  filename="member_data.cc"
Content-Transfer-Encoding: base64

Ly8gMjAwMi0wNS0xMwoKbmFtZXNwYWNlIF9fZ251X3Rlc3QKewogIGVudW0gCXJlZ2lvbiB7IG9y
aWVudGFsLCBlZ3lwdGlhbiwgZ3JlZWssIGV0cnVzY2FuLCByb21hbiB9OwoKICAvLyBUZXN0IG9u

Anyway, once Michael's ok'd your changes, you're ok for adding yourself 
to the maintainers file (post patch, add ChangeLog).

enjoy,
Andrew

Re: gdb.c++ testsuite 1: member data

[Daniel Jacobowitz]

On Tue, May 14, 2002 at 12:13:58PM -0700, Benjamin Kosnik wrote:
> These four files test for data member display in gdb. The first,
> member_data.cc, tests (bool, int, long, enum) data members and then
> tests various combinations of templates, non-POD object, etc. The data
> members tested are not random, and are synthesized to represent common
> constructs in the C++ standard library.
> 
> The second does the same, but the data members are static. 
> 
> As it stands, member_data.cc passes on linux when compiled shared, fails
> when static. The second file, members_data_static.cc, fails always. (And
> has for years, three at least.)
> 
> Please let me know what you think, and feel free to check them in. I'd
> really like it if one day these files both passed, for static and shared
> linkage. 
> 
> Files as attached. I don't have write access to the 'src' module. (And
> it's not especially imperative that I have it.)
> 
> tested x86/linux
> 
> 2002-05-14   Benjamin Kosnik  <bkoz@redhat.com>
> 
> 	* gdb.c++/member_data.cc: New file.
> 	* gdb.c++/member_data.exp: New file.
> 	* gdb.c++/member_data_static.cc: New file.
> 	* gdb.c++/member_data_static.exp: New file.


Ben, thanks a lot for submitting these!  We can always use more C++
tests, and I'm at work on the ones we have too much already to add
more.  I don't suppose the "1" in the subject means you've got more
coming?




-- 
Daniel Jacobowitz                           Carnegie Mellon University
MontaVista Software                         Debian GNU/Linux Developer

Re: gdb.c++ testsuite 1: member data

[Jim Blandy]

Michael Elizabeth Chastain <mec@shout.net> writes:
> Sounds good to me.  I welcome new tests.
> 
> New tests with FAILs in them need to have comments with the form:
> 
>   setup_kfail "gdb/NNN"
> 
> where NNN is a gnats PR number.
> 
> The goal is for all FAILs to be connected to PR's.
> 
> I have put this on my to-do list, which is a bit long right now.  :-/
> ETA tomorrow night maybe.

So, does Benjamin have approval to commit these tests?  Or will you
add the kfails and commit the tests yourself?

Re: gdb.c++ testsuite 1: member data

[Michael Elizabeth Chastain]

Sounds good to me.  I welcome new tests.

New tests with FAILs in them need to have comments with the form:

  setup_kfail "gdb/NNN"

where NNN is a gnats PR number.

The goal is for all FAILs to be connected to PR's.

I have put this on my to-do list, which is a bit long right now.  :-/
ETA tomorrow night maybe.

Michael C

gdb.c++ testsuite 1: member data

[Benjamin Kosnik]

[-- Attachment #1: Type: text/plain, Size: 1062 bytes --]

These four files test for data member display in gdb. The first,
member_data.cc, tests (bool, int, long, enum) data members and then
tests various combinations of templates, non-POD object, etc. The data
members tested are not random, and are synthesized to represent common
constructs in the C++ standard library.

The second does the same, but the data members are static. 

As it stands, member_data.cc passes on linux when compiled shared, fails
when static. The second file, members_data_static.cc, fails always. (And
has for years, three at least.)

Please let me know what you think, and feel free to check them in. I'd
really like it if one day these files both passed, for static and shared
linkage. 

Files as attached. I don't have write access to the 'src' module. (And
it's not especially imperative that I have it.)

tested x86/linux

2002-05-14   Benjamin Kosnik  <bkoz@redhat.com>

	* gdb.c++/member_data.cc: New file.
	* gdb.c++/member_data.exp: New file.
	* gdb.c++/member_data_static.cc: New file.
	* gdb.c++/member_data_static.exp: New file.

[-- Attachment #2: member_data.cc --]
[-- Type: application/octet-stream, Size: 1001 bytes --]

// 2002-05-13

namespace __gnu_test
{
  enum 	region { oriental, egyptian, greek, etruscan, roman };

  // Test one.
  class gnu_obj_1
  {
  protected:
    typedef region antiquities;
    const bool 		test;
    const int 		key1;
    long       		key2;

    antiquities 	value;

  public:
    gnu_obj_1(antiquities a, long l): test(true), key1(5), key2(l), value(a) {}
  };

  // Test two.
  template<typename T>
    class gnu_obj_2: public virtual gnu_obj_1
    {
    protected:
      antiquities	value_derived;
      
    public:
      gnu_obj_2(antiquities b): gnu_obj_1(oriental, 7), value_derived(b) { }
    }; 

  // Test three.
  template<typename T>
    class gnu_obj_3
    {
    protected:
      typedef region antiquities;
      gnu_obj_2<int>   	data;
      
    public:
      gnu_obj_3(antiquities b): data(etruscan) { }
    }; 
} 

int main()
{
  using namespace __gnu_test;
  gnu_obj_1		test1(egyptian, 4589);
  gnu_obj_2<long>	test2(roman);
  gnu_obj_3<long>	test3(greek);
  return 0;
}

[-- Attachment #3: member_data.exp --]
[-- Type: application/octet-stream, Size: 7114 bytes --]

# Copyright 2002 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 2 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, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  

# Tests for member data
# 2002-05-13  Benjamin Kosnik  <bkoz@redhat.com>

# This file is part of the gdb testsuite

if $tracelevel then {
        strace $tracelevel
        }

if { [skip_cplus_tests] } { continue }

#
# test running programs
#
set prms_id 0
set bug_id 0

set testfile "member_data"
set srcfile ${testfile}.cc
set binfile ${objdir}/${subdir}/${testfile}

if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug c++}] != "" } {
     gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail."
}

if [get_compiler_info ${binfile} "c++"] {
    return -1
}

gdb_exit
gdb_start
gdb_reinitialize_dir $srcdir/$subdir
gdb_load ${binfile}


if ![runto_main] then {
    perror "couldn't run to breakpoint"
    continue
}

# One.
send_gdb "break 50\n"
gdb_expect {
   -re "Breakpoint \[0-9\]*.*line 50\\.\r\n$gdb_prompt $" {
      pass "set break at 50"
    }
    -re ".*$gdb_prompt $" { fail "set break at 50" }
    timeout { fail "(timeout) set break at 50" }
}

send_gdb "continue\n"
gdb_expect {
   -re "Continuing\\.\r\n\r\nBreakpoint.*at.*member_data\\.cc:50\r\n.*$gdb_prompt $" {
      pass "continue to 50"
    }
    -re ".*$gdb_prompt $" { fail "continue to 50" }
    timeout { fail "(timeout) continue to 50" }
}

# simple object, const bool
send_gdb "print test1.test\n"
gdb_expect {
   -re "true\r\n$gdb_prompt $" {
      pass "simple object, const bool"
    }
    -re ".*$gdb_prompt $" { fail "simple object, const bool" }
    timeout { fail "simple object, const bool" }
}

# simple object, const int
send_gdb "print test1.key1\n"
gdb_expect {
   -re "5\r\n$gdb_prompt $" {
      pass "simple object, const int"
    }
    -re ".*$gdb_prompt $" { fail "simple object, const int" }
    timeout { fail "simple object, const int" }
}

# simple object, long
send_gdb "print test1.key2\n"
gdb_expect {
   -re "4589\r\n$gdb_prompt $" {
      pass "simple object, long"
    }
    -re ".*$gdb_prompt $" { fail "simple object, long" }
    timeout { fail "simple object, long" }
}

# simple object, enum
send_gdb "print test1.value\n"
gdb_expect {
   -re "egyptian\r\n$gdb_prompt $" {
      pass "simple object, enum"
    }
    -re ".*$gdb_prompt $" { fail "simple object, enum" }
    timeout { fail "simple object, enum" }
}

# Two.
send_gdb "break 51\n"
gdb_expect {
   -re "Breakpoint \[0-9\]*.*line 51\\.\r\n$gdb_prompt $" {
      pass "set break at 51"
    }
    -re ".*$gdb_prompt $" { fail "set break at 51" }
    timeout { fail "(timeout) set break at 51" }
}

send_gdb "continue\n"
gdb_expect {
   -re "Continuing\\.\r\n\r\nBreakpoint.*at.*member_data\\.cc:51\r\n.*$gdb_prompt $" {
      pass "continue to 51"
    }
    -re ".*$gdb_prompt $" { fail "continue to 51" }
    timeout { fail "(timeout) continue to 51" }
}

# derived template object, base const bool
send_gdb "print test2.test\n"
gdb_expect {
   -re "true\r\n$gdb_prompt $" {
      pass "derived template object, base const bool"
    }
    -re ".*$gdb_prompt $" { fail "derived template object, base const bool" }
    timeout { fail "derived template object, base const bool" }
}

# derived template object, base const int
send_gdb "print test2.key1\n"
gdb_expect {
   -re "5\r\n$gdb_prompt $" {
      pass "derived template object, base const int"
    }
    -re ".*$gdb_prompt $" { fail "derived template object, base const int" }
    timeout { fail "derived template object, base const int" }
}

# derived template object, base long
send_gdb "print test2.key2\n"
gdb_expect {
   -re "7\r\n$gdb_prompt $" {
      pass "derived template object, base  long"
    }
    -re ".*$gdb_prompt $" { fail "derived template object, base long" }
    timeout { fail "derived template object, base long" }
}

# derived template object, base enum
send_gdb "print test2.value\n"
gdb_expect {
   -re "oriental\r\n$gdb_prompt $" {
      pass "derived template object, base enum"
    }
    -re ".*$gdb_prompt $" { fail "derived template object, base enum" }
    timeout { fail "derived template object, base enum" }
}

# derived template object, enum
send_gdb "print test2.value_derived\n"
gdb_expect {
   -re "roman\r\n$gdb_prompt $" {
      pass "derived template object,  enum"
    }
    -re ".*$gdb_prompt $" { fail "derived template object, enum" }
    timeout { fail "derived template object, enum" }
}

# Three.
send_gdb "break 52\n"
gdb_expect {
   -re "Breakpoint \[0-9\]*.*line 52\\.\r\n$gdb_prompt $" {
      pass "set break at 52"
    }
    -re ".*$gdb_prompt $" { fail "set break at 52" }
    timeout { fail "(timeout) set break at 52" }
}

send_gdb "continue\n"
gdb_expect {
   -re "Continuing\\.\r\n\r\nBreakpoint.*at.*member_data\\.cc:52\r\n.*$gdb_prompt $" {
      pass "continue to 52"
    }
    -re ".*$gdb_prompt $" { fail "continue to 52" }
    timeout { fail "(timeout) continue to 52" }
}

# template object, derived template data member's base const bool
send_gdb "print test3.data.test\n"
gdb_expect {
   -re "true\r\n$gdb_prompt $" {
      pass "template object, const bool"
    }
    -re ".*$gdb_prompt $" { fail "template object, const bool" }
    timeout { fail "template object, const bool" }
}

# template object, derived template data member's base const int
send_gdb "print test3.data.key1\n"
gdb_expect {
   -re "5\r\n$gdb_prompt $" {
      pass "template object, const int"
    }
    -re ".*$gdb_prompt $" { fail "template object, const int" }
    timeout { fail "template object, const int" }
}

# template object, derived template data member's base long
send_gdb "print test3.data.key2\n"
gdb_expect {
   -re "7\r\n$gdb_prompt $" {
      pass "template object, long"
    }
    -re ".*$gdb_prompt $" { fail "template object, long" }
    timeout { fail "template object, long" }
}

# template object, derived template data member's base enum
send_gdb "print test3.data.value\n"
gdb_expect {
   -re "oriental\r\n$gdb_prompt $" {
      pass "template object, enum"
    }
    -re ".*$gdb_prompt $" { fail "template object, enum" }
    timeout { fail "template object, enum" }
}

#  template object, derived template data member's enum
send_gdb "print test3.data.value_derived\n"
gdb_expect {
   -re "etruscan\r\n$gdb_prompt $" {
      pass "template object,  enum"
    }
    -re ".*$gdb_prompt $" { fail "template object, enum" }
    timeout { fail "template object, enum" }
}

gdb_exit
return 0

[-- Attachment #4: member_data_static.cc --]
[-- Type: application/octet-stream, Size: 1297 bytes --]

// 2002-05-13

namespace __gnu_test
{
  enum 	region { oriental, egyptian, greek, etruscan, roman };

  // Test one.
  class gnu_obj_1
  {
  protected:
    typedef region antiquities;
    static const bool 	test = true;
    static const int 	key1 = 5;
    static long       	key2;

    static antiquities 	value;

  public:
    gnu_obj_1(antiquities a, long l) {}
  };

  const bool gnu_obj_1::test;
  const int gnu_obj_1::key1;
  long gnu_obj_1::key2 = 77;
  gnu_obj_1::antiquities gnu_obj_1::value = oriental;


  // Test two.
  template<typename T>
    class gnu_obj_2: public virtual gnu_obj_1
    {
    protected:
      static antiquities	value_derived;
      
    public:
      gnu_obj_2(antiquities b): gnu_obj_1(oriental, 7) { }
    }; 

  template<typename T>
    typename gnu_obj_2<T>::antiquities gnu_obj_2<T>::value_derived = etruscan;

  // Test three.
  template<typename T>
    class gnu_obj_3
    {
    protected:
      typedef region antiquities;
      static gnu_obj_2<int>   	data;
      
    public:
      gnu_obj_3(antiquities b) { }
    }; 

  template<typename T>
    gnu_obj_2<int> gnu_obj_3<T>::data(etruscan);
} 

int main()
{
  using namespace __gnu_test;
  gnu_obj_1		test1(egyptian, 4589);
  gnu_obj_2<long>	test2(roman);
  gnu_obj_3<long>	test3(greek);
  return 0;
}

[-- Attachment #5: member_data_static.exp --]
[-- Type: application/octet-stream, Size: 7576 bytes --]

# Copyright 2002 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 2 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, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  

# Tests for member static data
# 2002-05-13  Benjamin Kosnik  <bkoz@redhat.com>

# This file is part of the gdb testsuite

if $tracelevel then {
        strace $tracelevel
        }

if { [skip_cplus_tests] } { continue }

#
# test running programs
#
set prms_id 0
set bug_id 0

set testfile "member_data_static"
set srcfile ${testfile}.cc
set binfile ${objdir}/${subdir}/${testfile}

if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug c++}] != "" } {
     gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail."
}

if [get_compiler_info ${binfile} "c++"] {
    return -1
}

gdb_exit
gdb_start
gdb_reinitialize_dir $srcdir/$subdir
gdb_load ${binfile}


if ![runto_main] then {
    perror "couldn't run to breakpoint"
    continue
}

# One.
send_gdb "break 62\n"
gdb_expect {
   -re "Breakpoint \[0-9\]*.*line 62\\.\r\n$gdb_prompt $" {
      pass "set break at 62"
    }
    -re ".*$gdb_prompt $" { fail "set break at 62" }
    timeout { fail "(timeout) set break at 62" }
}

send_gdb "continue\n"
gdb_expect {
   -re "Continuing\\.\r\n\r\nBreakpoint.*at.*member_data_static\\.cc:62\r\n.*$gdb_prompt $" {
      pass "continue to 62"
    }
    -re ".*$gdb_prompt $" { fail "continue to 62" }
    timeout { fail "(timeout) continue to 62" }
}

# simple object, static const bool
send_gdb "print test1.test\n"
gdb_expect {
   -re "true\r\n$gdb_prompt $" {
      pass "simple object, static const bool"
    }
    -re ".*$gdb_prompt $" { fail "simple object, static const bool" }
    timeout { fail "simple object, static const bool" }
}

# simple object, static const int
send_gdb "print test1.key1\n"
gdb_expect {
   -re "5\r\n$gdb_prompt $" {
      pass "simple object, static const int"
    }
    -re ".*$gdb_prompt $" { fail "simple object, static const int" }
    timeout { fail "simple object, static const int" }
}

# simple object, static long
send_gdb "print test1.key2\n"
gdb_expect {
   -re "77\r\n$gdb_prompt $" {
      pass "simple object, static long"
    }
    -re ".*$gdb_prompt $" { fail "simple object, static long" }
    timeout { fail "simple object, static long" }
}

# simple object, static enum
send_gdb "print test1.value\n"
gdb_expect {
   -re "oriental\r\n$gdb_prompt $" {
      pass "simple object, static enum"
    }
    -re ".*$gdb_prompt $" { fail "simple object, static enum" }
    timeout { fail "simple object, static enum" }
}

# Two.
send_gdb "break 63\n"
gdb_expect {
   -re "Breakpoint \[0-9\]*.*line 63\\.\r\n$gdb_prompt $" {
      pass "set break at 63"
    }
    -re ".*$gdb_prompt $" { fail "set break at 63" }
    timeout { fail "(timeout) set break at 63" }
}

send_gdb "continue\n"
gdb_expect {
   -re "Continuing\\.\r\n\r\nBreakpoint.*at.*member_data_static\\.cc:63\r\n.*$gdb_prompt $" {
      pass "continue to 63"
    }
    -re ".*$gdb_prompt $" { fail "continue to 63" }
    timeout { fail "(timeout) continue to 63" }
}

# derived template object, base static const bool
send_gdb "print test2.test\n"
gdb_expect {
   -re "true\r\n$gdb_prompt $" {
      pass "derived template object, base static const bool"
    }
    -re ".*$gdb_prompt $" { fail "derived template object, base static const bool" }
    timeout { fail "derived template object, base static const bool" }
}

# derived template object, base static const int
send_gdb "print test2.key1\n"
gdb_expect {
   -re "5\r\n$gdb_prompt $" {
      pass "derived template object, base static const int"
    }
    -re ".*$gdb_prompt $" { fail "derived template object, base static const int" }
    timeout { fail "derived template object, base static const int" }
}

# derived template object, base static long
send_gdb "print test2.key2\n"
gdb_expect {
   -re "77\r\n$gdb_prompt $" {
      pass "derived template object, base static long"
    }
    -re ".*$gdb_prompt $" { fail "derived template object, base static long" }
    timeout { fail "derived template object, base static long" }
}

# derived template object, base static enum
send_gdb "print test2.value\n"
gdb_expect {
   -re "oriental\r\n$gdb_prompt $" {
      pass "derived template object, base static enum"
    }
    -re ".*$gdb_prompt $" { fail "derived template object, base static enum" }
    timeout { fail "derived template object, base static enum" }
}

# derived template object, static enum
send_gdb "print test2.value_derived\n"
gdb_expect {
   -re "etruscan\r\n$gdb_prompt $" {
      pass "derived template object, static enum"
    }
    -re ".*$gdb_prompt $" { fail "derived template object, static enum" }
    timeout { fail "derived template object, static enum" }
}

# Three.
send_gdb "break 64\n"
gdb_expect {
   -re "Breakpoint \[0-9\]*.*line 64\\.\r\n$gdb_prompt $" {
      pass "set break at 64"
    }
    -re ".*$gdb_prompt $" { fail "set break at 64" }
    timeout { fail "(timeout) set break at 64" }
}

send_gdb "continue\n"
gdb_expect {
   -re "Continuing\\.\r\n\r\nBreakpoint.*at.*member_data_static\\.cc:64\r\n.*$gdb_prompt $" {
      pass "continue to 64"
    }
    -re ".*$gdb_prompt $" { fail "continue to 64" }
    timeout { fail "(timeout) continue to 64" }
}

# template object, static derived template data member's base static const bool
send_gdb "print test3.data.test\n"
gdb_expect {
   -re "true\r\n$gdb_prompt $" {
      pass "template object, static const bool"
    }
    -re ".*$gdb_prompt $" { fail "template object, static const bool" }
    timeout { fail "template object, static const bool" }
}

# template object, static derived template data member's base static const int
send_gdb "print test3.data.key1\n"
gdb_expect {
   -re "5\r\n$gdb_prompt $" {
      pass "template object, static const int"
    }
    -re ".*$gdb_prompt $" { fail "template object, static const int" }
    timeout { fail "template object, static const int" }
}

# template object, static derived template data member's base static long
send_gdb "print test3.data.key2\n"
gdb_expect {
   -re "77\r\n$gdb_prompt $" {
      pass "template object, static long"
    }
    -re ".*$gdb_prompt $" { fail "template object, static long" }
    timeout { fail "template object, static long" }
}

# template object, static derived template data member's base static enum
send_gdb "print test3.data.value\n"
gdb_expect {
   -re "oriental\r\n$gdb_prompt $" {
      pass "template object, static enum"
    }
    -re ".*$gdb_prompt $" { fail "template object, static enum" }
    timeout { fail "template object, static enum" }
}

#  template object, static derived template data member's static enum
send_gdb "print test3.data.value_derived\n"
gdb_expect {
   -re "etruscan\r\n$gdb_prompt $" {
      pass "template object, static enum"
    }
    -re ".*$gdb_prompt $" { fail "template object, static enum" }
    timeout { fail "template object, static enum" }
}

gdb_exit
return 0