211 lines
4.9 KiB
Go
211 lines
4.9 KiB
Go
// Copyright 2021 The Tint Authors.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package parser_test
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"dawn.googlesource.com/dawn/tools/src/cmd/builtin-gen/ast"
|
|
"dawn.googlesource.com/dawn/tools/src/cmd/builtin-gen/parser"
|
|
)
|
|
|
|
func TestParser(t *testing.T) {
|
|
type test struct {
|
|
src string
|
|
expect ast.AST
|
|
}
|
|
|
|
for _, test := range []test{
|
|
{"enum E {}", ast.AST{
|
|
Enums: []ast.EnumDecl{{Name: "E"}},
|
|
}},
|
|
{"enum E { A [[deco]] B C }", ast.AST{
|
|
Enums: []ast.EnumDecl{{
|
|
Name: "E",
|
|
Entries: []ast.EnumEntry{
|
|
{Name: "A"},
|
|
{
|
|
Decorations: ast.Decorations{{Name: "deco"}},
|
|
Name: "B",
|
|
},
|
|
{Name: "C"},
|
|
},
|
|
}},
|
|
}},
|
|
{"type T", ast.AST{
|
|
Types: []ast.TypeDecl{{Name: "T"}},
|
|
}},
|
|
{"type T<A, B, C>", ast.AST{
|
|
Types: []ast.TypeDecl{{
|
|
Name: "T",
|
|
TemplateParams: ast.TemplateParams{
|
|
{Name: "A"},
|
|
{Name: "B"},
|
|
{Name: "C"},
|
|
},
|
|
}},
|
|
}},
|
|
{"[[deco]] type T", ast.AST{
|
|
Types: []ast.TypeDecl{{
|
|
Decorations: ast.Decorations{
|
|
{Name: "deco"},
|
|
},
|
|
Name: "T",
|
|
}},
|
|
}},
|
|
{`[[deco("a", "b")]] type T`, ast.AST{
|
|
Types: []ast.TypeDecl{{
|
|
Decorations: ast.Decorations{
|
|
{Name: "deco", Values: []string{"a", "b"}},
|
|
},
|
|
Name: "T",
|
|
}},
|
|
}},
|
|
{"match M : A", ast.AST{
|
|
Matchers: []ast.MatcherDecl{{
|
|
Name: "M",
|
|
Options: ast.MatcherOptions{
|
|
ast.TemplatedName{Name: "A"},
|
|
},
|
|
}},
|
|
}},
|
|
{"match M : A | B", ast.AST{
|
|
Matchers: []ast.MatcherDecl{{
|
|
Name: "M",
|
|
Options: ast.MatcherOptions{
|
|
ast.TemplatedName{Name: "A"},
|
|
ast.TemplatedName{Name: "B"},
|
|
},
|
|
}},
|
|
}},
|
|
{"fn F()", ast.AST{
|
|
Functions: []ast.FunctionDecl{{
|
|
Name: "F",
|
|
}},
|
|
}},
|
|
{"[[deco]] fn F()", ast.AST{
|
|
Functions: []ast.FunctionDecl{{
|
|
Name: "F",
|
|
Decorations: ast.Decorations{
|
|
{Name: "deco"},
|
|
},
|
|
}},
|
|
}},
|
|
{"fn F(a)", ast.AST{
|
|
Functions: []ast.FunctionDecl{{
|
|
Name: "F",
|
|
Parameters: ast.Parameters{
|
|
{Type: ast.TemplatedName{Name: "a"}},
|
|
},
|
|
}},
|
|
}},
|
|
{"fn F(a: T)", ast.AST{
|
|
Functions: []ast.FunctionDecl{{
|
|
Name: "F",
|
|
Parameters: ast.Parameters{
|
|
{Name: "a", Type: ast.TemplatedName{Name: "T"}},
|
|
},
|
|
}},
|
|
}},
|
|
{"fn F(a, b)", ast.AST{
|
|
Functions: []ast.FunctionDecl{{
|
|
Name: "F",
|
|
Parameters: ast.Parameters{
|
|
{Type: ast.TemplatedName{Name: "a"}},
|
|
{Type: ast.TemplatedName{Name: "b"}},
|
|
},
|
|
}},
|
|
}},
|
|
{"fn F<A : B<C>>()", ast.AST{
|
|
Functions: []ast.FunctionDecl{{
|
|
Name: "F",
|
|
TemplateParams: ast.TemplateParams{
|
|
{
|
|
Name: "A", Type: ast.TemplatedName{
|
|
Name: "B",
|
|
TemplateArgs: ast.TemplatedNames{
|
|
{Name: "C"},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}},
|
|
}},
|
|
{"fn F<T>(a: X, b: Y<T>)", ast.AST{
|
|
Functions: []ast.FunctionDecl{{
|
|
Name: "F",
|
|
TemplateParams: ast.TemplateParams{
|
|
{Name: "T"},
|
|
},
|
|
Parameters: ast.Parameters{
|
|
{Name: "a", Type: ast.TemplatedName{Name: "X"}},
|
|
{Name: "b", Type: ast.TemplatedName{
|
|
Name: "Y",
|
|
TemplateArgs: []ast.TemplatedName{{Name: "T"}},
|
|
}},
|
|
},
|
|
}},
|
|
}},
|
|
{"fn F() -> X", ast.AST{
|
|
Functions: []ast.FunctionDecl{{
|
|
Name: "F",
|
|
ReturnType: &ast.TemplatedName{Name: "X"},
|
|
}},
|
|
}},
|
|
{"fn F() -> X<T>", ast.AST{
|
|
Functions: []ast.FunctionDecl{{
|
|
Name: "F",
|
|
ReturnType: &ast.TemplatedName{
|
|
Name: "X",
|
|
TemplateArgs: []ast.TemplatedName{{Name: "T"}},
|
|
},
|
|
}},
|
|
}},
|
|
} {
|
|
got, err := parser.Parse(test.src, "file.txt")
|
|
if err != nil {
|
|
t.Errorf("While parsing:\n%s\nParse() returned error: %v", test.src, err)
|
|
continue
|
|
}
|
|
|
|
gotStr, expectStr := got.String(), test.expect.String()
|
|
if gotStr != expectStr {
|
|
t.Errorf("While parsing:\n%s\nGot:\n%s\nExpected:\n%s", test.src, gotStr, expectStr)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestErrors(t *testing.T) {
|
|
type test struct {
|
|
src string
|
|
expect string
|
|
}
|
|
|
|
for _, test := range []test{
|
|
{"+", "test.txt:1:1: unexpected '+'"},
|
|
{"123", "test.txt:1:1 unexpected token 'integer'"},
|
|
{"[[123]]", "test.txt:1:3 expected 'ident' for decoration name, got 'integer'"},
|
|
{"[[abc", "expected ']]' for decoration list, but reached end of file"},
|
|
} {
|
|
got, err := parser.Parse(test.src, "test.txt")
|
|
if gotErr := err.Error(); test.expect != gotErr {
|
|
t.Errorf(`Parse() returned error "%+v", expected error "%+v"`, gotErr, test.expect)
|
|
}
|
|
if got != nil {
|
|
t.Errorf("Lex() returned non-nil for error")
|
|
}
|
|
}
|
|
}
|