github.com/peggyl/go@v0.0.0-20151008231540-ae315999c2d5/src/cmd/compile/internal/gc/pgen_test.go (about)

     1  // Copyright 2015 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package gc
     6  
     7  import (
     8  	"reflect"
     9  	"testing"
    10  )
    11  
    12  // Test all code paths for cmpstackvarlt.
    13  func TestCmpstackvar(t *testing.T) {
    14  	testdata := []struct {
    15  		a, b Node
    16  		lt   bool
    17  	}{
    18  		{
    19  			Node{Class: PAUTO},
    20  			Node{Class: PFUNC},
    21  			false,
    22  		},
    23  		{
    24  			Node{Class: PFUNC},
    25  			Node{Class: PAUTO},
    26  			true,
    27  		},
    28  		{
    29  			Node{Class: PFUNC, Xoffset: 0},
    30  			Node{Class: PFUNC, Xoffset: 10},
    31  			true,
    32  		},
    33  		{
    34  			Node{Class: PFUNC, Xoffset: 20},
    35  			Node{Class: PFUNC, Xoffset: 10},
    36  			false,
    37  		},
    38  		{
    39  			Node{Class: PFUNC, Xoffset: 10},
    40  			Node{Class: PFUNC, Xoffset: 10},
    41  			false,
    42  		},
    43  		{
    44  			Node{Class: PAUTO, Used: true},
    45  			Node{Class: PAUTO, Used: false},
    46  			true,
    47  		},
    48  		{
    49  			Node{Class: PAUTO, Used: false},
    50  			Node{Class: PAUTO, Used: true},
    51  			false,
    52  		},
    53  		{
    54  			Node{Class: PAUTO, Type: &Type{Haspointers: 1}}, // haspointers -> false
    55  			Node{Class: PAUTO, Type: &Type{Haspointers: 2}}, // haspointers -> true
    56  			false,
    57  		},
    58  		{
    59  			Node{Class: PAUTO, Type: &Type{Haspointers: 2}}, // haspointers -> true
    60  			Node{Class: PAUTO, Type: &Type{Haspointers: 1}}, // haspointers -> false
    61  			true,
    62  		},
    63  		{
    64  			Node{Class: PAUTO, Type: &Type{}, Name: &Name{Needzero: true}},
    65  			Node{Class: PAUTO, Type: &Type{}, Name: &Name{Needzero: false}},
    66  			true,
    67  		},
    68  		{
    69  			Node{Class: PAUTO, Type: &Type{}, Name: &Name{Needzero: false}},
    70  			Node{Class: PAUTO, Type: &Type{}, Name: &Name{Needzero: true}},
    71  			false,
    72  		},
    73  		{
    74  			Node{Class: PAUTO, Type: &Type{Width: 1}, Name: &Name{}},
    75  			Node{Class: PAUTO, Type: &Type{Width: 2}, Name: &Name{}},
    76  			false,
    77  		},
    78  		{
    79  			Node{Class: PAUTO, Type: &Type{Width: 2}, Name: &Name{}},
    80  			Node{Class: PAUTO, Type: &Type{Width: 1}, Name: &Name{}},
    81  			true,
    82  		},
    83  		{
    84  			Node{Class: PAUTO, Type: &Type{}, Name: &Name{}, Sym: &Sym{Name: "abc"}},
    85  			Node{Class: PAUTO, Type: &Type{}, Name: &Name{}, Sym: &Sym{Name: "xyz"}},
    86  			true,
    87  		},
    88  		{
    89  			Node{Class: PAUTO, Type: &Type{}, Name: &Name{}, Sym: &Sym{Name: "abc"}},
    90  			Node{Class: PAUTO, Type: &Type{}, Name: &Name{}, Sym: &Sym{Name: "abc"}},
    91  			false,
    92  		},
    93  		{
    94  			Node{Class: PAUTO, Type: &Type{}, Name: &Name{}, Sym: &Sym{Name: "xyz"}},
    95  			Node{Class: PAUTO, Type: &Type{}, Name: &Name{}, Sym: &Sym{Name: "abc"}},
    96  			false,
    97  		},
    98  	}
    99  	for _, d := range testdata {
   100  		got := cmpstackvarlt(&d.a, &d.b)
   101  		if got != d.lt {
   102  			t.Errorf("want %#v < %#v", d.a, d.b)
   103  		}
   104  	}
   105  }
   106  
   107  func slice2nodelist(s []*Node) *NodeList {
   108  	var nl *NodeList
   109  	for _, n := range s {
   110  		nl = list(nl, n)
   111  	}
   112  	return nl
   113  }
   114  
   115  func nodelist2slice(nl *NodeList) []*Node {
   116  	var s []*Node
   117  	for l := nl; l != nil; l = l.Next {
   118  		s = append(s, l.N)
   119  	}
   120  	return s
   121  }
   122  
   123  func TestListsort(t *testing.T) {
   124  	inp := []*Node{
   125  		{Class: PFUNC, Type: &Type{}, Name: &Name{}, Sym: &Sym{}},
   126  		{Class: PAUTO, Type: &Type{}, Name: &Name{}, Sym: &Sym{}},
   127  		{Class: PFUNC, Xoffset: 0, Type: &Type{}, Name: &Name{}, Sym: &Sym{}},
   128  		{Class: PFUNC, Xoffset: 10, Type: &Type{}, Name: &Name{}, Sym: &Sym{}},
   129  		{Class: PFUNC, Xoffset: 20, Type: &Type{}, Name: &Name{}, Sym: &Sym{}},
   130  		{Class: PAUTO, Used: true, Type: &Type{}, Name: &Name{}, Sym: &Sym{}},
   131  		{Class: PAUTO, Type: &Type{Haspointers: 1}, Name: &Name{}, Sym: &Sym{}}, // haspointers -> false
   132  		{Class: PAUTO, Type: &Type{}, Name: &Name{}, Sym: &Sym{}},
   133  		{Class: PAUTO, Type: &Type{}, Name: &Name{Needzero: true}, Sym: &Sym{}},
   134  		{Class: PAUTO, Type: &Type{Width: 1}, Name: &Name{}, Sym: &Sym{}},
   135  		{Class: PAUTO, Type: &Type{Width: 2}, Name: &Name{}, Sym: &Sym{}},
   136  		{Class: PAUTO, Type: &Type{}, Name: &Name{}, Sym: &Sym{Name: "abc"}},
   137  		{Class: PAUTO, Type: &Type{}, Name: &Name{}, Sym: &Sym{Name: "xyz"}},
   138  	}
   139  	want := []*Node{
   140  		{Class: PFUNC, Type: &Type{}, Name: &Name{}, Sym: &Sym{}},
   141  		{Class: PFUNC, Xoffset: 0, Type: &Type{}, Name: &Name{}, Sym: &Sym{}},
   142  		{Class: PFUNC, Xoffset: 10, Type: &Type{}, Name: &Name{}, Sym: &Sym{}},
   143  		{Class: PFUNC, Xoffset: 20, Type: &Type{}, Name: &Name{}, Sym: &Sym{}},
   144  		{Class: PAUTO, Used: true, Type: &Type{}, Name: &Name{}, Sym: &Sym{}},
   145  		{Class: PAUTO, Type: &Type{}, Name: &Name{Needzero: true}, Sym: &Sym{}},
   146  		{Class: PAUTO, Type: &Type{Width: 2}, Name: &Name{}, Sym: &Sym{}},
   147  		{Class: PAUTO, Type: &Type{Width: 1}, Name: &Name{}, Sym: &Sym{}},
   148  		{Class: PAUTO, Type: &Type{}, Name: &Name{}, Sym: &Sym{}},
   149  		{Class: PAUTO, Type: &Type{}, Name: &Name{}, Sym: &Sym{}},
   150  		{Class: PAUTO, Type: &Type{}, Name: &Name{}, Sym: &Sym{Name: "abc"}},
   151  		{Class: PAUTO, Type: &Type{}, Name: &Name{}, Sym: &Sym{Name: "xyz"}},
   152  		{Class: PAUTO, Type: &Type{Haspointers: 1}, Name: &Name{}, Sym: &Sym{}}, // haspointers -> false
   153  	}
   154  	// haspointers updates Type.Haspointers as a side effect, so
   155  	// exercise this function on all inputs so that reflect.DeepEqual
   156  	// doesn't produce false positives.
   157  	for i := range want {
   158  		haspointers(want[i].Type)
   159  		haspointers(inp[i].Type)
   160  	}
   161  
   162  	nl := slice2nodelist(inp)
   163  	listsort(&nl, cmpstackvarlt)
   164  	got := nodelist2slice(nl)
   165  	if !reflect.DeepEqual(want, got) {
   166  		t.Error("listsort failed")
   167  		for i := range got {
   168  			g := got[i]
   169  			w := want[i]
   170  			eq := reflect.DeepEqual(w, g)
   171  			if !eq {
   172  				t.Log(i, w, g)
   173  			}
   174  		}
   175  	}
   176  }