Fix the dependency issue (#231)
This commit is contained in:
Robbie Zhang
384
vendor/github.com/hashicorp/hcl/json/parser/parser_test.go
generated
vendored
384
vendor/github.com/hashicorp/hcl/json/parser/parser_test.go
generated
vendored
@@ -1,384 +0,0 @@
|
||||
package parser
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"io/ioutil"
|
||||
"path/filepath"
|
||||
"reflect"
|
||||
"runtime"
|
||||
"testing"
|
||||
|
||||
"github.com/hashicorp/hcl/hcl/ast"
|
||||
"github.com/hashicorp/hcl/hcl/token"
|
||||
)
|
||||
|
||||
func TestType(t *testing.T) {
|
||||
var literals = []struct {
|
||||
typ token.Type
|
||||
src string
|
||||
}{
|
||||
{token.STRING, `"foo": "bar"`},
|
||||
{token.NUMBER, `"foo": 123`},
|
||||
{token.FLOAT, `"foo": 123.12`},
|
||||
{token.FLOAT, `"foo": -123.12`},
|
||||
{token.BOOL, `"foo": true`},
|
||||
{token.STRING, `"foo": null`},
|
||||
}
|
||||
|
||||
for _, l := range literals {
|
||||
t.Logf("Testing: %s", l.src)
|
||||
|
||||
p := newParser([]byte(l.src))
|
||||
item, err := p.objectItem()
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
|
||||
lit, ok := item.Val.(*ast.LiteralType)
|
||||
if !ok {
|
||||
t.Errorf("node should be of type LiteralType, got: %T", item.Val)
|
||||
}
|
||||
|
||||
if lit.Token.Type != l.typ {
|
||||
t.Errorf("want: %s, got: %s", l.typ, lit.Token.Type)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestListType(t *testing.T) {
|
||||
var literals = []struct {
|
||||
src string
|
||||
tokens []token.Type
|
||||
}{
|
||||
{
|
||||
`"foo": ["123", 123]`,
|
||||
[]token.Type{token.STRING, token.NUMBER},
|
||||
},
|
||||
{
|
||||
`"foo": [123, "123",]`,
|
||||
[]token.Type{token.NUMBER, token.STRING},
|
||||
},
|
||||
{
|
||||
`"foo": []`,
|
||||
[]token.Type{},
|
||||
},
|
||||
{
|
||||
`"foo": ["123", 123]`,
|
||||
[]token.Type{token.STRING, token.NUMBER},
|
||||
},
|
||||
{
|
||||
`"foo": ["123", {}]`,
|
||||
[]token.Type{token.STRING, token.LBRACE},
|
||||
},
|
||||
}
|
||||
|
||||
for _, l := range literals {
|
||||
t.Logf("Testing: %s", l.src)
|
||||
|
||||
p := newParser([]byte(l.src))
|
||||
item, err := p.objectItem()
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
|
||||
list, ok := item.Val.(*ast.ListType)
|
||||
if !ok {
|
||||
t.Errorf("node should be of type LiteralType, got: %T", item.Val)
|
||||
}
|
||||
|
||||
tokens := []token.Type{}
|
||||
for _, li := range list.List {
|
||||
switch v := li.(type) {
|
||||
case *ast.LiteralType:
|
||||
tokens = append(tokens, v.Token.Type)
|
||||
case *ast.ObjectType:
|
||||
tokens = append(tokens, token.LBRACE)
|
||||
}
|
||||
}
|
||||
|
||||
equals(t, l.tokens, tokens)
|
||||
}
|
||||
}
|
||||
|
||||
func TestObjectType(t *testing.T) {
|
||||
var literals = []struct {
|
||||
src string
|
||||
nodeType []ast.Node
|
||||
itemLen int
|
||||
}{
|
||||
{
|
||||
`"foo": {}`,
|
||||
nil,
|
||||
0,
|
||||
},
|
||||
{
|
||||
`"foo": {
|
||||
"bar": "fatih"
|
||||
}`,
|
||||
[]ast.Node{&ast.LiteralType{}},
|
||||
1,
|
||||
},
|
||||
{
|
||||
`"foo": {
|
||||
"bar": "fatih",
|
||||
"baz": ["arslan"]
|
||||
}`,
|
||||
[]ast.Node{
|
||||
&ast.LiteralType{},
|
||||
&ast.ListType{},
|
||||
},
|
||||
2,
|
||||
},
|
||||
{
|
||||
`"foo": {
|
||||
"bar": {}
|
||||
}`,
|
||||
[]ast.Node{
|
||||
&ast.ObjectType{},
|
||||
},
|
||||
1,
|
||||
},
|
||||
{
|
||||
`"foo": {
|
||||
"bar": {},
|
||||
"foo": true
|
||||
}`,
|
||||
[]ast.Node{
|
||||
&ast.ObjectType{},
|
||||
&ast.LiteralType{},
|
||||
},
|
||||
2,
|
||||
},
|
||||
}
|
||||
|
||||
for _, l := range literals {
|
||||
t.Logf("Testing:\n%s\n", l.src)
|
||||
|
||||
p := newParser([]byte(l.src))
|
||||
// p.enableTrace = true
|
||||
item, err := p.objectItem()
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
|
||||
// we know that the ObjectKey name is foo for all cases, what matters
|
||||
// is the object
|
||||
obj, ok := item.Val.(*ast.ObjectType)
|
||||
if !ok {
|
||||
t.Errorf("node should be of type LiteralType, got: %T", item.Val)
|
||||
}
|
||||
|
||||
// check if the total length of items are correct
|
||||
equals(t, l.itemLen, len(obj.List.Items))
|
||||
|
||||
// check if the types are correct
|
||||
for i, item := range obj.List.Items {
|
||||
equals(t, reflect.TypeOf(l.nodeType[i]), reflect.TypeOf(item.Val))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestFlattenObjects(t *testing.T) {
|
||||
var literals = []struct {
|
||||
src string
|
||||
nodeType []ast.Node
|
||||
itemLen int
|
||||
}{
|
||||
{
|
||||
`{
|
||||
"foo": [
|
||||
{
|
||||
"foo": "svh",
|
||||
"bar": "fatih"
|
||||
}
|
||||
]
|
||||
}`,
|
||||
[]ast.Node{
|
||||
&ast.ObjectType{},
|
||||
&ast.LiteralType{},
|
||||
&ast.LiteralType{},
|
||||
},
|
||||
3,
|
||||
},
|
||||
{
|
||||
`{
|
||||
"variable": {
|
||||
"foo": {}
|
||||
}
|
||||
}`,
|
||||
[]ast.Node{
|
||||
&ast.ObjectType{},
|
||||
},
|
||||
1,
|
||||
},
|
||||
{
|
||||
`{
|
||||
"empty": []
|
||||
}`,
|
||||
[]ast.Node{
|
||||
&ast.ListType{},
|
||||
},
|
||||
1,
|
||||
},
|
||||
{
|
||||
`{
|
||||
"basic": [1, 2, 3]
|
||||
}`,
|
||||
[]ast.Node{
|
||||
&ast.ListType{},
|
||||
},
|
||||
1,
|
||||
},
|
||||
}
|
||||
|
||||
for _, l := range literals {
|
||||
t.Logf("Testing:\n%s\n", l.src)
|
||||
|
||||
f, err := Parse([]byte(l.src))
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
|
||||
// the first object is always an ObjectList so just assert that one
|
||||
// so we can use it as such
|
||||
obj, ok := f.Node.(*ast.ObjectList)
|
||||
if !ok {
|
||||
t.Errorf("node should be *ast.ObjectList, got: %T", f.Node)
|
||||
}
|
||||
|
||||
// check if the types are correct
|
||||
var i int
|
||||
for _, item := range obj.Items {
|
||||
equals(t, reflect.TypeOf(l.nodeType[i]), reflect.TypeOf(item.Val))
|
||||
i++
|
||||
|
||||
if obj, ok := item.Val.(*ast.ObjectType); ok {
|
||||
for _, item := range obj.List.Items {
|
||||
equals(t, reflect.TypeOf(l.nodeType[i]), reflect.TypeOf(item.Val))
|
||||
i++
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// check if the number of items is correct
|
||||
equals(t, l.itemLen, i)
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
func TestObjectKey(t *testing.T) {
|
||||
keys := []struct {
|
||||
exp []token.Type
|
||||
src string
|
||||
}{
|
||||
{[]token.Type{token.STRING}, `"foo": {}`},
|
||||
}
|
||||
|
||||
for _, k := range keys {
|
||||
p := newParser([]byte(k.src))
|
||||
keys, err := p.objectKey()
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
tokens := []token.Type{}
|
||||
for _, o := range keys {
|
||||
tokens = append(tokens, o.Token.Type)
|
||||
}
|
||||
|
||||
equals(t, k.exp, tokens)
|
||||
}
|
||||
|
||||
errKeys := []struct {
|
||||
src string
|
||||
}{
|
||||
{`foo 12 {}`},
|
||||
{`foo bar = {}`},
|
||||
{`foo []`},
|
||||
{`12 {}`},
|
||||
}
|
||||
|
||||
for _, k := range errKeys {
|
||||
p := newParser([]byte(k.src))
|
||||
_, err := p.objectKey()
|
||||
if err == nil {
|
||||
t.Errorf("case '%s' should give an error", k.src)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Official HCL tests
|
||||
func TestParse(t *testing.T) {
|
||||
cases := []struct {
|
||||
Name string
|
||||
Err bool
|
||||
}{
|
||||
{
|
||||
"array.json",
|
||||
false,
|
||||
},
|
||||
{
|
||||
"basic.json",
|
||||
false,
|
||||
},
|
||||
{
|
||||
"object.json",
|
||||
false,
|
||||
},
|
||||
{
|
||||
"types.json",
|
||||
false,
|
||||
},
|
||||
{
|
||||
"bad_input_128.json",
|
||||
true,
|
||||
},
|
||||
{
|
||||
"bad_input_tf_8110.json",
|
||||
true,
|
||||
},
|
||||
{
|
||||
"good_input_tf_8110.json",
|
||||
false,
|
||||
},
|
||||
}
|
||||
|
||||
const fixtureDir = "./test-fixtures"
|
||||
|
||||
for _, tc := range cases {
|
||||
d, err := ioutil.ReadFile(filepath.Join(fixtureDir, tc.Name))
|
||||
if err != nil {
|
||||
t.Fatalf("err: %s", err)
|
||||
}
|
||||
|
||||
_, err = Parse(d)
|
||||
if (err != nil) != tc.Err {
|
||||
t.Fatalf("Input: %s\n\nError: %s", tc.Name, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestParse_inline(t *testing.T) {
|
||||
cases := []struct {
|
||||
Value string
|
||||
Err bool
|
||||
}{
|
||||
{"{:{", true},
|
||||
}
|
||||
|
||||
for _, tc := range cases {
|
||||
_, err := Parse([]byte(tc.Value))
|
||||
if (err != nil) != tc.Err {
|
||||
t.Fatalf("Input: %q\n\nError: %s", tc.Value, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// equals fails the test if exp is not equal to act.
|
||||
func equals(tb testing.TB, exp, act interface{}) {
|
||||
if !reflect.DeepEqual(exp, act) {
|
||||
_, file, line, _ := runtime.Caller(1)
|
||||
fmt.Printf("\033[31m%s:%d:\n\n\texp: %s\n\n\tgot: %s\033[39m\n\n", filepath.Base(file), line, exp, act)
|
||||
tb.FailNow()
|
||||
}
|
||||
}
|
||||
4
vendor/github.com/hashicorp/hcl/json/parser/test-fixtures/array.json
generated
vendored
4
vendor/github.com/hashicorp/hcl/json/parser/test-fixtures/array.json
generated
vendored
@@ -1,4 +0,0 @@
|
||||
{
|
||||
"foo": [1, 2, "bar"],
|
||||
"bar": "baz"
|
||||
}
|
||||
1
vendor/github.com/hashicorp/hcl/json/parser/test-fixtures/bad_input_128.json
generated
vendored
1
vendor/github.com/hashicorp/hcl/json/parser/test-fixtures/bad_input_128.json
generated
vendored
@@ -1 +0,0 @@
|
||||
{:{
|
||||
7
vendor/github.com/hashicorp/hcl/json/parser/test-fixtures/bad_input_tf_8110.json
generated
vendored
7
vendor/github.com/hashicorp/hcl/json/parser/test-fixtures/bad_input_tf_8110.json
generated
vendored
@@ -1,7 +0,0 @@
|
||||
{
|
||||
"variable": {
|
||||
"poc": {
|
||||
"default": "${replace("europe-west", "-", " ")}"
|
||||
}
|
||||
}
|
||||
}
|
||||
3
vendor/github.com/hashicorp/hcl/json/parser/test-fixtures/basic.json
generated
vendored
3
vendor/github.com/hashicorp/hcl/json/parser/test-fixtures/basic.json
generated
vendored
@@ -1,3 +0,0 @@
|
||||
{
|
||||
"foo": "bar"
|
||||
}
|
||||
7
vendor/github.com/hashicorp/hcl/json/parser/test-fixtures/good_input_tf_8110.json
generated
vendored
7
vendor/github.com/hashicorp/hcl/json/parser/test-fixtures/good_input_tf_8110.json
generated
vendored
@@ -1,7 +0,0 @@
|
||||
{
|
||||
"variable": {
|
||||
"poc": {
|
||||
"default": "${replace(\"europe-west\", \"-\", \" \")}"
|
||||
}
|
||||
}
|
||||
}
|
||||
5
vendor/github.com/hashicorp/hcl/json/parser/test-fixtures/object.json
generated
vendored
5
vendor/github.com/hashicorp/hcl/json/parser/test-fixtures/object.json
generated
vendored
@@ -1,5 +0,0 @@
|
||||
{
|
||||
"foo": {
|
||||
"bar": [1,2]
|
||||
}
|
||||
}
|
||||
10
vendor/github.com/hashicorp/hcl/json/parser/test-fixtures/types.json
generated
vendored
10
vendor/github.com/hashicorp/hcl/json/parser/test-fixtures/types.json
generated
vendored
@@ -1,10 +0,0 @@
|
||||
{
|
||||
"foo": "bar",
|
||||
"bar": 7,
|
||||
"baz": [1,2,3],
|
||||
"foo": -12,
|
||||
"bar": 3.14159,
|
||||
"foo": true,
|
||||
"bar": false,
|
||||
"foo": null
|
||||
}
|
||||
362
vendor/github.com/hashicorp/hcl/json/scanner/scanner_test.go
generated
vendored
362
vendor/github.com/hashicorp/hcl/json/scanner/scanner_test.go
generated
vendored
@@ -1,362 +0,0 @@
|
||||
package scanner
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"testing"
|
||||
|
||||
"github.com/hashicorp/hcl/json/token"
|
||||
)
|
||||
|
||||
var f100 = "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
|
||||
|
||||
type tokenPair struct {
|
||||
tok token.Type
|
||||
text string
|
||||
}
|
||||
|
||||
var tokenLists = map[string][]tokenPair{
|
||||
"operator": []tokenPair{
|
||||
{token.LBRACK, "["},
|
||||
{token.LBRACE, "{"},
|
||||
{token.COMMA, ","},
|
||||
{token.PERIOD, "."},
|
||||
{token.RBRACK, "]"},
|
||||
{token.RBRACE, "}"},
|
||||
},
|
||||
"bool": []tokenPair{
|
||||
{token.BOOL, "true"},
|
||||
{token.BOOL, "false"},
|
||||
},
|
||||
"string": []tokenPair{
|
||||
{token.STRING, `" "`},
|
||||
{token.STRING, `"a"`},
|
||||
{token.STRING, `"本"`},
|
||||
{token.STRING, `"${file(\"foo\")}"`},
|
||||
{token.STRING, `"\a"`},
|
||||
{token.STRING, `"\b"`},
|
||||
{token.STRING, `"\f"`},
|
||||
{token.STRING, `"\n"`},
|
||||
{token.STRING, `"\r"`},
|
||||
{token.STRING, `"\t"`},
|
||||
{token.STRING, `"\v"`},
|
||||
{token.STRING, `"\""`},
|
||||
{token.STRING, `"\000"`},
|
||||
{token.STRING, `"\777"`},
|
||||
{token.STRING, `"\x00"`},
|
||||
{token.STRING, `"\xff"`},
|
||||
{token.STRING, `"\u0000"`},
|
||||
{token.STRING, `"\ufA16"`},
|
||||
{token.STRING, `"\U00000000"`},
|
||||
{token.STRING, `"\U0000ffAB"`},
|
||||
{token.STRING, `"` + f100 + `"`},
|
||||
},
|
||||
"number": []tokenPair{
|
||||
{token.NUMBER, "0"},
|
||||
{token.NUMBER, "1"},
|
||||
{token.NUMBER, "9"},
|
||||
{token.NUMBER, "42"},
|
||||
{token.NUMBER, "1234567890"},
|
||||
{token.NUMBER, "-0"},
|
||||
{token.NUMBER, "-1"},
|
||||
{token.NUMBER, "-9"},
|
||||
{token.NUMBER, "-42"},
|
||||
{token.NUMBER, "-1234567890"},
|
||||
},
|
||||
"float": []tokenPair{
|
||||
{token.FLOAT, "0."},
|
||||
{token.FLOAT, "1."},
|
||||
{token.FLOAT, "42."},
|
||||
{token.FLOAT, "01234567890."},
|
||||
{token.FLOAT, ".0"},
|
||||
{token.FLOAT, ".1"},
|
||||
{token.FLOAT, ".42"},
|
||||
{token.FLOAT, ".0123456789"},
|
||||
{token.FLOAT, "0.0"},
|
||||
{token.FLOAT, "1.0"},
|
||||
{token.FLOAT, "42.0"},
|
||||
{token.FLOAT, "01234567890.0"},
|
||||
{token.FLOAT, "0e0"},
|
||||
{token.FLOAT, "1e0"},
|
||||
{token.FLOAT, "42e0"},
|
||||
{token.FLOAT, "01234567890e0"},
|
||||
{token.FLOAT, "0E0"},
|
||||
{token.FLOAT, "1E0"},
|
||||
{token.FLOAT, "42E0"},
|
||||
{token.FLOAT, "01234567890E0"},
|
||||
{token.FLOAT, "0e+10"},
|
||||
{token.FLOAT, "1e-10"},
|
||||
{token.FLOAT, "42e+10"},
|
||||
{token.FLOAT, "01234567890e-10"},
|
||||
{token.FLOAT, "0E+10"},
|
||||
{token.FLOAT, "1E-10"},
|
||||
{token.FLOAT, "42E+10"},
|
||||
{token.FLOAT, "01234567890E-10"},
|
||||
{token.FLOAT, "01.8e0"},
|
||||
{token.FLOAT, "1.4e0"},
|
||||
{token.FLOAT, "42.2e0"},
|
||||
{token.FLOAT, "01234567890.12e0"},
|
||||
{token.FLOAT, "0.E0"},
|
||||
{token.FLOAT, "1.12E0"},
|
||||
{token.FLOAT, "42.123E0"},
|
||||
{token.FLOAT, "01234567890.213E0"},
|
||||
{token.FLOAT, "0.2e+10"},
|
||||
{token.FLOAT, "1.2e-10"},
|
||||
{token.FLOAT, "42.54e+10"},
|
||||
{token.FLOAT, "01234567890.98e-10"},
|
||||
{token.FLOAT, "0.1E+10"},
|
||||
{token.FLOAT, "1.1E-10"},
|
||||
{token.FLOAT, "42.1E+10"},
|
||||
{token.FLOAT, "01234567890.1E-10"},
|
||||
{token.FLOAT, "-0.0"},
|
||||
{token.FLOAT, "-1.0"},
|
||||
{token.FLOAT, "-42.0"},
|
||||
{token.FLOAT, "-01234567890.0"},
|
||||
{token.FLOAT, "-0e0"},
|
||||
{token.FLOAT, "-1e0"},
|
||||
{token.FLOAT, "-42e0"},
|
||||
{token.FLOAT, "-01234567890e0"},
|
||||
{token.FLOAT, "-0E0"},
|
||||
{token.FLOAT, "-1E0"},
|
||||
{token.FLOAT, "-42E0"},
|
||||
{token.FLOAT, "-01234567890E0"},
|
||||
{token.FLOAT, "-0e+10"},
|
||||
{token.FLOAT, "-1e-10"},
|
||||
{token.FLOAT, "-42e+10"},
|
||||
{token.FLOAT, "-01234567890e-10"},
|
||||
{token.FLOAT, "-0E+10"},
|
||||
{token.FLOAT, "-1E-10"},
|
||||
{token.FLOAT, "-42E+10"},
|
||||
{token.FLOAT, "-01234567890E-10"},
|
||||
{token.FLOAT, "-01.8e0"},
|
||||
{token.FLOAT, "-1.4e0"},
|
||||
{token.FLOAT, "-42.2e0"},
|
||||
{token.FLOAT, "-01234567890.12e0"},
|
||||
{token.FLOAT, "-0.E0"},
|
||||
{token.FLOAT, "-1.12E0"},
|
||||
{token.FLOAT, "-42.123E0"},
|
||||
{token.FLOAT, "-01234567890.213E0"},
|
||||
{token.FLOAT, "-0.2e+10"},
|
||||
{token.FLOAT, "-1.2e-10"},
|
||||
{token.FLOAT, "-42.54e+10"},
|
||||
{token.FLOAT, "-01234567890.98e-10"},
|
||||
{token.FLOAT, "-0.1E+10"},
|
||||
{token.FLOAT, "-1.1E-10"},
|
||||
{token.FLOAT, "-42.1E+10"},
|
||||
{token.FLOAT, "-01234567890.1E-10"},
|
||||
},
|
||||
}
|
||||
|
||||
var orderedTokenLists = []string{
|
||||
"comment",
|
||||
"operator",
|
||||
"bool",
|
||||
"string",
|
||||
"number",
|
||||
"float",
|
||||
}
|
||||
|
||||
func TestPosition(t *testing.T) {
|
||||
// create artifical source code
|
||||
buf := new(bytes.Buffer)
|
||||
|
||||
for _, listName := range orderedTokenLists {
|
||||
for _, ident := range tokenLists[listName] {
|
||||
fmt.Fprintf(buf, "\t\t\t\t%s\n", ident.text)
|
||||
}
|
||||
}
|
||||
|
||||
s := New(buf.Bytes())
|
||||
|
||||
pos := token.Pos{"", 4, 1, 5}
|
||||
s.Scan()
|
||||
for _, listName := range orderedTokenLists {
|
||||
|
||||
for _, k := range tokenLists[listName] {
|
||||
curPos := s.tokPos
|
||||
// fmt.Printf("[%q] s = %+v:%+v\n", k.text, curPos.Offset, curPos.Column)
|
||||
|
||||
if curPos.Offset != pos.Offset {
|
||||
t.Fatalf("offset = %d, want %d for %q", curPos.Offset, pos.Offset, k.text)
|
||||
}
|
||||
if curPos.Line != pos.Line {
|
||||
t.Fatalf("line = %d, want %d for %q", curPos.Line, pos.Line, k.text)
|
||||
}
|
||||
if curPos.Column != pos.Column {
|
||||
t.Fatalf("column = %d, want %d for %q", curPos.Column, pos.Column, k.text)
|
||||
}
|
||||
pos.Offset += 4 + len(k.text) + 1 // 4 tabs + token bytes + newline
|
||||
pos.Line += countNewlines(k.text) + 1 // each token is on a new line
|
||||
|
||||
s.Error = func(pos token.Pos, msg string) {
|
||||
t.Errorf("error %q for %q", msg, k.text)
|
||||
}
|
||||
|
||||
s.Scan()
|
||||
}
|
||||
}
|
||||
// make sure there were no token-internal errors reported by scanner
|
||||
if s.ErrorCount != 0 {
|
||||
t.Errorf("%d errors", s.ErrorCount)
|
||||
}
|
||||
}
|
||||
|
||||
func TestComment(t *testing.T) {
|
||||
testTokenList(t, tokenLists["comment"])
|
||||
}
|
||||
|
||||
func TestOperator(t *testing.T) {
|
||||
testTokenList(t, tokenLists["operator"])
|
||||
}
|
||||
|
||||
func TestBool(t *testing.T) {
|
||||
testTokenList(t, tokenLists["bool"])
|
||||
}
|
||||
|
||||
func TestIdent(t *testing.T) {
|
||||
testTokenList(t, tokenLists["ident"])
|
||||
}
|
||||
|
||||
func TestString(t *testing.T) {
|
||||
testTokenList(t, tokenLists["string"])
|
||||
}
|
||||
|
||||
func TestNumber(t *testing.T) {
|
||||
testTokenList(t, tokenLists["number"])
|
||||
}
|
||||
|
||||
func TestFloat(t *testing.T) {
|
||||
testTokenList(t, tokenLists["float"])
|
||||
}
|
||||
|
||||
func TestRealExample(t *testing.T) {
|
||||
complexReal := `
|
||||
{
|
||||
"variable": {
|
||||
"foo": {
|
||||
"default": "bar",
|
||||
"description": "bar",
|
||||
"depends_on": ["something"]
|
||||
}
|
||||
}
|
||||
}`
|
||||
|
||||
literals := []struct {
|
||||
tokenType token.Type
|
||||
literal string
|
||||
}{
|
||||
{token.LBRACE, `{`},
|
||||
{token.STRING, `"variable"`},
|
||||
{token.COLON, `:`},
|
||||
{token.LBRACE, `{`},
|
||||
{token.STRING, `"foo"`},
|
||||
{token.COLON, `:`},
|
||||
{token.LBRACE, `{`},
|
||||
{token.STRING, `"default"`},
|
||||
{token.COLON, `:`},
|
||||
{token.STRING, `"bar"`},
|
||||
{token.COMMA, `,`},
|
||||
{token.STRING, `"description"`},
|
||||
{token.COLON, `:`},
|
||||
{token.STRING, `"bar"`},
|
||||
{token.COMMA, `,`},
|
||||
{token.STRING, `"depends_on"`},
|
||||
{token.COLON, `:`},
|
||||
{token.LBRACK, `[`},
|
||||
{token.STRING, `"something"`},
|
||||
{token.RBRACK, `]`},
|
||||
{token.RBRACE, `}`},
|
||||
{token.RBRACE, `}`},
|
||||
{token.RBRACE, `}`},
|
||||
{token.EOF, ``},
|
||||
}
|
||||
|
||||
s := New([]byte(complexReal))
|
||||
for _, l := range literals {
|
||||
tok := s.Scan()
|
||||
if l.tokenType != tok.Type {
|
||||
t.Errorf("got: %s want %s for %s\n", tok, l.tokenType, tok.String())
|
||||
}
|
||||
|
||||
if l.literal != tok.Text {
|
||||
t.Errorf("got: %s want %s\n", tok, l.literal)
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
func TestError(t *testing.T) {
|
||||
testError(t, "\x80", "1:1", "illegal UTF-8 encoding", token.ILLEGAL)
|
||||
testError(t, "\xff", "1:1", "illegal UTF-8 encoding", token.ILLEGAL)
|
||||
|
||||
testError(t, `"ab`+"\x80", "1:4", "illegal UTF-8 encoding", token.STRING)
|
||||
testError(t, `"abc`+"\xff", "1:5", "illegal UTF-8 encoding", token.STRING)
|
||||
|
||||
testError(t, `01238`, "1:7", "numbers cannot start with 0", token.NUMBER)
|
||||
testError(t, `01238123`, "1:10", "numbers cannot start with 0", token.NUMBER)
|
||||
testError(t, `'aa'`, "1:1", "illegal char: '", token.ILLEGAL)
|
||||
|
||||
testError(t, `"`, "1:2", "literal not terminated", token.STRING)
|
||||
testError(t, `"abc`, "1:5", "literal not terminated", token.STRING)
|
||||
testError(t, `"abc`+"\n", "1:5", "literal not terminated", token.STRING)
|
||||
}
|
||||
|
||||
func testError(t *testing.T, src, pos, msg string, tok token.Type) {
|
||||
s := New([]byte(src))
|
||||
|
||||
errorCalled := false
|
||||
s.Error = func(p token.Pos, m string) {
|
||||
if !errorCalled {
|
||||
if pos != p.String() {
|
||||
t.Errorf("pos = %q, want %q for %q", p, pos, src)
|
||||
}
|
||||
|
||||
if m != msg {
|
||||
t.Errorf("msg = %q, want %q for %q", m, msg, src)
|
||||
}
|
||||
errorCalled = true
|
||||
}
|
||||
}
|
||||
|
||||
tk := s.Scan()
|
||||
if tk.Type != tok {
|
||||
t.Errorf("tok = %s, want %s for %q", tk, tok, src)
|
||||
}
|
||||
if !errorCalled {
|
||||
t.Errorf("error handler not called for %q", src)
|
||||
}
|
||||
if s.ErrorCount == 0 {
|
||||
t.Errorf("count = %d, want > 0 for %q", s.ErrorCount, src)
|
||||
}
|
||||
}
|
||||
|
||||
func testTokenList(t *testing.T, tokenList []tokenPair) {
|
||||
// create artifical source code
|
||||
buf := new(bytes.Buffer)
|
||||
for _, ident := range tokenList {
|
||||
fmt.Fprintf(buf, "%s\n", ident.text)
|
||||
}
|
||||
|
||||
s := New(buf.Bytes())
|
||||
for _, ident := range tokenList {
|
||||
tok := s.Scan()
|
||||
if tok.Type != ident.tok {
|
||||
t.Errorf("tok = %q want %q for %q\n", tok, ident.tok, ident.text)
|
||||
}
|
||||
|
||||
if tok.Text != ident.text {
|
||||
t.Errorf("text = %q want %q", tok.String(), ident.text)
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
func countNewlines(s string) int {
|
||||
n := 0
|
||||
for _, ch := range s {
|
||||
if ch == '\n' {
|
||||
n++
|
||||
}
|
||||
}
|
||||
return n
|
||||
}
|
||||
4
vendor/github.com/hashicorp/hcl/json/test-fixtures/array.json
generated
vendored
4
vendor/github.com/hashicorp/hcl/json/test-fixtures/array.json
generated
vendored
@@ -1,4 +0,0 @@
|
||||
{
|
||||
"foo": [1, 2, "bar"],
|
||||
"bar": "baz"
|
||||
}
|
||||
3
vendor/github.com/hashicorp/hcl/json/test-fixtures/basic.json
generated
vendored
3
vendor/github.com/hashicorp/hcl/json/test-fixtures/basic.json
generated
vendored
@@ -1,3 +0,0 @@
|
||||
{
|
||||
"foo": "bar"
|
||||
}
|
||||
5
vendor/github.com/hashicorp/hcl/json/test-fixtures/object.json
generated
vendored
5
vendor/github.com/hashicorp/hcl/json/test-fixtures/object.json
generated
vendored
@@ -1,5 +0,0 @@
|
||||
{
|
||||
"foo": {
|
||||
"bar": [1,2]
|
||||
}
|
||||
}
|
||||
10
vendor/github.com/hashicorp/hcl/json/test-fixtures/types.json
generated
vendored
10
vendor/github.com/hashicorp/hcl/json/test-fixtures/types.json
generated
vendored
@@ -1,10 +0,0 @@
|
||||
{
|
||||
"foo": "bar",
|
||||
"bar": 7,
|
||||
"baz": [1,2,3],
|
||||
"foo": -12,
|
||||
"bar": 3.14159,
|
||||
"foo": true,
|
||||
"bar": false,
|
||||
"foo": null
|
||||
}
|
||||
34
vendor/github.com/hashicorp/hcl/json/token/token_test.go
generated
vendored
34
vendor/github.com/hashicorp/hcl/json/token/token_test.go
generated
vendored
@@ -1,34 +0,0 @@
|
||||
package token
|
||||
|
||||
import (
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestTypeString(t *testing.T) {
|
||||
var tokens = []struct {
|
||||
tt Type
|
||||
str string
|
||||
}{
|
||||
{ILLEGAL, "ILLEGAL"},
|
||||
{EOF, "EOF"},
|
||||
{NUMBER, "NUMBER"},
|
||||
{FLOAT, "FLOAT"},
|
||||
{BOOL, "BOOL"},
|
||||
{STRING, "STRING"},
|
||||
{NULL, "NULL"},
|
||||
{LBRACK, "LBRACK"},
|
||||
{LBRACE, "LBRACE"},
|
||||
{COMMA, "COMMA"},
|
||||
{PERIOD, "PERIOD"},
|
||||
{RBRACK, "RBRACK"},
|
||||
{RBRACE, "RBRACE"},
|
||||
}
|
||||
|
||||
for _, token := range tokens {
|
||||
if token.tt.String() != token.str {
|
||||
t.Errorf("want: %q got:%q\n", token.str, token.tt)
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user