typeterm_test.go

Documentation: go/types

     1  // Code generated by "go test -run=Generate -write=all"; DO NOT EDIT.
     2  // Source: ../../cmd/compile/internal/types2/typeterm_test.go
     3  
     4  // Copyright 2021 The Go Authors. All rights reserved.
     5  // Use of this source code is governed by a BSD-style
     6  // license that can be found in the LICENSE file.
     7  
     8  package types
     9  
    10  import (
    11  	"strings"
    12  	"testing"
    13  )
    14  
    15  var myInt = func() Type {
    16  	tname := NewTypeName(nopos, nil, "myInt", nil)
    17  	return NewNamed(tname, Typ[Int], nil)
    18  }()
    19  
    20  var testTerms = map[string]*term{
    21  	"∅":       nil,
    22  	"𝓤":       {},
    23  	"int":     {false, Typ[Int]},
    24  	"~int":    {true, Typ[Int]},
    25  	"string":  {false, Typ[String]},
    26  	"~string": {true, Typ[String]},
    27  	"myInt":   {false, myInt},
    28  }
    29  
    30  func TestTermString(t *testing.T) {
    31  	for want, x := range testTerms {
    32  		if got := x.String(); got != want {
    33  			t.Errorf("%v.String() == %v; want %v", x, got, want)
    34  		}
    35  	}
    36  }
    37  
    38  func split(s string, n int) []string {
    39  	r := strings.Split(s, " ")
    40  	if len(r) != n {
    41  		panic("invalid test case: " + s)
    42  	}
    43  	return r
    44  }
    45  
    46  func testTerm(name string) *term {
    47  	r, ok := testTerms[name]
    48  	if !ok {
    49  		panic("invalid test argument: " + name)
    50  	}
    51  	return r
    52  }
    53  
    54  func TestTermEqual(t *testing.T) {
    55  	for _, test := range []string{
    56  		"∅ ∅ T",
    57  		"𝓤 𝓤 T",
    58  		"int int T",
    59  		"~int ~int T",
    60  		"myInt myInt T",
    61  		"∅ 𝓤 F",
    62  		"∅ int F",
    63  		"∅ ~int F",
    64  		"𝓤 int F",
    65  		"𝓤 ~int F",
    66  		"𝓤 myInt F",
    67  		"int ~int F",
    68  		"int myInt F",
    69  		"~int myInt F",
    70  	} {
    71  		args := split(test, 3)
    72  		x := testTerm(args[0])
    73  		y := testTerm(args[1])
    74  		want := args[2] == "T"
    75  		if got := x.equal(y); got != want {
    76  			t.Errorf("%v.equal(%v) = %v; want %v", x, y, got, want)
    77  		}
    78  		// equal is symmetric
    79  		x, y = y, x
    80  		if got := x.equal(y); got != want {
    81  			t.Errorf("%v.equal(%v) = %v; want %v", x, y, got, want)
    82  		}
    83  	}
    84  }
    85  
    86  func TestTermUnion(t *testing.T) {
    87  	for _, test := range []string{
    88  		"∅ ∅ ∅ ∅",
    89  		"∅ 𝓤 𝓤 ∅",
    90  		"∅ int int ∅",
    91  		"∅ ~int ~int ∅",
    92  		"∅ myInt myInt ∅",
    93  		"𝓤 𝓤 𝓤 ∅",
    94  		"𝓤 int 𝓤 ∅",
    95  		"𝓤 ~int 𝓤 ∅",
    96  		"𝓤 myInt 𝓤 ∅",
    97  		"int int int ∅",
    98  		"int ~int ~int ∅",
    99  		"int string int string",
   100  		"int ~string int ~string",
   101  		"int myInt int myInt",
   102  		"~int ~string ~int ~string",
   103  		"~int myInt ~int ∅",
   104  
   105  		// union is symmetric, but the result order isn't - repeat symmetric cases explicitly
   106  		"𝓤 ∅ 𝓤 ∅",
   107  		"int ∅ int ∅",
   108  		"~int ∅ ~int ∅",
   109  		"myInt ∅ myInt ∅",
   110  		"int 𝓤 𝓤 ∅",
   111  		"~int 𝓤 𝓤 ∅",
   112  		"myInt 𝓤 𝓤 ∅",
   113  		"~int int ~int ∅",
   114  		"string int string int",
   115  		"~string int ~string int",
   116  		"myInt int myInt int",
   117  		"~string ~int ~string ~int",
   118  		"myInt ~int ~int ∅",
   119  	} {
   120  		args := split(test, 4)
   121  		x := testTerm(args[0])
   122  		y := testTerm(args[1])
   123  		want1 := testTerm(args[2])
   124  		want2 := testTerm(args[3])
   125  		if got1, got2 := x.union(y); !got1.equal(want1) || !got2.equal(want2) {
   126  			t.Errorf("%v.union(%v) = %v, %v; want %v, %v", x, y, got1, got2, want1, want2)
   127  		}
   128  	}
   129  }
   130  
   131  func TestTermIntersection(t *testing.T) {
   132  	for _, test := range []string{
   133  		"∅ ∅ ∅",
   134  		"∅ 𝓤 ∅",
   135  		"∅ int ∅",
   136  		"∅ ~int ∅",
   137  		"∅ myInt ∅",
   138  		"𝓤 𝓤 𝓤",
   139  		"𝓤 int int",
   140  		"𝓤 ~int ~int",
   141  		"𝓤 myInt myInt",
   142  		"int int int",
   143  		"int ~int int",
   144  		"int string ∅",
   145  		"int ~string ∅",
   146  		"int string ∅",
   147  		"~int ~string ∅",
   148  		"~int myInt myInt",
   149  	} {
   150  		args := split(test, 3)
   151  		x := testTerm(args[0])
   152  		y := testTerm(args[1])
   153  		want := testTerm(args[2])
   154  		if got := x.intersect(y); !got.equal(want) {
   155  			t.Errorf("%v.intersect(%v) = %v; want %v", x, y, got, want)
   156  		}
   157  		// intersect is symmetric
   158  		x, y = y, x
   159  		if got := x.intersect(y); !got.equal(want) {
   160  			t.Errorf("%v.intersect(%v) = %v; want %v", x, y, got, want)
   161  		}
   162  	}
   163  }
   164  
   165  func TestTermIncludes(t *testing.T) {
   166  	for _, test := range []string{
   167  		"∅ int F",
   168  		"𝓤 int T",
   169  		"int int T",
   170  		"~int int T",
   171  		"~int myInt T",
   172  		"string int F",
   173  		"~string int F",
   174  		"myInt int F",
   175  	} {
   176  		args := split(test, 3)
   177  		x := testTerm(args[0])
   178  		y := testTerm(args[1]).typ
   179  		want := args[2] == "T"
   180  		if got := x.includes(y); got != want {
   181  			t.Errorf("%v.includes(%v) = %v; want %v", x, y, got, want)
   182  		}
   183  	}
   184  }
   185  
   186  func TestTermSubsetOf(t *testing.T) {
   187  	for _, test := range []string{
   188  		"∅ ∅ T",
   189  		"𝓤 𝓤 T",
   190  		"int int T",
   191  		"~int ~int T",
   192  		"myInt myInt T",
   193  		"∅ 𝓤 T",
   194  		"∅ int T",
   195  		"∅ ~int T",
   196  		"∅ myInt T",
   197  		"𝓤 int F",
   198  		"𝓤 ~int F",
   199  		"𝓤 myInt F",
   200  		"int ~int T",
   201  		"int myInt F",
   202  		"~int myInt F",
   203  		"myInt int F",
   204  		"myInt ~int T",
   205  	} {
   206  		args := split(test, 3)
   207  		x := testTerm(args[0])
   208  		y := testTerm(args[1])
   209  		want := args[2] == "T"
   210  		if got := x.subsetOf(y); got != want {
   211  			t.Errorf("%v.subsetOf(%v) = %v; want %v", x, y, got, want)
   212  		}
   213  	}
   214  }
   215  
   216  func TestTermDisjoint(t *testing.T) {
   217  	for _, test := range []string{
   218  		"int int F",
   219  		"~int ~int F",
   220  		"int ~int F",
   221  		"int string T",
   222  		"int ~string T",
   223  		"int myInt T",
   224  		"~int ~string T",
   225  		"~int myInt F",
   226  		"string myInt T",
   227  		"~string myInt T",
   228  	} {
   229  		args := split(test, 3)
   230  		x := testTerm(args[0])
   231  		y := testTerm(args[1])
   232  		want := args[2] == "T"
   233  		if got := x.disjoint(y); got != want {
   234  			t.Errorf("%v.disjoint(%v) = %v; want %v", x, y, got, want)
   235  		}
   236  		// disjoint is symmetric
   237  		x, y = y, x
   238  		if got := x.disjoint(y); got != want {
   239  			t.Errorf("%v.disjoint(%v) = %v; want %v", x, y, got, want)
   240  		}
   241  	}
   242  }
   243
View as plain text