示例#1
0
文件: dsl_test.go 项目: sbinet/fubsy
func TestParse_internal_newlines(t *testing.T) {
	// newlines in a function call are invisible to the parser
	tmpdir, cleanup := testutils.Mktemp()
	defer cleanup()

	script := `
main {
  x(
a.b
    )
}
`
	fn := testutils.Mkfile(tmpdir, "newlines.fubsy", script)
	ast, err := Parse(fn)
	assert.Equal(t, 0, len(err))

	expect := &ASTRoot{
		children: []ASTNode{
			&ASTPhase{
				name: "main",
				children: []ASTNode{
					&ASTFunctionCall{
						function: &ASTName{name: "x"},
						args: []ASTExpression{
							&ASTSelection{
								container: &ASTName{name: "a"},
								member:    "b",
							}}}},
			}}}
	assertASTEqual(t, expect, ast)
}
示例#2
0
文件: dsl_test.go 项目: sbinet/fubsy
func TestParse_valid_sequence(t *testing.T) {
	tmpdir, cleanup := testutils.Mktemp()
	defer cleanup()

	// sequence of top-level children
	script := `
main {
"boo"
}
plugin foo {{{
o'malley & friends
}}}
blob {
 "meep"
 }`
	fn := testutils.Mkfile(tmpdir, "valid_2.fubsy", script)
	ast, errs := Parse(fn)
	testutils.NoErrors(t, errs)

	expect := &ASTRoot{children: []ASTNode{
		&ASTPhase{
			name:     "main",
			children: []ASTNode{&ASTString{value: "boo"}}},
		&ASTInline{
			lang: "foo", content: "o'malley & friends"},
		&ASTPhase{
			name:     "blob",
			children: []ASTNode{&ASTString{value: "meep"}}},
	}}
	assertASTEqual(t, expect, ast)
}
示例#3
0
文件: dsl_test.go 项目: sbinet/fubsy
// this one tries to exercise many token types and grammar rules
func TestParse_omnibus_1(t *testing.T) {
	tmpdir, cleanup := testutils.Mktemp()
	defer cleanup()

	script := `
# start with a comment
import foo
import foo.bar.baz

     
# blank lines are OK!
plugin funky {{{
any ol' crap! "bring it on, 
dude" ...
}}}
main {
  a   =("foo") + b
  c=(d.e)  ()
x.y.z
  <
    lib1/*.c
    lib2/**/*.c
  >
}
`
	fn := testutils.Mkfile(tmpdir, "omnibus_1.fubsy", script)
	ast, err := Parse(fn)
	assert.Equal(t, 0, len(err))

	expect :=
		`ASTRoot {
  ASTImport[foo]
  ASTImport[foo.bar.baz]
  ASTInline[funky] {{{
    any ol' crap! "bring it on, 
    dude" ...
  }}}
  ASTPhase[main] {
    ASTAssignment[a]
      ASTAdd
      op1:
        ASTString[foo]
      op2:
        ASTName[b]
    ASTAssignment[c]
      ASTFunctionCall[d.e] (0 args)
    ASTSelection[x.y: z]
    ASTFileFinder[lib1/*.c lib2/**/*.c]
  }
}
`
	var actual_ bytes.Buffer
	ast.Dump(&actual_, "")
	actual := actual_.String()
	if expect != actual {
		t.Errorf("expected AST:\n%s\nbut got:\n%s", expect, actual)
	}
}
示例#4
0
文件: dsl_test.go 项目: sbinet/fubsy
func TestParse_omnibus_2(t *testing.T) {
	tmpdir, cleanup := testutils.Mktemp()
	defer cleanup()

	script := `
main {
  headers = <*.h>

  a + b : <*.c> + headers {
    x = a
    "cc $x"
    f(a, b)
  }
}
`
	fn := testutils.Mkfile(tmpdir, "omnibus_2.fubsy", script)
	ast, err := Parse(fn)
	assert.Equal(t, 0, len(err))

	expect :=
		`ASTRoot {
  ASTPhase[main] {
    ASTAssignment[headers]
      ASTFileFinder[*.h]
    ASTBuildRule {
    targets:
      ASTAdd
      op1:
        ASTName[a]
      op2:
        ASTName[b]
    sources:
      ASTAdd
      op1:
        ASTFileFinder[*.c]
      op2:
        ASTName[headers]
    actions:
      ASTAssignment[x]
        ASTName[a]
      ASTString[cc $x]
      ASTFunctionCall[f] (2 args)
        ASTName[a]
        ASTName[b]
    }
  }
}
`
	var actual_ bytes.Buffer
	ast.Dump(&actual_, "")
	actual := actual_.String()
	if expect != actual {
		t.Errorf("expected AST:\n%s\nbut got:\n%s", expect, actual)
	}
}
示例#5
0
文件: dsl_test.go 项目: sbinet/fubsy
func TestParse_invalid_1(t *testing.T) {
	tmpdir, cleanup := testutils.Mktemp()
	defer cleanup()

	// invalid: no closing rbracket
	script := `
main{
"borf"
`
	fn := testutils.Mkfile(tmpdir, "invalid_1.fubsy", script)
	_, err := Parse(fn)
	expect := fn + ":4: syntax error (near EOF)"
	assertOneError(t, expect, err)
}
示例#6
0
文件: dsl_test.go 项目: sbinet/fubsy
func TestParse_invalid_2(t *testing.T) {
	tmpdir, cleanup := testutils.Mktemp()
	defer cleanup()

	// invalid: bad token
	script := `
main{
 *&! "whizz"
}`
	fn := testutils.Mkfile(tmpdir, "invalid_2.fubsy", script)
	_, err := Parse(fn)
	expect := fn + ":3: syntax error (near *&!)"
	assertOneError(t, expect, err)
	reset()
}
示例#7
0
文件: dsl_test.go 项目: sbinet/fubsy
func TestParse_valid_1(t *testing.T) {
	tmpdir, cleanup := testutils.Mktemp()
	defer cleanup()

	// dead simple: a single top-level element
	script := `
main {
<meep>

}
`
	fn := testutils.Mkfile(tmpdir, "valid_1.fubsy", script)
	expect := &ASTRoot{children: []ASTNode{
		&ASTPhase{name: "main", children: []ASTNode{
			&ASTFileFinder{patterns: []string{"meep"}}}}}}
	ast, err := Parse(fn)
	assert.Equal(t, 0, len(err))
	assertASTEqual(t, expect, ast)
	eofloc := ast.EOF().Location()
	assert.True(t, strings.HasSuffix(eofloc.ErrorPrefix(), "valid_1.fubsy:6: "))
}