зеркало из https://github.com/golang/tools.git
481 строка
10 KiB
Go
481 строка
10 KiB
Go
// Copyright 2014 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.
|
|
|
|
// This file contains simple golden tests for various examples.
|
|
// Besides validating the results when the implementation changes,
|
|
// it provides a way to look at the generated code without having
|
|
// to execute the print statements in one's head.
|
|
|
|
package main
|
|
|
|
import (
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
|
|
"golang.org/x/tools/internal/testenv"
|
|
)
|
|
|
|
// Golden represents a test case.
|
|
type Golden struct {
|
|
name string
|
|
trimPrefix string
|
|
lineComment bool
|
|
input string // input; the package clause is provided when running the test.
|
|
output string // expected output.
|
|
}
|
|
|
|
var golden = []Golden{
|
|
{"day", "", false, day_in, day_out},
|
|
{"offset", "", false, offset_in, offset_out},
|
|
{"gap", "", false, gap_in, gap_out},
|
|
{"num", "", false, num_in, num_out},
|
|
{"unum", "", false, unum_in, unum_out},
|
|
{"unumpos", "", false, unumpos_in, unumpos_out},
|
|
{"prime", "", false, prime_in, prime_out},
|
|
{"prefix", "Type", false, prefix_in, prefix_out},
|
|
{"tokens", "", true, tokens_in, tokens_out},
|
|
}
|
|
|
|
// Each example starts with "type XXX [u]int", with a single space separating them.
|
|
|
|
// Simple test: enumeration of type int starting at 0.
|
|
const day_in = `type Day int
|
|
const (
|
|
Monday Day = iota
|
|
Tuesday
|
|
Wednesday
|
|
Thursday
|
|
Friday
|
|
Saturday
|
|
Sunday
|
|
)
|
|
`
|
|
|
|
const day_out = `func _() {
|
|
// An "invalid array index" compiler error signifies that the constant values have changed.
|
|
// Re-run the stringer command to generate them again.
|
|
var x [1]struct{}
|
|
_ = x[Monday-0]
|
|
_ = x[Tuesday-1]
|
|
_ = x[Wednesday-2]
|
|
_ = x[Thursday-3]
|
|
_ = x[Friday-4]
|
|
_ = x[Saturday-5]
|
|
_ = x[Sunday-6]
|
|
}
|
|
|
|
const _Day_name = "MondayTuesdayWednesdayThursdayFridaySaturdaySunday"
|
|
|
|
var _Day_index = [...]uint8{0, 6, 13, 22, 30, 36, 44, 50}
|
|
|
|
func (i Day) String() string {
|
|
if i < 0 || i >= Day(len(_Day_index)-1) {
|
|
return "Day(" + strconv.FormatInt(int64(i), 10) + ")"
|
|
}
|
|
return _Day_name[_Day_index[i]:_Day_index[i+1]]
|
|
}
|
|
`
|
|
|
|
// Enumeration with an offset.
|
|
// Also includes a duplicate.
|
|
const offset_in = `type Number int
|
|
const (
|
|
_ Number = iota
|
|
One
|
|
Two
|
|
Three
|
|
AnotherOne = One // Duplicate; note that AnotherOne doesn't appear below.
|
|
)
|
|
`
|
|
|
|
const offset_out = `func _() {
|
|
// An "invalid array index" compiler error signifies that the constant values have changed.
|
|
// Re-run the stringer command to generate them again.
|
|
var x [1]struct{}
|
|
_ = x[One-1]
|
|
_ = x[Two-2]
|
|
_ = x[Three-3]
|
|
}
|
|
|
|
const _Number_name = "OneTwoThree"
|
|
|
|
var _Number_index = [...]uint8{0, 3, 6, 11}
|
|
|
|
func (i Number) String() string {
|
|
i -= 1
|
|
if i < 0 || i >= Number(len(_Number_index)-1) {
|
|
return "Number(" + strconv.FormatInt(int64(i+1), 10) + ")"
|
|
}
|
|
return _Number_name[_Number_index[i]:_Number_index[i+1]]
|
|
}
|
|
`
|
|
|
|
// Gaps and an offset.
|
|
const gap_in = `type Gap int
|
|
const (
|
|
Two Gap = 2
|
|
Three Gap = 3
|
|
Five Gap = 5
|
|
Six Gap = 6
|
|
Seven Gap = 7
|
|
Eight Gap = 8
|
|
Nine Gap = 9
|
|
Eleven Gap = 11
|
|
)
|
|
`
|
|
|
|
const gap_out = `func _() {
|
|
// An "invalid array index" compiler error signifies that the constant values have changed.
|
|
// Re-run the stringer command to generate them again.
|
|
var x [1]struct{}
|
|
_ = x[Two-2]
|
|
_ = x[Three-3]
|
|
_ = x[Five-5]
|
|
_ = x[Six-6]
|
|
_ = x[Seven-7]
|
|
_ = x[Eight-8]
|
|
_ = x[Nine-9]
|
|
_ = x[Eleven-11]
|
|
}
|
|
|
|
const (
|
|
_Gap_name_0 = "TwoThree"
|
|
_Gap_name_1 = "FiveSixSevenEightNine"
|
|
_Gap_name_2 = "Eleven"
|
|
)
|
|
|
|
var (
|
|
_Gap_index_0 = [...]uint8{0, 3, 8}
|
|
_Gap_index_1 = [...]uint8{0, 4, 7, 12, 17, 21}
|
|
)
|
|
|
|
func (i Gap) String() string {
|
|
switch {
|
|
case 2 <= i && i <= 3:
|
|
i -= 2
|
|
return _Gap_name_0[_Gap_index_0[i]:_Gap_index_0[i+1]]
|
|
case 5 <= i && i <= 9:
|
|
i -= 5
|
|
return _Gap_name_1[_Gap_index_1[i]:_Gap_index_1[i+1]]
|
|
case i == 11:
|
|
return _Gap_name_2
|
|
default:
|
|
return "Gap(" + strconv.FormatInt(int64(i), 10) + ")"
|
|
}
|
|
}
|
|
`
|
|
|
|
// Signed integers spanning zero.
|
|
const num_in = `type Num int
|
|
const (
|
|
m_2 Num = -2 + iota
|
|
m_1
|
|
m0
|
|
m1
|
|
m2
|
|
)
|
|
`
|
|
|
|
const num_out = `func _() {
|
|
// An "invalid array index" compiler error signifies that the constant values have changed.
|
|
// Re-run the stringer command to generate them again.
|
|
var x [1]struct{}
|
|
_ = x[m_2 - -2]
|
|
_ = x[m_1 - -1]
|
|
_ = x[m0-0]
|
|
_ = x[m1-1]
|
|
_ = x[m2-2]
|
|
}
|
|
|
|
const _Num_name = "m_2m_1m0m1m2"
|
|
|
|
var _Num_index = [...]uint8{0, 3, 6, 8, 10, 12}
|
|
|
|
func (i Num) String() string {
|
|
i -= -2
|
|
if i < 0 || i >= Num(len(_Num_index)-1) {
|
|
return "Num(" + strconv.FormatInt(int64(i+-2), 10) + ")"
|
|
}
|
|
return _Num_name[_Num_index[i]:_Num_index[i+1]]
|
|
}
|
|
`
|
|
|
|
// Unsigned integers spanning zero.
|
|
const unum_in = `type Unum uint
|
|
const (
|
|
m_2 Unum = iota + 253
|
|
m_1
|
|
)
|
|
|
|
const (
|
|
m0 Unum = iota
|
|
m1
|
|
m2
|
|
)
|
|
`
|
|
|
|
const unum_out = `func _() {
|
|
// An "invalid array index" compiler error signifies that the constant values have changed.
|
|
// Re-run the stringer command to generate them again.
|
|
var x [1]struct{}
|
|
_ = x[m_2-253]
|
|
_ = x[m_1-254]
|
|
_ = x[m0-0]
|
|
_ = x[m1-1]
|
|
_ = x[m2-2]
|
|
}
|
|
|
|
const (
|
|
_Unum_name_0 = "m0m1m2"
|
|
_Unum_name_1 = "m_2m_1"
|
|
)
|
|
|
|
var (
|
|
_Unum_index_0 = [...]uint8{0, 2, 4, 6}
|
|
_Unum_index_1 = [...]uint8{0, 3, 6}
|
|
)
|
|
|
|
func (i Unum) String() string {
|
|
switch {
|
|
case i <= 2:
|
|
return _Unum_name_0[_Unum_index_0[i]:_Unum_index_0[i+1]]
|
|
case 253 <= i && i <= 254:
|
|
i -= 253
|
|
return _Unum_name_1[_Unum_index_1[i]:_Unum_index_1[i+1]]
|
|
default:
|
|
return "Unum(" + strconv.FormatInt(int64(i), 10) + ")"
|
|
}
|
|
}
|
|
`
|
|
|
|
// Unsigned positive integers.
|
|
const unumpos_in = `type Unumpos uint
|
|
const (
|
|
m253 Unumpos = iota + 253
|
|
m254
|
|
)
|
|
|
|
const (
|
|
m1 Unumpos = iota + 1
|
|
m2
|
|
m3
|
|
)
|
|
`
|
|
|
|
const unumpos_out = `func _() {
|
|
// An "invalid array index" compiler error signifies that the constant values have changed.
|
|
// Re-run the stringer command to generate them again.
|
|
var x [1]struct{}
|
|
_ = x[m253-253]
|
|
_ = x[m254-254]
|
|
_ = x[m1-1]
|
|
_ = x[m2-2]
|
|
_ = x[m3-3]
|
|
}
|
|
|
|
const (
|
|
_Unumpos_name_0 = "m1m2m3"
|
|
_Unumpos_name_1 = "m253m254"
|
|
)
|
|
|
|
var (
|
|
_Unumpos_index_0 = [...]uint8{0, 2, 4, 6}
|
|
_Unumpos_index_1 = [...]uint8{0, 4, 8}
|
|
)
|
|
|
|
func (i Unumpos) String() string {
|
|
switch {
|
|
case 1 <= i && i <= 3:
|
|
i -= 1
|
|
return _Unumpos_name_0[_Unumpos_index_0[i]:_Unumpos_index_0[i+1]]
|
|
case 253 <= i && i <= 254:
|
|
i -= 253
|
|
return _Unumpos_name_1[_Unumpos_index_1[i]:_Unumpos_index_1[i+1]]
|
|
default:
|
|
return "Unumpos(" + strconv.FormatInt(int64(i), 10) + ")"
|
|
}
|
|
}
|
|
`
|
|
|
|
// Enough gaps to trigger a map implementation of the method.
|
|
// Also includes a duplicate to test that it doesn't cause problems
|
|
const prime_in = `type Prime int
|
|
const (
|
|
p2 Prime = 2
|
|
p3 Prime = 3
|
|
p5 Prime = 5
|
|
p7 Prime = 7
|
|
p77 Prime = 7 // Duplicate; note that p77 doesn't appear below.
|
|
p11 Prime = 11
|
|
p13 Prime = 13
|
|
p17 Prime = 17
|
|
p19 Prime = 19
|
|
p23 Prime = 23
|
|
p29 Prime = 29
|
|
p37 Prime = 31
|
|
p41 Prime = 41
|
|
p43 Prime = 43
|
|
)
|
|
`
|
|
|
|
const prime_out = `func _() {
|
|
// An "invalid array index" compiler error signifies that the constant values have changed.
|
|
// Re-run the stringer command to generate them again.
|
|
var x [1]struct{}
|
|
_ = x[p2-2]
|
|
_ = x[p3-3]
|
|
_ = x[p5-5]
|
|
_ = x[p7-7]
|
|
_ = x[p77-7]
|
|
_ = x[p11-11]
|
|
_ = x[p13-13]
|
|
_ = x[p17-17]
|
|
_ = x[p19-19]
|
|
_ = x[p23-23]
|
|
_ = x[p29-29]
|
|
_ = x[p37-31]
|
|
_ = x[p41-41]
|
|
_ = x[p43-43]
|
|
}
|
|
|
|
const _Prime_name = "p2p3p5p7p11p13p17p19p23p29p37p41p43"
|
|
|
|
var _Prime_map = map[Prime]string{
|
|
2: _Prime_name[0:2],
|
|
3: _Prime_name[2:4],
|
|
5: _Prime_name[4:6],
|
|
7: _Prime_name[6:8],
|
|
11: _Prime_name[8:11],
|
|
13: _Prime_name[11:14],
|
|
17: _Prime_name[14:17],
|
|
19: _Prime_name[17:20],
|
|
23: _Prime_name[20:23],
|
|
29: _Prime_name[23:26],
|
|
31: _Prime_name[26:29],
|
|
41: _Prime_name[29:32],
|
|
43: _Prime_name[32:35],
|
|
}
|
|
|
|
func (i Prime) String() string {
|
|
if str, ok := _Prime_map[i]; ok {
|
|
return str
|
|
}
|
|
return "Prime(" + strconv.FormatInt(int64(i), 10) + ")"
|
|
}
|
|
`
|
|
|
|
const prefix_in = `type Type int
|
|
const (
|
|
TypeInt Type = iota
|
|
TypeString
|
|
TypeFloat
|
|
TypeRune
|
|
TypeByte
|
|
TypeStruct
|
|
TypeSlice
|
|
)
|
|
`
|
|
|
|
const prefix_out = `func _() {
|
|
// An "invalid array index" compiler error signifies that the constant values have changed.
|
|
// Re-run the stringer command to generate them again.
|
|
var x [1]struct{}
|
|
_ = x[TypeInt-0]
|
|
_ = x[TypeString-1]
|
|
_ = x[TypeFloat-2]
|
|
_ = x[TypeRune-3]
|
|
_ = x[TypeByte-4]
|
|
_ = x[TypeStruct-5]
|
|
_ = x[TypeSlice-6]
|
|
}
|
|
|
|
const _Type_name = "IntStringFloatRuneByteStructSlice"
|
|
|
|
var _Type_index = [...]uint8{0, 3, 9, 14, 18, 22, 28, 33}
|
|
|
|
func (i Type) String() string {
|
|
if i < 0 || i >= Type(len(_Type_index)-1) {
|
|
return "Type(" + strconv.FormatInt(int64(i), 10) + ")"
|
|
}
|
|
return _Type_name[_Type_index[i]:_Type_index[i+1]]
|
|
}
|
|
`
|
|
|
|
const tokens_in = `type Token int
|
|
const (
|
|
And Token = iota // &
|
|
Or // |
|
|
Add // +
|
|
Sub // -
|
|
Ident
|
|
Period // .
|
|
|
|
// not to be used
|
|
SingleBefore
|
|
// not to be used
|
|
BeforeAndInline // inline
|
|
InlineGeneral /* inline general */
|
|
)
|
|
`
|
|
|
|
const tokens_out = `func _() {
|
|
// An "invalid array index" compiler error signifies that the constant values have changed.
|
|
// Re-run the stringer command to generate them again.
|
|
var x [1]struct{}
|
|
_ = x[And-0]
|
|
_ = x[Or-1]
|
|
_ = x[Add-2]
|
|
_ = x[Sub-3]
|
|
_ = x[Ident-4]
|
|
_ = x[Period-5]
|
|
_ = x[SingleBefore-6]
|
|
_ = x[BeforeAndInline-7]
|
|
_ = x[InlineGeneral-8]
|
|
}
|
|
|
|
const _Token_name = "&|+-Ident.SingleBeforeinlineinline general"
|
|
|
|
var _Token_index = [...]uint8{0, 1, 2, 3, 4, 9, 10, 22, 28, 42}
|
|
|
|
func (i Token) String() string {
|
|
if i < 0 || i >= Token(len(_Token_index)-1) {
|
|
return "Token(" + strconv.FormatInt(int64(i), 10) + ")"
|
|
}
|
|
return _Token_name[_Token_index[i]:_Token_index[i+1]]
|
|
}
|
|
`
|
|
|
|
func TestGolden(t *testing.T) {
|
|
testenv.NeedsTool(t, "go")
|
|
|
|
dir := t.TempDir()
|
|
for _, test := range golden {
|
|
g := Generator{
|
|
trimPrefix: test.trimPrefix,
|
|
lineComment: test.lineComment,
|
|
}
|
|
input := "package test\n" + test.input
|
|
file := test.name + ".go"
|
|
absFile := filepath.Join(dir, file)
|
|
err := os.WriteFile(absFile, []byte(input), 0644)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
g.parsePackage([]string{absFile}, nil)
|
|
// Extract the name and type of the constant from the first line.
|
|
tokens := strings.SplitN(test.input, " ", 3)
|
|
if len(tokens) != 3 {
|
|
t.Fatalf("%s: need type declaration on first line", test.name)
|
|
}
|
|
g.generate(tokens[1])
|
|
got := string(g.format())
|
|
if got != test.output {
|
|
t.Errorf("%s: got(%d)\n====\n%q====\nexpected(%d)\n====%q", test.name, len(got), got, len(test.output), test.output)
|
|
}
|
|
}
|
|
}
|