gdb.c++ testsuite 1: member data

[Benjamin Kosnik <bkoz@redhat.com>]

[-- 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