From 554fd8c5195424bdbcabf5de30fdc183aba391bd Mon Sep 17 00:00:00 2001
From: upstream source tree <ports@midipix.org>
Date: Sun, 15 Mar 2015 20:14:05 -0400
Subject: obtained gcc-4.6.4.tar.bz2 from upstream website; verified
 gcc-4.6.4.tar.bz2.sig; imported gcc-4.6.4 source tree from verified upstream
 tarball.

downloading a git-generated archive based on the 'upstream' tag
should provide you with a source tree that is binary identical
to the one extracted from the above tarball.

if you have obtained the source via the command 'git clone',
however, do note that line-endings of files in your working
directory might differ from line-endings of the respective
files in the upstream repository.
---
 libgo/go/debug/dwarf/type_test.go | 112 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 112 insertions(+)
 create mode 100644 libgo/go/debug/dwarf/type_test.go

(limited to 'libgo/go/debug/dwarf/type_test.go')

diff --git a/libgo/go/debug/dwarf/type_test.go b/libgo/go/debug/dwarf/type_test.go
new file mode 100644
index 000000000..e01f7353a
--- /dev/null
+++ b/libgo/go/debug/dwarf/type_test.go
@@ -0,0 +1,112 @@
+// Copyright 2009 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package dwarf_test
+
+import (
+	. "debug/dwarf"
+	"debug/elf"
+	"debug/macho"
+	"testing"
+)
+
+var typedefTests = map[string]string{
+	"t_ptr_volatile_int":                    "*volatile int",
+	"t_ptr_const_char":                      "*const char",
+	"t_long":                                "long int",
+	"t_ushort":                              "short unsigned int",
+	"t_func_int_of_float_double":            "func(float, double) int",
+	"t_ptr_func_int_of_float_double":        "*func(float, double) int",
+	"t_ptr_func_int_of_float_complex":       "*func(complex float) int",
+	"t_ptr_func_int_of_double_complex":      "*func(complex double) int",
+	"t_ptr_func_int_of_long_double_complex": "*func(complex long double) int",
+	"t_func_ptr_int_of_char_schar_uchar":    "func(char, signed char, unsigned char) *int",
+	"t_func_void_of_char":                   "func(char) void",
+	"t_func_void_of_void":                   "func() void",
+	"t_func_void_of_ptr_char_dots":          "func(*char, ...) void",
+	"t_my_struct":                           "struct my_struct {vi volatile int@0; x char@4 : 1@7; y int@4 : 4@27; array [40]long long int@8}",
+	"t_my_union":                            "union my_union {vi volatile int@0; x char@0 : 1@7; y int@0 : 4@28; array [40]long long int@0}",
+	"t_my_enum":                             "enum my_enum {e1=1; e2=2; e3=-5; e4=1000000000000000}",
+	"t_my_list":                             "struct list {val short int@0; next *t_my_list@8}",
+	"t_my_tree":                             "struct tree {left *struct tree@0; right *struct tree@8; val long long unsigned int@16}",
+}
+
+func elfData(t *testing.T, name string) *Data {
+	f, err := elf.Open(name)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	d, err := f.DWARF()
+	if err != nil {
+		t.Fatal(err)
+	}
+	return d
+}
+
+func machoData(t *testing.T, name string) *Data {
+	f, err := macho.Open(name)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	d, err := f.DWARF()
+	if err != nil {
+		t.Fatal(err)
+	}
+	return d
+}
+
+
+func TestTypedefsELF(t *testing.T) { testTypedefs(t, elfData(t, "testdata/typedef.elf")) }
+
+func TestTypedefsMachO(t *testing.T) {
+	testTypedefs(t, machoData(t, "testdata/typedef.macho"))
+}
+
+func testTypedefs(t *testing.T, d *Data) {
+	r := d.Reader()
+	seen := make(map[string]bool)
+	for {
+		e, err := r.Next()
+		if err != nil {
+			t.Fatal("r.Next:", err)
+		}
+		if e == nil {
+			break
+		}
+		if e.Tag == TagTypedef {
+			typ, err := d.Type(e.Offset)
+			if err != nil {
+				t.Fatal("d.Type:", err)
+			}
+			t1 := typ.(*TypedefType)
+			var typstr string
+			if ts, ok := t1.Type.(*StructType); ok {
+				typstr = ts.Defn()
+			} else {
+				typstr = t1.Type.String()
+			}
+
+			if want, ok := typedefTests[t1.Name]; ok {
+				if seen[t1.Name] {
+					t.Errorf("multiple definitions for %s", t1.Name)
+				}
+				seen[t1.Name] = true
+				if typstr != want {
+					t.Errorf("%s:\n\thave %s\n\twant %s", t1.Name, typstr, want)
+				}
+			}
+		}
+		if e.Tag != TagCompileUnit {
+			r.SkipChildren()
+		}
+	}
+
+	for k := range typedefTests {
+		if !seen[k] {
+			t.Errorf("missing %s", k)
+		}
+	}
+}
-- 
cgit v1.2.3