again: ping: testcase for "absolute source" patch

again: ping: testcase for "absolute source" patch

[Baurzhan Ismagulov]

Hello,

the recent discussion reminded me about the testcase I submitted in
http://sources.redhat.com/ml/gdb-patches/2004-08/msg00539.html . While
unrelated, it did help me understand the issue. There are relatively few
basic cases (like absolute / relative, compilation cwd present / absent,
etc., search path specified / not specified, etc.), it's their
permutations that kill. While the testcase doesn't cover them all, I
think it's a good start, especially if we are going to touch some
functionality affecting openp. The functionality is very basic and
breaks everything if anything goes wrong; it happened several times in
the past, thus the motivation for this testcase.

A short history: Michael Chastain was guiding me w.r.t. this testcase.
Basically, he had three issues with it:

1. The testcase didn't support build != host.

   The overall consensus was that there were useful testcases that
   didn't support build != host at the moment. Michael decided to
   include them if they explicitly returned unresolved on remote hosts.
   I added the check.

2. Michael wanted to understand it.

   We had come relatively far, but Michael got a new job and apparently
   didn't have much time to review the testcase since
   http://sources.redhat.com/ml/gdb-patches/2004-10/msg00281.html .

3. There were four cases where I was not sure what we wanted to do, so I
   marked them "fail".

   I asked for feedback several times, but haven't received any answer.

So, I suggest that we review, polish and include this testcase. After
that, we can test it on more platforms and add new permutations for
non-POSIX names.

Comments?

With kind regards,
Baurzhan.

Re: again: ping: testcase for "absolute source" patch

[Baurzhan Ismagulov]

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

Sorry, forgot to include the testcase.

With kind regards,
Baurzhan.

2005-05-05  Baurzhan Ismagulov  <ibr@ata.cs.hun.edu.tr>

	* gdb.base/openp.c: New testcase.
	* gdb.base/openp.exp: New testcase checking for source, binary
	and compilation directory handling.

[-- Attachment #2: openp.c --]
[-- Type: text/x-csrc, Size: 22 bytes --]

int main(){return 0;}

[-- Attachment #3: openp.exp --]
[-- Type: text/plain, Size: 16708 bytes --]

#   Copyright (C) 2004 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.  

# This file was written by Baurzhan Ismagulov <ibr@ata.cs.hun.edu.tr>.
# $Id: openp.exp,v 1.9 2004/10/15 15:04:04 ibr Exp $

# This file tests whether gdb finds the files properly given the
# following file names:
# 1. basename:   file
# 2. absolute:   /dir/file
# 3. relative:   dir/file
# 4. in current: ./file
# 5. in upper:   ../file

# This is checked for binaries as well as for sources. To do that, we
# place them in some specific locations, such as compilation directory,
# $PATH, gdb source path ("directory" command), etc. As the files from
# the previous tests could interfere with the test currently running
# (sometimes we expect gdb to find a file, sometimes -- not), we define
# a certain state of files and directories as canonical, move the files
# around before each test, and move them back thereafter.


# Resolve possibe /./ and /../ within the given path. We are paranoid
# about cases like "mkdir -p a/../b" (although GNU coreutils and Solaris
# 8 seem to handle this particular case).
# XXX: Can this be replaced with tcl path manipulation routines?
proc canonize_path {dir} {
    set old_dir [pwd]
    cd $dir
    set new_dir [pwd]
    cd $old_dir
    return $new_dir
}

# Compile $src to $bin in $cdir.
# XXX: build == host.
proc cdir_compile {cdir src bin} {
    if [catch {set old_dir [pwd]} msg] {
	perror $msg
	return -1
    }
    if [catch {cd $cdir} msg] {
	perror $msg
	return -1
    }
    if {[gdb_compile $src $bin executable debug] != ""} {
	perror "Testcase compile failed."
	return -1
    }
    if [catch {cd $old_dir} msg] {
	perror $msg
	return -1
    }
    return 0
}

# Move the binary to $bin_dir, add $path_dir to PATH, gdb_test in the
# $gdb_wd directory.
# XXX: build == host.
proc test_bin {gdb_wd bin_dir path_dir gdb_test_cmd gdb_resp txt} {
    global binname
    global binfile
    global env
    if {$bin_dir != ""} {
	if {[lindex [remote_exec host "mv $binfile $bin_dir"] 0] != 0} {
	    unresolved "Failed to move $binfile to $bin_dir."
	    return -1
	}
	set our_bin $bin_dir/$binname
    } else {
	set our_bin $binfile
    }
    if {$path_dir != "" && [info exists env(PATH)]} {
	if [catch {set old_path $env(PATH)} msg] {
	    perror $msg
	    return -1
	}
	# XXX: Directory separator in PATH?
	if [catch {set env(PATH) $env(PATH):$path_dir} msg] {
	    perror $msg
	    return -1
	}
    }
    if [catch {set old_dir [pwd]} msg] {
	perror $msg
	return -1
    }
    if [catch {cd $gdb_wd} msg] {
	perror $msg
	return -1
    }
    pass "test_bin: We are in $gdb_wd, our binary is $our_bin, and we've added \"$path_dir\" to PATH."
    gdb_start
    gdb_test $gdb_test_cmd $gdb_resp $txt
    gdb_exit
    if [catch {cd $old_dir} msg] {
	perror $msg
	return -1
    }
    if [info exists old_path] {
	if [catch {set env(PATH) $old_path} msg] {
	    perror $msg
	    return -1
	}
    }
    if {$bin_dir != ""} {
	if {[lindex [remote_exec host "mv $bin_dir/$binname $binfile"] 0] != 0} {
	    unresolved "Failed to move $bin_dir/$binname to $binfile."
	    return -1
	}
    }
    return 0
}

# Compile in $comp_dir, move the source to $srcfile_dir, perform $cmd1
# and $cmd2, gdb_test in $gdb_wd.
# XXX: build == host.
proc test_src {comp_dir comp_srcfile comp_binfile srcfile_dir
	       gdb_wd cmd1 cmd2 gdb_test_cmd gdb_resp txt} {
    global srcname
    global srcfile

    if [catch {set old_dir [pwd]} msg] {
	perror $msg
	return -1
    }
    if {[cdir_compile $comp_dir $comp_srcfile $comp_binfile] != 0} {
	unresolved "Failed to compile $comp_srcfile to $comp_binfile in $comp_dir."
	return -1
    }
    if {$srcfile_dir != ""} {
	if {[lindex [remote_exec host "mv $srcfile $srcfile_dir"] 0] != 0} {
	    unresolved "Failed to move $srcfile to $srcfile_dir."
	    return -1
	}
	set our_src $srcfile_dir/$srcname
    } else {
	set our_src $srcfile
    }
    if [catch {cd $gdb_wd} msg] {
	perror $msg
	return -1
    }
    pass "test_src: We are in $gdb_wd, our source is $our_src and was compiled under $comp_dir as $comp_srcfile."
    gdb_start
    if {$cmd1 != ""} {
	gdb_test $cmd1 ""
    }
    if {$cmd2 != ""} {
	gdb_test $cmd2 ""
    }
    gdb_test $gdb_test_cmd $gdb_resp $txt
    gdb_exit
    if [catch {cd $old_dir} msg] {
	perror $msg
	return -1
    }
    if {$srcfile_dir != ""} {
	if {[lindex [remote_exec host "mv $srcfile_dir/$srcname $srcfile"] 0] != 0} {
	    unresolved "Failed to move $srcfile_dir/$srcname to $srcfile."
	    return -1
	}
    }
    return 0
}


if {[is_remote host]} {
    unresolved "This test script does not work on a remote host."
    return -1
}

if $tracelevel then {
    strace $tracelevel
}

set prms_id 0
set bug_id 0

set testname "openp"
set srcname $testname.c
set binname $testname.bin
set testtmpdir [canonize_path $objdir/$subdir]/$testname
set srcfile $testtmpdir/subdir/src/$srcname
set binfile $testtmpdir/subdir/bin/$binname

set src_txt {1.int main\(\){return 0;}.*}

if {[lindex [remote_exec host "mkdir -p \
$testtmpdir/subdir/src/subdir \
$testtmpdir/subdir/bin/subdir \
$testtmpdir/subdir/cwd/bin \
$testtmpdir/subdir/cwd/src \
$testtmpdir/subdir/dir$testtmpdir/subdir/src/subdir \
$testtmpdir/subdir/dir$testtmpdir/subdir/bin \
$testtmpdir/subdir/dir/src"] 0] != 0} {
    unresolved "Failed to create the directories under $testtmpdir/subdir."
    return -1
}
if {[lindex [remote_exec host "cp $srcdir/$subdir/$testname.c $srcfile"] 0] != 0} {
    unresolved "Failed to copy $srcdir/$subdir/$testname.c to $srcfile."
    return -1
}
if {[cdir_compile $testtmpdir $srcfile $binfile] != 0} {
    unresolved "Failed to compile $srcfile to $binfile in $testtmpdir."
    return -1
}
gdb_exit

# At this point our canonical environment is ready. The binary is in
# $binfile. It can be moved by some test if necessary, but must be moved
# back after the test; leaving it where it was during the test may cause
# false passes or failures in the next tests. Since we test where gdb
# should find or not find a given file, we should have exactly one
# binary for the binary tests, otherwise we cannot be sure which one was
# found by gdb.

# Likewise, the source is in $srcfile, and we should have exactly one
# source for the source tests. The binaries are compiled by every test
# and deleted afterwards.


# b1+
test_bin $testtmpdir/subdir/bin \
    "" \
    "" \
    "file $binname" \
    "Reading symbols from $binfile\\.\\.\\.done\\..*" \
    "openp b1+ (existing binary, basename)"

# b1-
test_bin $testtmpdir/subdir/cwd \
    "" \
    $testtmpdir/subdir/bin \
    "file $binname" \
    "Reading symbols from $binfile\\.\\.\\..*done\\..*" \
    "openp b1- (non-existent binary, basename, find in PATH)"

# b2+
test_bin $testtmpdir/subdir/cwd \
    "" \
    "" \
    "file $binfile" \
    "Reading symbols from $binfile\\.\\.\\.done\\..*" \
    "openp b2+ (existing binary, absolute name)"

# b2-a
# XXX: Should we match locale-specific messages?
test_bin $testtmpdir/subdir/cwd \
    $testtmpdir/subdir/dir$testtmpdir/subdir/bin \
    $testtmpdir/subdir/dir \
    "file $binfile" \
    "$binfile: .*" \
    "openp b2-a (non-existent binary, absolute name, don't look in <PATH_dir>/absolute)"

# b2-
# XXX: Should we match locale-specific messages?
test_bin $testtmpdir/subdir/cwd \
    $testtmpdir/subdir/dir \
    $testtmpdir/subdir/dir \
    "file $binfile" \
    "$binfile: .*" \
    "openp b2- (non-existent binary, absolute name, don't look for <PATH_dir>/basename)"

# b3+
test_bin $testtmpdir/subdir \
    "" \
    "" \
    "file bin/$binname" \
    "Reading symbols from $binfile\\.\\.\\.done\\..*" \
    "openp b3+ (existing binary, relative name)"

# b3-r
# XXX: locale
test_bin $testtmpdir/subdir/cwd \
    "" \
    $testtmpdir/subdir \
    "file bin/$binname" \
    "bin/$binname: .*" \
    "openp b3-r (non-existent binary, relative name, don't look in <PATH_dir>/relative)"

# b3-
# XXX: locale
test_bin $testtmpdir/subdir/cwd \
    "" \
    $testtmpdir/subdir/bin \
    "file bin/$binname" \
    "bin/$binname: .*" \
    "openp b3- (non-existent binary, relative name, don't look in <PATH_dir>/basename)"

# b4+
test_bin $testtmpdir/subdir/bin \
    "" \
    "" \
    "file ./$binname" \
    "Reading symbols from $binfile\\.\\.\\.done\\..*" \
    "openp b4+ (existing binary, in the current dir)"

# b4-
# XXX: locale
test_bin $testtmpdir/subdir/cwd \
    "" \
    $testtmpdir/subdir/bin \
    "file ./$binname" \
    "\\./$binname: .*" \
    "openp b4- (non-existent binary, in the current dir, don't look in PATH)"

# b5+
test_bin $testtmpdir/subdir/bin/subdir \
    "" \
    "" \
    "file ../$binname" \
    "Reading symbols from $binfile\\.\\.\\.done\\..*" \
    "openp b5+ (existing binary, in the upper dir)"

# b5-r
# XXX: locale
test_bin $testtmpdir/subdir/cwd \
    "" \
    $testtmpdir/subdir/bin/subdir \
    "file ../$binname" \
    "\\.\\./$binname: .*" \
    "openp b5-r (non-existent binary, in the upper dir name, don't look in <PATH_dir>/relative)"

# b5-
# XXX: locale
test_bin $testtmpdir/subdir/cwd \
    "" \
    $testtmpdir/subdir/bin \
    "file ../$binname" \
    "\\.\\./$binname: .*" \
    "openp b5- (non-existent binary, in the upper dir name, don't look in <PATH_dir>/basename)"


# s1+
test_src $testtmpdir/subdir/src $srcname $binfile \
    "" \
    $testtmpdir/subdir/cwd \
    "file $binfile" "" \
    "l main" \
    $src_txt \
    "openp s1+ (existing source, basename)"

# s1-.
test_src $testtmpdir/subdir/src $srcname $binfile \
    $testtmpdir/subdir/cwd \
    $testtmpdir/subdir/cwd \
    "file $binfile" "" \
    "l main" \
    $src_txt \
    "openp s1-. (non-existent source, basename, find in \$cwd/basename)"

# s1-da
test_src $testtmpdir/subdir/src $srcname $binfile \
    $testtmpdir/subdir/dir$testtmpdir/subdir/src \
    $testtmpdir/subdir/cwd \
    "dir $testtmpdir/subdir/dir" "file $binfile" \
    "l main" \
    $src_txt \
    "openp s1-da (non-existent source, basename, find in <dir>/\$cdir/basename)"

# s1-d
test_src $testtmpdir/subdir/src $srcname $binfile \
    $testtmpdir/subdir/dir \
    $testtmpdir/subdir/cwd \
    "dir $testtmpdir/subdir/dir" "file $binfile" \
    "l main" \
    $src_txt \
    "openp s1-d (non-existent source, basename, find in <dir>/basename)"

# s2+
test_src $testtmpdir $srcfile $binfile \
    "" \
    $testtmpdir/subdir/cwd \
    "file $binfile" ""\
    "l main" \
    $src_txt \
    "openp s2+ (existing source, absolute name)"

# s2-.
test_src $testtmpdir $srcfile $binfile \
    $testtmpdir/subdir/cwd \
    $testtmpdir/subdir/cwd \
    "file $binfile" "" \
    "l main" \
    $src_txt \
    "openp s2-. (non-existent source, absolute name, find in \$cwd/basename)"

# s2-da
test_src $testtmpdir $srcfile $binfile \
    $testtmpdir/subdir/dir$testtmpdir/subdir/src \
    $testtmpdir/subdir/cwd \
    "dir $testtmpdir/subdir/dir" "file $binfile" \
    "l main" \
    $src_txt \
    "openp s2-da (non-existent source, absolute name, find in <dir>/absolute)"

# s2-d
test_src $testtmpdir $srcfile $binfile \
    $testtmpdir/subdir/dir \
    $testtmpdir/subdir/cwd \
    "dir $testtmpdir/subdir/dir" "file $binfile" \
    "l main" \
    $src_txt \
    "openp s2-d (non-existent source, absolute name, find in <dir>/basename)"

# s3+
test_src $testtmpdir/subdir src/$srcname $binfile \
    "" \
    $testtmpdir/subdir/cwd \
    "file $binfile" "" \
    "l main" \
    $src_txt \
    "openp s3+ (existing source, relative name)"

# s3-.r
test_src $testtmpdir/subdir src/$srcname $binfile \
    $testtmpdir/subdir/cwd/src \
    $testtmpdir/subdir/cwd \
    "file $binfile" "" \
    "l main" \
    $src_txt \
    "openp s3-.r (non-existent source, relative name, find in \$cwd/relative)"

# s3-c
test_src $testtmpdir/subdir src/$srcname $binfile \
    $testtmpdir/subdir \
    $testtmpdir/subdir/cwd \
    "file $binfile" "" \
    "l main" \
    $src_txt \
    "openp s3-c (non-existent source, relative name, find in \$cdir/basename)"

# s3-.
test_src $testtmpdir/subdir src/$srcname $binfile \
    $testtmpdir/subdir/cwd \
    $testtmpdir/subdir/cwd \
    "file $binfile" "" \
    "l main" \
    $src_txt \
    "openp s3-. (non-existent source, relative name, find in \$cwd/basename)"

# s3-da
test_src $testtmpdir/subdir src/$srcname $binfile \
    $testtmpdir/subdir/dir$testtmpdir/subdir \
    $testtmpdir/subdir/cwd \
    "dir $testtmpdir/subdir/dir" "file $binfile" \
    "l main" \
    $src_txt \
    "openp s3-da (non-existent source, relative name, find in <dir>/\$cdir/relative)"

# s3-dr
test_src $testtmpdir/subdir src/$srcname $binfile \
    $testtmpdir/subdir/dir/src \
    $testtmpdir/subdir/cwd \
    "dir $testtmpdir/subdir/dir" "file $binfile" \
    "l main" \
    $src_txt \
    "openp s3-dr (non-existent source, relative name, find in <dir>/relative)"

# s3-d
test_src $testtmpdir/subdir src/$srcname $binfile \
    $testtmpdir/subdir/dir \
    $testtmpdir/subdir/cwd \
    "dir $testtmpdir/subdir/dir" "file $binfile" \
    "l main" \
    $src_txt \
    "openp s3-d (non-existent source, relative name, find in <dir>/basename)"

# s4+
test_src $testtmpdir/subdir/src ./$srcname $binfile \
    "" \
    $testtmpdir/subdir/cwd \
    "file $binfile" "" \
    "l main" \
    $src_txt \
    "openp s4+ (existing source, in the current dir)"

# s4-.
test_src $testtmpdir/subdir/src ./$srcname $binfile \
    $testtmpdir/subdir/cwd \
    $testtmpdir/subdir/cwd \
    "file $binfile" "" \
    "l main" \
    $src_txt \
    "openp s4-. (non-existent source, in the current dir, find in \$cwd/basename)"

# s4-da
test_src $testtmpdir/subdir/src ./$srcname $binfile \
    $testtmpdir/subdir/dir$testtmpdir/subdir/src \
    $testtmpdir/subdir/cwd \
    "dir $testtmpdir/subdir/dir" "file $binfile" \
    "l main" \
    $src_txt \
    "openp s4-da (non-existent source, in the current dir, find in <dir>/\$cdir/basename)"

# s4-d
test_src $testtmpdir/subdir/src ./$srcname $binfile \
    $testtmpdir/subdir/dir \
    $testtmpdir/subdir/cwd \
    "dir $testtmpdir/subdir/dir" "file $binfile" \
    "l main" \
    $src_txt \
    "openp s4-d (non-existent source, in the current dir, find in <dir>/basename)"

# s5+
test_src $testtmpdir/subdir/src/subdir ../$srcname $binfile \
    "" \
    $testtmpdir/subdir/cwd \
    "file $binfile" "" \
    "l main" \
    $src_txt \
    "openp s5+ (existing source, in the upper dir)"

# s5-.r
test_src $testtmpdir/subdir/src/subdir ../$srcname $binfile \
    $testtmpdir/subdir \
    $testtmpdir/subdir/cwd \
    "file $binfile" "" \
    "l main" \
    $src_txt \
    "openp s5-.r (non-existent source, in the upper dir, find in \$cwd/relative)"

# s5-c
test_src $testtmpdir/subdir/src/subdir ../$srcname $binfile \
    $testtmpdir/subdir/src/subdir \
    $testtmpdir/subdir/cwd \
    "file $binfile" "" \
    "l main" \
    $src_txt \
    "openp s5-c (non-existent source, in the upper dir, find in \$cdir/basename)"

# s5-.
test_src $testtmpdir/subdir/src/subdir ../$srcname $binfile \
    $testtmpdir/subdir/cwd \
    $testtmpdir/subdir/cwd \
    "file $binfile" "" \
    "l main" \
    $src_txt \
    "openp s5-. (non-existent source, in the upper dir, find in \$cdir/basename)"

# s5-da
test_src $testtmpdir/subdir/src/subdir ../$srcname $binfile \
    $testtmpdir/subdir/dir$testtmpdir/subdir/src/subdir \
    $testtmpdir/subdir/cwd \
    "dir $testtmpdir/subdir/dir" "file $binfile" \
    "l main" \
    $src_txt \
    "openp s5-da (non-existent source, in the upper dir, find in <dir>/\$cdir/relative)"

# s5-dr
test_src $testtmpdir/subdir/src/subdir ../$srcname $binfile \
    $testtmpdir/subdir \
    $testtmpdir/subdir/cwd \
    "dir $testtmpdir/subdir/dir" "file $binfile" \
    "l main" \
    $src_txt \
    "openp s5-dr (non-existent source, in the upper dir, find in <dir>/relative)"

# s5-d
test_src $testtmpdir/subdir/src/subdir ../$srcname $binfile \
    $testtmpdir/subdir/dir \
    $testtmpdir/subdir/cwd \
    "dir $testtmpdir/subdir/dir" "file $binfile" \
    "l main" \
    $src_txt \
    "openp s5-d (non-existent source, in the upper dir, find in <dir>/basename)"

Re: again: ping: testcase for "absolute source" patch

[Daniel Jacobowitz]

On Thu, May 05, 2005 at 01:00:48PM +0200, Baurzhan Ismagulov wrote:
> Hello,
> 
> the recent discussion reminded me about the testcase I submitted in
> http://sources.redhat.com/ml/gdb-patches/2004-08/msg00539.html . While
> unrelated, it did help me understand the issue. There are relatively few
> basic cases (like absolute / relative, compilation cwd present / absent,
> etc., search path specified / not specified, etc.), it's their
> permutations that kill. While the testcase doesn't cover them all, I
> think it's a good start, especially if we are going to touch some
> functionality affecting openp. The functionality is very basic and
> breaks everything if anything goes wrong; it happened several times in
> the past, thus the motivation for this testcase.

We don't plan to touch openp right now; but let's test it, by all
means.

> A short history: Michael Chastain was guiding me w.r.t. this testcase.
> Basically, he had three issues with it:
> 
> 1. The testcase didn't support build != host.
> 
>    The overall consensus was that there were useful testcases that
>    didn't support build != host at the moment. Michael decided to
>    include them if they explicitly returned unresolved on remote hosts.
>    I added the check.

Lately we've been caring about this even less.

> 3. There were four cases where I was not sure what we wanted to do, so I
>    marked them "fail".
> 
>    I asked for feedback several times, but haven't received any answer.

Adding new FAILs is not ok; at a minimum they should have a PR filed
and be KFAIL'd.  But let's take a brief check to see what the logical
thing to do would be.  Here's the reference:

  http://sources.redhat.com/ml/gdb-patches/2004-08/msg00539.html

If I understand the test right - which is hard to do, definitely -
these cases look like:

  cd $a
  gcc -g -o $b/openp.bin openp.c
  mv openp.c $c/$a/openp.c
  (gdb) dir $c
  (gdb) file $b/openp.bin

And then you fail because we didn't search for the absolute path $a
relative to $c, which is in our search path.

I don't think there's much value to this, if $cdir is an absolute path.
If it's a relative path, maybe, but your compiler oughtn't to be doing
that.  Can you explain why you think this should work?

I do know of some problems with openp that are sort of like this - I
encounter them periodically debugging glibc.  They're a little similar
but related, and you might want to add tests for them.  Here's one:

drow@nevyn:~/dir% pwd
/home/drow/dir
drow@nevyn:~/dir% cat 1/1.c
#include <../2/2.h>

int main()
{ return 0; }
drow@nevyn:~/dir% cat 2/2.h
int foo() { return 1;}
drow@nevyn:~/dir% (cd 1 && gcc -g -o 1 1.c -I.)
drow@nevyn:~/dir% (cd 1 && gdb 1)
...
(gdb) list foo
1       int foo() { return 1;}
drow@nevyn:~/dir% gdb ./1/1
...
(gdb) list foo
1       2.h: No such file or directory.
        in 2.h
(gdb) info source
Current source file is 2.h
Compilation directory is ../2


...

Current source file is 1.c
Compilation directory is /home/drow/dir/1

We've lost the fact that "../2" is relative to the compilation
directory for the main source file; I'm not sure if this is a dwarf2
reader bug or a symtab bug or an openp bug.  But it bugs me.  A lot.

> So, I suggest that we review, polish and include this testcase. After
> that, we can test it on more platforms and add new permutations for
> non-POSIX names.
> 
> Comments?

You're including pathnames in the test results.  I'd really rather you
didn't do that; it makes results hard to compare, and really really
hard to read.  Also, a lot of the tests have shortened names like "s1"
but those names don't tell the reader anything.  So in some places you
need to be less descriptive and in others more descriptive.  Ideally I
can fit the descriptions on a screen (80-col plus or minus a bit) and
yet still have some idea what they are testing.


-- 
Daniel Jacobowitz
CodeSourcery, LLC