go termlist_test 源码

golang termlist_test 代码

文件路径：/src/go/types/termlist_test.go

// Copyright 2021 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 types

import (
	"strings"
	"testing"
)

// maketl makes a term list from a string of the term list.
func maketl(s string) termlist {
	s = strings.ReplaceAll(s, " ", "")
	names := strings.Split(s, "|")
	r := make(termlist, len(names))
	for i, n := range names {
		r[i] = testTerm(n)
	}
	return r
}

func TestTermlistAll(t *testing.T) {
	if !allTermlist.isAll() {
		t.Errorf("allTermlist is not the set of all types")
	}
}

func TestTermlistString(t *testing.T) {
	for _, want := range []string{
		"∅",
		"?",
		"int",
		"~int",
		"myInt",
		"∅ | ∅",
		"? | ?",
		"∅ | ? | int",
		"∅ | ? | int | myInt",
	} {
		if got := maketl(want).String(); got != want {
			t.Errorf("(%v).String() == %v", want, got)
		}
	}
}

func TestTermlistIsEmpty(t *testing.T) {
	for test, want := range map[string]bool{
		"∅":             true,
		"∅ | ∅":         true,
		"∅ | ∅ | ?":     false,
		"∅ | ∅ | myInt": false,
		"?":             false,
		"? | int":       false,
		"? | myInt | ∅": false,
	} {
		xl := maketl(test)
		got := xl.isEmpty()
		if got != want {
			t.Errorf("(%v).isEmpty() == %v; want %v", test, got, want)
		}
	}
}

func TestTermlistIsAll(t *testing.T) {
	for test, want := range map[string]bool{
		"∅":             false,
		"∅ | ∅":         false,
		"int | ~string": false,
		"~int | myInt":  false,
		"∅ | ∅ | ?":     true,
		"?":             true,
		"? | int":       true,
		"myInt | ?":     true,
	} {
		xl := maketl(test)
		got := xl.isAll()
		if got != want {
			t.Errorf("(%v).isAll() == %v; want %v", test, got, want)
		}
	}
}

func TestTermlistNorm(t *testing.T) {
	for _, test := range []struct {
		xl, want string
	}{
		{"∅", "∅"},
		{"∅ | ∅", "∅"},
		{"∅ | int", "int"},
		{"∅ | myInt", "myInt"},
		{"? | int", "?"},
		{"? | myInt", "?"},
		{"int | myInt", "int | myInt"},
		{"~int | int", "~int"},
		{"~int | myInt", "~int"},
		{"int | ~string | int", "int | ~string"},
		{"~int | string | ? | ~string | int", "?"},
		{"~int | string | myInt | ~string | int", "~int | ~string"},
	} {
		xl := maketl(test.xl)
		got := maketl(test.xl).norm()
		if got.String() != test.want {
			t.Errorf("(%v).norm() = %v; want %v", xl, got, test.want)
		}
	}
}

func TestTermlistUnion(t *testing.T) {
	for _, test := range []struct {
		xl, yl, want string
	}{

		{"∅", "∅", "∅"},
		{"∅", "?", "?"},
		{"∅", "int", "int"},
		{"?", "~int", "?"},
		{"int", "~int", "~int"},
		{"int", "string", "int | string"},
		{"int", "myInt", "int | myInt"},
		{"~int", "myInt", "~int"},
		{"int | string", "~string", "int | ~string"},
		{"~int | string", "~string | int", "~int | ~string"},
		{"~int | string | ∅", "~string | int", "~int | ~string"},
		{"~int | myInt | ∅", "~string | int", "~int | ~string"},
		{"~int | string | ?", "~string | int", "?"},
		{"~int | string | myInt", "~string | int", "~int | ~string"},
	} {
		xl := maketl(test.xl)
		yl := maketl(test.yl)
		got := xl.union(yl).String()
		if got != test.want {
			t.Errorf("(%v).union(%v) = %v; want %v", test.xl, test.yl, got, test.want)
		}
	}
}

func TestTermlistIntersect(t *testing.T) {
	for _, test := range []struct {
		xl, yl, want string
	}{

		{"∅", "∅", "∅"},
		{"∅", "?", "∅"},
		{"∅", "int", "∅"},
		{"∅", "myInt", "∅"},
		{"?", "~int", "~int"},
		{"?", "myInt", "myInt"},
		{"int", "~int", "int"},
		{"int", "string", "∅"},
		{"int", "myInt", "∅"},
		{"~int", "myInt", "myInt"},
		{"int | string", "~string", "string"},
		{"~int | string", "~string | int", "int | string"},
		{"~int | string | ∅", "~string | int", "int | string"},
		{"~int | myInt | ∅", "~string | int", "int"},
		{"~int | string | ?", "~string | int", "int | ~string"},
		{"~int | string | myInt", "~string | int", "int | string"},
	} {
		xl := maketl(test.xl)
		yl := maketl(test.yl)
		got := xl.intersect(yl).String()
		if got != test.want {
			t.Errorf("(%v).intersect(%v) = %v; want %v", test.xl, test.yl, got, test.want)
		}
	}
}

func TestTermlistEqual(t *testing.T) {
	for _, test := range []struct {
		xl, yl string
		want   bool
	}{
		{"∅", "∅", true},
		{"∅", "?", false},
		{"?", "?", true},
		{"? | int", "?", true},
		{"? | int", "string | ?", true},
		{"? | myInt", "string | ?", true},
		{"int | ~string", "string | int", false},
		{"~int | string", "string | myInt", false},
		{"int | ~string | ∅", "string | int | ~string", true},
	} {
		xl := maketl(test.xl)
		yl := maketl(test.yl)
		got := xl.equal(yl)
		if got != test.want {
			t.Errorf("(%v).equal(%v) = %v; want %v", test.xl, test.yl, got, test.want)
		}
	}
}

func TestTermlistIncludes(t *testing.T) {
	for _, test := range []struct {
		xl, typ string
		want    bool
	}{
		{"∅", "int", false},
		{"?", "int", true},
		{"~int", "int", true},
		{"int", "string", false},
		{"~int", "string", false},
		{"~int", "myInt", true},
		{"int | string", "string", true},
		{"~int | string", "int", true},
		{"~int | string", "myInt", true},
		{"~int | myInt | ∅", "myInt", true},
		{"myInt | ∅ | ?", "int", true},
	} {
		xl := maketl(test.xl)
		yl := testTerm(test.typ).typ
		got := xl.includes(yl)
		if got != test.want {
			t.Errorf("(%v).includes(%v) = %v; want %v", test.xl, yl, got, test.want)
		}
	}
}

func TestTermlistSupersetOf(t *testing.T) {
	for _, test := range []struct {
		xl, typ string
		want    bool
	}{
		{"∅", "∅", true},
		{"∅", "?", false},
		{"∅", "int", false},
		{"?", "∅", true},
		{"?", "?", true},
		{"?", "int", true},
		{"?", "~int", true},
		{"?", "myInt", true},
		{"~int", "int", true},
		{"~int", "~int", true},
		{"~int", "myInt", true},
		{"int", "~int", false},
		{"myInt", "~int", false},
		{"int", "string", false},
		{"~int", "string", false},
		{"int | string", "string", true},
		{"int | string", "~string", false},
		{"~int | string", "int", true},
		{"~int | string", "myInt", true},
		{"~int | string | ∅", "string", true},
		{"~string | ∅ | ?", "myInt", true},
	} {
		xl := maketl(test.xl)
		y := testTerm(test.typ)
		got := xl.supersetOf(y)
		if got != test.want {
			t.Errorf("(%v).supersetOf(%v) = %v; want %v", test.xl, y, got, test.want)
		}
	}
}

func TestTermlistSubsetOf(t *testing.T) {
	for _, test := range []struct {
		xl, yl string
		want   bool
	}{
		{"∅", "∅", true},
		{"∅", "?", true},
		{"?", "∅", false},
		{"?", "?", true},
		{"int", "int | string", true},
		{"~int", "int | string", false},
		{"~int", "myInt | string", false},
		{"myInt", "~int | string", true},
		{"~int", "string | string | int | ~int", true},
		{"myInt", "string | string | ~int", true},
		{"int | string", "string", false},
		{"int | string", "string | int", true},
		{"int | ~string", "string | int", false},
		{"myInt | ~string", "string | int | ?", true},
		{"int | ~string", "string | int | ∅ | string", false},
		{"int | myInt", "string | ~int | ∅ | string", true},
	} {
		xl := maketl(test.xl)
		yl := maketl(test.yl)
		got := xl.subsetOf(yl)
		if got != test.want {
			t.Errorf("(%v).subsetOf(%v) = %v; want %v", test.xl, test.yl, got, test.want)
		}
	}
}

相关信息

go 源码目录

相关文章

go api 源码

go api_test 源码

go array 源码

go assignments 源码

go basic 源码

go builtins 源码

go builtins_test 源码

go call 源码

go chan 源码

go check 源码