forked from golang/go
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathexpr_test.go
More file actions
131 lines (122 loc) · 3.33 KB
/
Copy pathexpr_test.go
File metadata and controls
131 lines (122 loc) · 3.33 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
// Copyright 2015 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 asm
import (
"cmd/asm/internal/lex"
"strings"
"testing"
"text/scanner"
)
type exprTest struct {
input string
output int64
atEOF bool
}
var exprTests = []exprTest{
// Simple
{"0", 0, true},
{"3", 3, true},
{"070", 8 * 7, true},
{"0x0f", 15, true},
{"0xFF", 255, true},
{"9223372036854775807", 9223372036854775807, true}, // max int64
// Unary
{"-0", 0, true},
{"~0", -1, true},
{"~0*0", 0, true},
{"+3", 3, true},
{"-3", -3, true},
{"-9223372036854775808", -9223372036854775808, true}, // min int64
// Binary
{"3+4", 3 + 4, true},
{"3-4", 3 - 4, true},
{"2|5", 2 | 5, true},
{"3^4", 3 ^ 4, true},
{"3*4", 3 * 4, true},
{"14/4", 14 / 4, true},
{"3<<4", 3 << 4, true},
{"48>>3", 48 >> 3, true},
{"3&9", 3 & 9, true},
// General
{"3*2+3", 3*2 + 3, true},
{"3+2*3", 3 + 2*3, true},
{"3*(2+3)", 3 * (2 + 3), true},
{"3*-(2+3)", 3 * -(2 + 3), true},
{"3<<2+4", 3<<2 + 4, true},
{"3<<2+4", 3<<2 + 4, true},
{"3<<(2+4)", 3 << (2 + 4), true},
// Junk at EOF.
{"3 x", 3, false},
// Big number
{"4611686018427387904", 4611686018427387904, true},
}
func TestExpr(t *testing.T) {
p := NewParser(nil, nil, nil) // Expression evaluation uses none of these fields of the parser.
for i, test := range exprTests {
p.start(lex.Tokenize(test.input))
result := int64(p.expr())
if result != test.output {
t.Errorf("%d: %q evaluated to %d; expected %d", i, test.input, result, test.output)
}
tok := p.next()
if test.atEOF && tok.ScanToken != scanner.EOF {
t.Errorf("%d: %q: at EOF got %s", i, test.input, tok)
} else if !test.atEOF && tok.ScanToken == scanner.EOF {
t.Errorf("%d: %q: expected not EOF but at EOF", i, test.input)
}
}
}
type badExprTest struct {
input string
error string // Empty means no error.
}
var badExprTests = []badExprTest{
{"0/0", "division by zero"},
{"3/0", "division by zero"},
{"(1<<63)/0", "divide of value with high bit set"},
{"3%0", "modulo by zero"},
{"(1<<63)%0", "modulo of value with high bit set"},
{"3<<-4", "negative left shift count"},
{"3<<(1<<63)", "negative left shift count"},
{"3>>-4", "negative right shift count"},
{"3>>(1<<63)", "negative right shift count"},
{"(1<<63)>>2", "right shift of value with high bit set"},
{"(1<<62)>>2", ""},
{`'\x80'`, "illegal UTF-8 encoding for character constant"},
{"(23*4", "missing closing paren"},
{")23*4", "unexpected ) evaluating expression"},
{"18446744073709551616", "value out of range"},
}
func TestBadExpr(t *testing.T) {
panicOnError = true
defer func() {
panicOnError = false
}()
for i, test := range badExprTests {
err := runBadTest(i, test, t)
if err == nil {
if test.error != "" {
t.Errorf("#%d: %q: expected error %q; got none", i, test.input, test.error)
}
continue
}
if !strings.Contains(err.Error(), test.error) {
t.Errorf("#%d: expected error %q; got %q", i, test.error, err)
continue
}
}
}
func runBadTest(i int, test badExprTest, t *testing.T) (err error) {
p := NewParser(nil, nil, nil) // Expression evaluation uses none of these fields of the parser.
p.start(lex.Tokenize(test.input))
defer func() {
e := recover()
var ok bool
if err, ok = e.(error); e != nil && !ok {
t.Fatal(e)
}
}()
p.expr()
return nil
}