github.com/miolini/go@v0.0.0-20160405192216-fca68c8cb408/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  	"sort"
    10  	"testing"
    11  )
    12  
    13  // Test all code paths for cmpstackvarlt.
    14  func TestCmpstackvar(t *testing.T) {
    15  	testdata := []struct {
    16  		a, b Node
    17  		lt   bool
    18  	}{
    19  		{
    20  			Node{Class: PAUTO},
    21  			Node{Class: PFUNC},
    22  			false,
    23  		},
    24  		{
    25  			Node{Class: PFUNC},
    26  			Node{Class: PAUTO},
    27  			true,
    28  		},
    29  		{
    30  			Node{Class: PFUNC, Xoffset: 0},
    31  			Node{Class: PFUNC, Xoffset: 10},
    32  			true,
    33  		},
    34  		{
    35  			Node{Class: PFUNC, Xoffset: 20},
    36  			Node{Class: PFUNC, Xoffset: 10},
    37  			false,
    38  		},
    39  		{
    40  			Node{Class: PFUNC, Xoffset: 10},
    41  			Node{Class: PFUNC, Xoffset: 10},
    42  			false,
    43  		},
    44  		{
    45  			Node{Class: PPARAM, Xoffset: 10},
    46  			Node{Class: PPARAMOUT, Xoffset: 20},
    47  			true,
    48  		},
    49  		{
    50  			Node{Class: PPARAMOUT, Xoffset: 10},
    51  			Node{Class: PPARAM, Xoffset: 20},
    52  			true,
    53  		},
    54  		{
    55  			Node{Class: PAUTO, Used: true},
    56  			Node{Class: PAUTO, Used: false},
    57  			true,
    58  		},
    59  		{
    60  			Node{Class: PAUTO, Used: false},
    61  			Node{Class: PAUTO, Used: true},
    62  			false,
    63  		},
    64  		{
    65  			Node{Class: PAUTO, Type: &Type{Haspointers: 1}}, // haspointers -> false
    66  			Node{Class: PAUTO, Type: &Type{Haspointers: 2}}, // haspointers -> true
    67  			false,
    68  		},
    69  		{
    70  			Node{Class: PAUTO, Type: &Type{Haspointers: 2}}, // haspointers -> true
    71  			Node{Class: PAUTO, Type: &Type{Haspointers: 1}}, // haspointers -> false
    72  			true,
    73  		},
    74  		{
    75  			Node{Class: PAUTO, Type: &Type{}, Name: &Name{Needzero: true}},
    76  			Node{Class: PAUTO, Type: &Type{}, Name: &Name{Needzero: false}},
    77  			true,
    78  		},
    79  		{
    80  			Node{Class: PAUTO, Type: &Type{}, Name: &Name{Needzero: false}},
    81  			Node{Class: PAUTO, Type: &Type{}, Name: &Name{Needzero: true}},
    82  			false,
    83  		},
    84  		{
    85  			Node{Class: PAUTO, Type: &Type{Width: 1}, Name: &Name{}},
    86  			Node{Class: PAUTO, Type: &Type{Width: 2}, Name: &Name{}},
    87  			false,
    88  		},
    89  		{
    90  			Node{Class: PAUTO, Type: &Type{Width: 2}, Name: &Name{}},
    91  			Node{Class: PAUTO, Type: &Type{Width: 1}, Name: &Name{}},
    92  			true,
    93  		},
    94  		{
    95  			Node{Class: PAUTO, Type: &Type{}, Name: &Name{}, Sym: &Sym{Name: "abc"}},
    96  			Node{Class: PAUTO, Type: &Type{}, Name: &Name{}, Sym: &Sym{Name: "xyz"}},
    97  			true,
    98  		},
    99  		{
   100  			Node{Class: PAUTO, Type: &Type{}, Name: &Name{}, Sym: &Sym{Name: "abc"}},
   101  			Node{Class: PAUTO, Type: &Type{}, Name: &Name{}, Sym: &Sym{Name: "abc"}},
   102  			false,
   103  		},
   104  		{
   105  			Node{Class: PAUTO, Type: &Type{}, Name: &Name{}, Sym: &Sym{Name: "xyz"}},
   106  			Node{Class: PAUTO, Type: &Type{}, Name: &Name{}, Sym: &Sym{Name: "abc"}},
   107  			false,
   108  		},
   109  	}
   110  	for _, d := range testdata {
   111  		got := cmpstackvarlt(&d.a, &d.b)
   112  		if got != d.lt {
   113  			t.Errorf("want %#v < %#v", d.a, d.b)
   114  		}
   115  		// If we expect a < b to be true, check that b < a is false.
   116  		if d.lt && cmpstackvarlt(&d.b, &d.a) {
   117  			t.Errorf("unexpected %#v < %#v", d.b, d.a)
   118  		}
   119  	}
   120  }
   121  
   122  func TestStackvarSort(t *testing.T) {
   123  	inp := []*Node{
   124  		{Class: PFUNC, Type: &Type{}, Name: &Name{}, Sym: &Sym{}},
   125  		{Class: PAUTO, Type: &Type{}, Name: &Name{}, Sym: &Sym{}},
   126  		{Class: PFUNC, Xoffset: 0, Type: &Type{}, Name: &Name{}, Sym: &Sym{}},
   127  		{Class: PFUNC, Xoffset: 10, Type: &Type{}, Name: &Name{}, Sym: &Sym{}},
   128  		{Class: PFUNC, Xoffset: 20, Type: &Type{}, Name: &Name{}, Sym: &Sym{}},
   129  		{Class: PAUTO, Used: true, Type: &Type{}, Name: &Name{}, Sym: &Sym{}},
   130  		{Class: PAUTO, Type: &Type{Haspointers: 1}, Name: &Name{}, Sym: &Sym{}}, // haspointers -> false
   131  		{Class: PAUTO, Type: &Type{}, Name: &Name{}, Sym: &Sym{}},
   132  		{Class: PAUTO, Type: &Type{}, Name: &Name{Needzero: true}, Sym: &Sym{}},
   133  		{Class: PAUTO, Type: &Type{Width: 1}, Name: &Name{}, Sym: &Sym{}},
   134  		{Class: PAUTO, Type: &Type{Width: 2}, Name: &Name{}, Sym: &Sym{}},
   135  		{Class: PAUTO, Type: &Type{}, Name: &Name{}, Sym: &Sym{Name: "abc"}},
   136  		{Class: PAUTO, Type: &Type{}, Name: &Name{}, Sym: &Sym{Name: "xyz"}},
   137  	}
   138  	want := []*Node{
   139  		{Class: PFUNC, Type: &Type{}, Name: &Name{}, Sym: &Sym{}},
   140  		{Class: PFUNC, Xoffset: 0, Type: &Type{}, Name: &Name{}, Sym: &Sym{}},
   141  		{Class: PFUNC, Xoffset: 10, Type: &Type{}, Name: &Name{}, Sym: &Sym{}},
   142  		{Class: PFUNC, Xoffset: 20, Type: &Type{}, Name: &Name{}, Sym: &Sym{}},
   143  		{Class: PAUTO, Used: true, Type: &Type{}, Name: &Name{}, Sym: &Sym{}},
   144  		{Class: PAUTO, Type: &Type{}, Name: &Name{Needzero: true}, Sym: &Sym{}},
   145  		{Class: PAUTO, Type: &Type{Width: 2}, Name: &Name{}, Sym: &Sym{}},
   146  		{Class: PAUTO, Type: &Type{Width: 1}, Name: &Name{}, Sym: &Sym{}},
   147  		{Class: PAUTO, Type: &Type{}, Name: &Name{}, Sym: &Sym{}},
   148  		{Class: PAUTO, Type: &Type{}, Name: &Name{}, Sym: &Sym{}},
   149  		{Class: PAUTO, Type: &Type{}, Name: &Name{}, Sym: &Sym{Name: "abc"}},
   150  		{Class: PAUTO, Type: &Type{}, Name: &Name{}, Sym: &Sym{Name: "xyz"}},
   151  		{Class: PAUTO, Type: &Type{Haspointers: 1}, Name: &Name{}, Sym: &Sym{}}, // haspointers -> false
   152  	}
   153  	// haspointers updates Type.Haspointers as a side effect, so
   154  	// exercise this function on all inputs so that reflect.DeepEqual
   155  	// doesn't produce false positives.
   156  	for i := range want {
   157  		haspointers(want[i].Type)
   158  		haspointers(inp[i].Type)
   159  	}
   160  
   161  	sort.Sort(byStackVar(inp))
   162  	if !reflect.DeepEqual(want, inp) {
   163  		t.Error("sort failed")
   164  		for i := range inp {
   165  			g := inp[i]
   166  			w := want[i]
   167  			eq := reflect.DeepEqual(w, g)
   168  			if !eq {
   169  				t.Log(i, w, g)
   170  			}
   171  		}
   172  	}
   173  }