2018-07-02 17:48:55 +00:00
|
|
|
package printer_test
|
|
|
|
|
|
|
|
import (
|
|
|
|
"bytes"
|
|
|
|
"testing"
|
|
|
|
|
2020-05-17 19:56:32 +00:00
|
|
|
"github.com/z7zmey/php-parser/pkg/ast"
|
|
|
|
"github.com/z7zmey/php-parser/pkg/printer"
|
2018-07-02 17:48:55 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
func TestPrintFile(t *testing.T) {
|
2020-07-10 07:50:09 +00:00
|
|
|
expected := `<?php
|
|
|
|
namespace Foo;
|
|
|
|
abstract class Bar extends Baz
|
|
|
|
{
|
|
|
|
public function greet()
|
|
|
|
{
|
|
|
|
echo 'Hello world';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`
|
2020-07-29 20:23:44 +00:00
|
|
|
rootNode := &ast.Root{
|
2020-05-17 19:56:32 +00:00
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtNamespace{
|
2020-08-24 11:20:20 +00:00
|
|
|
Name: &ast.NameName{
|
2020-05-17 19:56:32 +00:00
|
|
|
Parts: []ast.Vertex{
|
|
|
|
&ast.NameNamePart{Value: []byte("Foo")},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
&ast.StmtClass{
|
|
|
|
Modifiers: []ast.Vertex{&ast.Identifier{Value: []byte("abstract")}},
|
|
|
|
ClassName: &ast.NameName{
|
|
|
|
Parts: []ast.Vertex{
|
|
|
|
&ast.NameNamePart{Value: []byte("Bar")},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
Extends: &ast.StmtClassExtends{
|
|
|
|
ClassName: &ast.NameName{
|
|
|
|
Parts: []ast.Vertex{
|
|
|
|
&ast.NameNamePart{Value: []byte("Baz")},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtClassMethod{
|
|
|
|
Modifiers: []ast.Vertex{&ast.Identifier{Value: []byte("public")}},
|
|
|
|
MethodName: &ast.Identifier{Value: []byte("greet")},
|
|
|
|
Stmt: &ast.StmtStmtList{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtEcho{
|
|
|
|
Exprs: []ast.Vertex{
|
|
|
|
&ast.ScalarString{Value: []byte("'Hello world'")},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
2020-07-10 07:50:09 +00:00
|
|
|
}
|
2018-07-02 17:48:55 +00:00
|
|
|
|
2020-07-10 07:50:09 +00:00
|
|
|
o1 := bytes.NewBufferString("")
|
|
|
|
p1 := printer.NewPrettyPrinter(o1, "\t")
|
|
|
|
p1.Print(rootNode)
|
|
|
|
if actual := o1.String(); expected != actual {
|
|
|
|
t.Errorf("\nPrint the 1st time\nexpected: %s\ngot: %s\n", expected, actual)
|
2018-07-02 17:48:55 +00:00
|
|
|
}
|
|
|
|
|
2020-07-10 07:50:09 +00:00
|
|
|
o2 := bytes.NewBufferString("")
|
|
|
|
p2 := printer.NewPrettyPrinter(o2, "\t")
|
|
|
|
p2.Print(rootNode)
|
|
|
|
if actual := o2.String(); expected != actual {
|
|
|
|
t.Errorf("\nPrint the 2nd time\nexpected: %s\ngot: %s\n", expected, actual)
|
2018-07-02 17:48:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintFileInlineHtml(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.Root{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtInlineHtml{Value: []byte("<div>HTML</div>")},
|
|
|
|
&ast.StmtExpression{
|
|
|
|
Expr: &ast.ScalarHeredoc{
|
|
|
|
Label: []byte("<<<\"LBL\"\n"),
|
|
|
|
Parts: []ast.Vertex{
|
|
|
|
&ast.ScalarEncapsedStringPart{Value: []byte("hello world\n")},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `<div>HTML</div><?php
|
|
|
|
<<<"LBL"
|
|
|
|
hello world
|
|
|
|
LBL;
|
|
|
|
`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// node
|
|
|
|
|
|
|
|
func TestPrintIdentifier(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.Identifier{Value: []byte("test")})
|
2018-07-02 17:48:55 +00:00
|
|
|
|
|
|
|
if o.String() != `test` {
|
|
|
|
t.Errorf("TestPrintIdentifier is failed\n")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintParameter(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.Parameter{
|
2020-07-05 19:47:46 +00:00
|
|
|
Type: &ast.NameFullyQualified{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
|
|
|
|
Var: &ast.Variadic{
|
|
|
|
Var: &ast.ExprVariable{
|
|
|
|
VarName: &ast.Identifier{
|
|
|
|
Value: []byte("var"),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
DefaultValue: &ast.ScalarString{Value: []byte("'default'")},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := "\\Foo ...$var = 'default'"
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintNullable(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.Nullable{
|
|
|
|
Expr: &ast.Parameter{
|
|
|
|
Type: &ast.NameFullyQualified{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
|
2020-07-05 19:47:46 +00:00
|
|
|
Var: &ast.Variadic{Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}}},
|
2020-05-17 19:56:32 +00:00
|
|
|
DefaultValue: &ast.ScalarString{Value: []byte("'default'")},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := "?\\Foo ...$var = 'default'"
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintArgument(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.Argument{
|
2018-07-02 17:48:55 +00:00
|
|
|
IsReference: false,
|
|
|
|
Variadic: true,
|
2020-05-17 19:56:32 +00:00
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := "...$var"
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
func TestPrintArgumentByRef(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.Argument{
|
2018-07-02 17:48:55 +00:00
|
|
|
IsReference: true,
|
|
|
|
Variadic: false,
|
2020-05-17 19:56:32 +00:00
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := "&$var"
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// name
|
|
|
|
|
|
|
|
func TestPrintNameNamePart(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.NameNamePart{
|
|
|
|
Value: []byte("foo"),
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := "foo"
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintNameName(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.NameName{
|
|
|
|
Parts: []ast.Vertex{
|
|
|
|
&ast.NameNamePart{
|
|
|
|
Value: []byte("Foo"),
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
&ast.NameNamePart{
|
|
|
|
Value: []byte("Bar"),
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := "Foo\\Bar"
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintNameFullyQualified(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.NameFullyQualified{
|
|
|
|
Parts: []ast.Vertex{
|
|
|
|
&ast.NameNamePart{
|
|
|
|
Value: []byte("Foo"),
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
&ast.NameNamePart{
|
|
|
|
Value: []byte("Bar"),
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := "\\Foo\\Bar"
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintNameRelative(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.NameRelative{
|
|
|
|
Parts: []ast.Vertex{
|
|
|
|
&ast.NameNamePart{
|
|
|
|
Value: []byte("Foo"),
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
&ast.NameNamePart{
|
|
|
|
Value: []byte("Bar"),
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := "namespace\\Foo\\Bar"
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// scalar
|
|
|
|
|
|
|
|
func TestPrintScalarLNumber(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ScalarLnumber{Value: []byte("1")})
|
2018-07-02 17:48:55 +00:00
|
|
|
|
|
|
|
if o.String() != `1` {
|
|
|
|
t.Errorf("TestPrintScalarLNumber is failed\n")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintScalarDNumber(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ScalarDnumber{Value: []byte(".1")})
|
2018-07-02 17:48:55 +00:00
|
|
|
|
|
|
|
if o.String() != `.1` {
|
|
|
|
t.Errorf("TestPrintScalarDNumber is failed\n")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintScalarString(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ScalarString{Value: []byte("'hello world'")})
|
2018-07-02 17:48:55 +00:00
|
|
|
|
|
|
|
expected := `'hello world'`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintScalarEncapsedStringPart(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ScalarEncapsedStringPart{Value: []byte("hello world")})
|
2018-07-02 17:48:55 +00:00
|
|
|
|
|
|
|
if o.String() != `hello world` {
|
|
|
|
t.Errorf("TestPrintScalarEncapsedStringPart is failed\n")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintScalarEncapsed(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ScalarEncapsed{
|
|
|
|
Parts: []ast.Vertex{
|
|
|
|
&ast.ScalarEncapsedStringPart{Value: []byte("hello ")},
|
|
|
|
&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
|
|
|
|
&ast.ScalarEncapsedStringPart{Value: []byte(" world")},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
})
|
|
|
|
|
2018-07-09 19:04:18 +00:00
|
|
|
if o.String() != `"hello {$var} world"` {
|
2018-07-02 17:48:55 +00:00
|
|
|
t.Errorf("TestPrintScalarEncapsed is failed\n")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintScalarHeredoc(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ScalarHeredoc{
|
|
|
|
Label: []byte("<<<LBL\n"),
|
|
|
|
Parts: []ast.Vertex{
|
|
|
|
&ast.ScalarEncapsedStringPart{Value: []byte("hello ")},
|
|
|
|
&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
|
|
|
|
&ast.ScalarEncapsedStringPart{Value: []byte(" world\n")},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `<<<LBL
|
2018-07-09 19:04:18 +00:00
|
|
|
hello {$var} world
|
2018-07-02 17:48:55 +00:00
|
|
|
LBL`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintScalarNowdoc(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ScalarHeredoc{
|
|
|
|
Label: []byte("<<<'LBL'\n"),
|
|
|
|
Parts: []ast.Vertex{
|
|
|
|
&ast.ScalarEncapsedStringPart{Value: []byte("hello world\n")},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `<<<'LBL'
|
|
|
|
hello world
|
|
|
|
LBL`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintScalarMagicConstant(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ScalarMagicConstant{Value: []byte("__DIR__")})
|
2018-07-02 17:48:55 +00:00
|
|
|
|
|
|
|
if o.String() != `__DIR__` {
|
|
|
|
t.Errorf("TestPrintScalarMagicConstant is failed\n")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// assign
|
|
|
|
|
|
|
|
func TestPrintAssign(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprAssign{
|
|
|
|
Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a = $b`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintReference(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprAssignReference{
|
|
|
|
Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a =& $b`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintAssignBitwiseAnd(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprAssignBitwiseAnd{
|
|
|
|
Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a &= $b`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintAssignBitwiseOr(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprAssignBitwiseOr{
|
|
|
|
Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a |= $b`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintAssignBitwiseXor(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprAssignBitwiseXor{
|
|
|
|
Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a ^= $b`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintAssignConcat(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprAssignConcat{
|
|
|
|
Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a .= $b`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintAssignDiv(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprAssignDiv{
|
|
|
|
Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a /= $b`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintAssignMinus(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprAssignMinus{
|
|
|
|
Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a -= $b`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintAssignMod(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprAssignMod{
|
|
|
|
Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a %= $b`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintAssignMul(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprAssignMul{
|
|
|
|
Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a *= $b`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintAssignPlus(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprAssignPlus{
|
|
|
|
Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a += $b`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintAssignPow(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprAssignPow{
|
|
|
|
Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a **= $b`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintAssignShiftLeft(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprAssignShiftLeft{
|
|
|
|
Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a <<= $b`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintAssignShiftRight(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprAssignShiftRight{
|
|
|
|
Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a >>= $b`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// binary
|
|
|
|
|
|
|
|
func TestPrintBinaryBitwiseAnd(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprBinaryBitwiseAnd{
|
|
|
|
Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a & $b`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintBinaryBitwiseOr(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprBinaryBitwiseOr{
|
|
|
|
Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a | $b`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintBinaryBitwiseXor(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprBinaryBitwiseXor{
|
|
|
|
Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a ^ $b`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintBinaryBooleanAnd(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprBinaryBooleanAnd{
|
|
|
|
Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a && $b`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintBinaryBooleanOr(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprBinaryBooleanOr{
|
|
|
|
Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a || $b`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintBinaryCoalesce(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprBinaryCoalesce{
|
|
|
|
Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a ?? $b`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintBinaryConcat(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprBinaryConcat{
|
|
|
|
Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a . $b`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintBinaryDiv(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprBinaryDiv{
|
|
|
|
Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a / $b`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintBinaryEqual(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprBinaryEqual{
|
|
|
|
Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a == $b`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintBinaryGreaterOrEqual(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprBinaryGreaterOrEqual{
|
|
|
|
Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a >= $b`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintBinaryGreater(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprBinaryGreater{
|
|
|
|
Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a > $b`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintBinaryIdentical(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprBinaryIdentical{
|
|
|
|
Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a === $b`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintBinaryLogicalAnd(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprBinaryLogicalAnd{
|
|
|
|
Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a and $b`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintBinaryLogicalOr(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprBinaryLogicalOr{
|
|
|
|
Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a or $b`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintBinaryLogicalXor(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprBinaryLogicalXor{
|
|
|
|
Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a xor $b`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintBinaryMinus(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprBinaryMinus{
|
|
|
|
Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a - $b`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintBinaryMod(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprBinaryMod{
|
|
|
|
Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a % $b`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintBinaryMul(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprBinaryMul{
|
|
|
|
Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a * $b`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintBinaryNotEqual(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprBinaryNotEqual{
|
|
|
|
Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a != $b`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintBinaryNotIdentical(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprBinaryNotIdentical{
|
|
|
|
Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a !== $b`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintBinaryPlus(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprBinaryPlus{
|
|
|
|
Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a + $b`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintBinaryPow(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprBinaryPow{
|
|
|
|
Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a ** $b`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintBinaryShiftLeft(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprBinaryShiftLeft{
|
|
|
|
Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a << $b`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintBinaryShiftRight(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprBinaryShiftRight{
|
|
|
|
Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a >> $b`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintBinarySmallerOrEqual(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprBinarySmallerOrEqual{
|
|
|
|
Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a <= $b`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintBinarySmaller(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprBinarySmaller{
|
|
|
|
Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a < $b`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintBinarySpaceship(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprBinarySpaceship{
|
|
|
|
Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a <=> $b`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// cast
|
|
|
|
|
|
|
|
func TestPrintArray(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprCastArray{
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `(array)$var`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintBool(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprCastBool{
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `(bool)$var`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintDouble(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprCastDouble{
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `(float)$var`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintInt(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprCastInt{
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `(int)$var`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintObject(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprCastObject{
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `(object)$var`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintString(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprCastString{
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `(string)$var`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintUnset(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprCastUnset{
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `(unset)$var`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// expr
|
|
|
|
|
|
|
|
func TestPrintExprArrayDimFetch(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprArrayDimFetch{
|
|
|
|
Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
|
|
|
|
Dim: &ast.ScalarLnumber{Value: []byte("1")},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$var[1]`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintExprArrayItemWithKey(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprArrayItem{
|
|
|
|
Key: &ast.ScalarString{Value: []byte("'Hello'")},
|
|
|
|
Val: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("world")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `'Hello' => $world`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintExprArrayItem(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprArrayItem{
|
|
|
|
Val: &ast.ExprReference{Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("world")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `&$world`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintExprArray(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprArray{
|
|
|
|
Items: []ast.Vertex{
|
|
|
|
&ast.ExprArrayItem{
|
|
|
|
Key: &ast.ScalarString{Value: []byte("'Hello'")},
|
|
|
|
Val: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("world")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
&ast.ExprArrayItem{
|
|
|
|
Key: &ast.ScalarLnumber{Value: []byte("2")},
|
|
|
|
Val: &ast.ExprReference{Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
&ast.ExprArrayItem{
|
|
|
|
Val: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `array('Hello' => $world, 2 => &$var, $var)`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintExprBitwiseNot(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprBitwiseNot{
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `~$var`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintExprBooleanNot(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprBooleanNot{
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `!$var`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintExprClassConstFetch(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprClassConstFetch{
|
|
|
|
Class: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
|
|
|
|
ConstantName: &ast.Identifier{Value: []byte("CONST")},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$var::CONST`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintExprClone(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprClone{
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `clone $var`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintExprClosureUse(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprClosureUse{
|
|
|
|
Uses: []ast.Vertex{
|
|
|
|
&ast.ExprReference{Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("foo")}}},
|
|
|
|
&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("bar")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `use (&$foo, $bar)`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintExprClosure(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtNamespace{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.ExprClosure{
|
2018-07-02 17:48:55 +00:00
|
|
|
Static: true,
|
|
|
|
ReturnsRef: true,
|
2020-05-17 19:56:32 +00:00
|
|
|
Params: []ast.Vertex{
|
|
|
|
&ast.Parameter{
|
2020-07-05 19:47:46 +00:00
|
|
|
Var: &ast.Reference{Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
ClosureUse: &ast.ExprClosureUse{
|
|
|
|
Uses: []ast.Vertex{
|
|
|
|
&ast.ExprReference{Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
|
|
|
|
&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
ReturnType: &ast.NameFullyQualified{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `namespace {
|
|
|
|
static function &(&$var) use (&$a, $b): \Foo {
|
|
|
|
$a;
|
|
|
|
}
|
|
|
|
}`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintExprConstFetch(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprConstFetch{
|
|
|
|
Const: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("null")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := "null"
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintEmpty(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprEmpty{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}}})
|
2018-07-02 17:48:55 +00:00
|
|
|
|
|
|
|
expected := `empty($var)`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrettyPrinterrorSuppress(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprErrorSuppress{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}}})
|
2018-07-02 17:48:55 +00:00
|
|
|
|
|
|
|
expected := `@$var`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintEval(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprEval{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}}})
|
2018-07-02 17:48:55 +00:00
|
|
|
|
|
|
|
expected := `eval($var)`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintExit(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprExit{Die: false, Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}}})
|
2018-07-02 17:48:55 +00:00
|
|
|
|
|
|
|
expected := `exit($var)`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-07-09 21:51:02 +00:00
|
|
|
func TestPrintDie(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprExit{Die: true, Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}}})
|
2018-07-09 21:51:02 +00:00
|
|
|
|
|
|
|
expected := `die($var)`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-07-02 17:48:55 +00:00
|
|
|
func TestPrintFunctionCall(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprFunctionCall{
|
|
|
|
Function: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
|
|
|
|
ArgumentList: &ast.ArgumentList{
|
|
|
|
Arguments: []ast.Vertex{
|
|
|
|
&ast.Argument{
|
2018-07-02 17:48:55 +00:00
|
|
|
IsReference: true,
|
2020-05-17 19:56:32 +00:00
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
&ast.Argument{
|
2018-07-02 17:48:55 +00:00
|
|
|
Variadic: true,
|
2020-05-17 19:56:32 +00:00
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
&ast.Argument{
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("c")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$var(&$a, ...$b, $c)`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintInclude(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprInclude{Expr: &ast.ScalarString{Value: []byte("'path'")}})
|
2018-07-02 17:48:55 +00:00
|
|
|
|
|
|
|
expected := `include 'path'`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintIncludeOnce(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprIncludeOnce{Expr: &ast.ScalarString{Value: []byte("'path'")}})
|
2018-07-02 17:48:55 +00:00
|
|
|
|
|
|
|
expected := `include_once 'path'`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintInstanceOf(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprInstanceOf{
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
|
|
|
|
Class: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$var instanceof Foo`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintIsset(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprIsset{
|
|
|
|
Vars: []ast.Vertex{
|
|
|
|
&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `isset($a, $b)`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintList(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprList{
|
|
|
|
Items: []ast.Vertex{
|
|
|
|
&ast.ExprArrayItem{
|
|
|
|
Val: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
&ast.ExprArrayItem{
|
|
|
|
Val: &ast.ExprList{
|
|
|
|
Items: []ast.Vertex{
|
|
|
|
&ast.ExprArrayItem{
|
|
|
|
Val: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
&ast.ExprArrayItem{
|
|
|
|
Val: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("c")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `list($a, list($b, $c))`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintMethodCall(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprMethodCall{
|
|
|
|
Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("foo")}},
|
|
|
|
Method: &ast.Identifier{Value: []byte("bar")},
|
|
|
|
ArgumentList: &ast.ArgumentList{
|
|
|
|
Arguments: []ast.Vertex{
|
|
|
|
&ast.Argument{
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
&ast.Argument{
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$foo->bar($a, $b)`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintNew(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprNew{
|
|
|
|
Class: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
|
|
|
|
ArgumentList: &ast.ArgumentList{
|
|
|
|
Arguments: []ast.Vertex{
|
|
|
|
&ast.Argument{
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
&ast.Argument{
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `new Foo($a, $b)`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintPostDec(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprPostDec{
|
|
|
|
Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$var--`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintPostInc(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprPostInc{
|
|
|
|
Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$var++`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintPreDec(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprPreDec{
|
|
|
|
Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `--$var`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintPreInc(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprPreInc{
|
|
|
|
Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `++$var`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintPrint(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprPrint{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}}})
|
2018-07-02 17:48:55 +00:00
|
|
|
|
|
|
|
expected := `print($var)`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintPropertyFetch(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprPropertyFetch{
|
|
|
|
Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("foo")}},
|
|
|
|
Property: &ast.Identifier{Value: []byte("bar")},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$foo->bar`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintExprReference(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprReference{
|
|
|
|
Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("foo")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `&$foo`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintRequire(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprRequire{Expr: &ast.ScalarString{Value: []byte("'path'")}})
|
2018-07-02 17:48:55 +00:00
|
|
|
|
|
|
|
expected := `require 'path'`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintRequireOnce(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprRequireOnce{Expr: &ast.ScalarString{Value: []byte("'path'")}})
|
2018-07-02 17:48:55 +00:00
|
|
|
|
|
|
|
expected := `require_once 'path'`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintShellExec(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprShellExec{
|
|
|
|
Parts: []ast.Vertex{
|
|
|
|
&ast.ScalarEncapsedStringPart{Value: []byte("hello ")},
|
|
|
|
&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("world")}},
|
|
|
|
&ast.ScalarEncapsedStringPart{Value: []byte("!")},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
})
|
|
|
|
|
2018-07-09 19:04:18 +00:00
|
|
|
expected := "`hello {$world}!`"
|
2018-07-02 17:48:55 +00:00
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintExprShortArray(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprShortArray{
|
|
|
|
Items: []ast.Vertex{
|
|
|
|
&ast.ExprArrayItem{
|
|
|
|
Key: &ast.ScalarString{Value: []byte("'Hello'")},
|
|
|
|
Val: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("world")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
&ast.ExprArrayItem{
|
|
|
|
Key: &ast.ScalarLnumber{Value: []byte("2")},
|
|
|
|
Val: &ast.ExprReference{Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
&ast.ExprArrayItem{
|
|
|
|
Val: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `['Hello' => $world, 2 => &$var, $var]`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintShortList(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprShortList{
|
|
|
|
Items: []ast.Vertex{
|
|
|
|
&ast.ExprArrayItem{
|
|
|
|
Val: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
&ast.ExprArrayItem{
|
|
|
|
Val: &ast.ExprList{
|
|
|
|
Items: []ast.Vertex{
|
|
|
|
&ast.ExprArrayItem{
|
|
|
|
Val: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
&ast.ExprArrayItem{
|
|
|
|
Val: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("c")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `[$a, list($b, $c)]`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStaticCall(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprStaticCall{
|
|
|
|
Class: &ast.Identifier{Value: []byte("Foo")},
|
|
|
|
Call: &ast.Identifier{Value: []byte("bar")},
|
|
|
|
ArgumentList: &ast.ArgumentList{
|
|
|
|
Arguments: []ast.Vertex{
|
|
|
|
&ast.Argument{
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
&ast.Argument{
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `Foo::bar($a, $b)`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStaticPropertyFetch(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprStaticPropertyFetch{
|
|
|
|
Class: &ast.Identifier{Value: []byte("Foo")},
|
|
|
|
Property: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("bar")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `Foo::$bar`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintTernary(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprTernary{
|
|
|
|
Condition: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
IfFalse: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a ?: $b`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintTernaryFull(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprTernary{
|
|
|
|
Condition: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
IfTrue: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
|
|
|
IfFalse: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("c")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a ? $b : $c`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintUnaryMinus(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprUnaryMinus{
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `-$var`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintUnaryPlus(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprUnaryPlus{
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `+$var`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintVariable(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprVariable{VarName: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}}})
|
2018-07-02 17:48:55 +00:00
|
|
|
|
|
|
|
expected := `$$var`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintYieldFrom(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprYieldFrom{
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `yield from $var`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintYield(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprYield{
|
|
|
|
Value: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `yield $var`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintYieldFull(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.ExprYield{
|
|
|
|
Key: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("k")}},
|
|
|
|
Value: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `yield $k => $var`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// stmt
|
|
|
|
|
|
|
|
func TestPrintAltElseIf(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtAltElseIf{
|
|
|
|
Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Stmt: &ast.StmtStmtList{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `elseif ($a) :
|
|
|
|
$b;`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintAltElseIfEmpty(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtAltElseIf{
|
|
|
|
Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Stmt: &ast.StmtStmtList{},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `elseif ($a) :`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintAltElse(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtAltElse{
|
|
|
|
Stmt: &ast.StmtStmtList{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `else :
|
|
|
|
$b;`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintAltElseEmpty(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtAltElse{
|
|
|
|
Stmt: &ast.StmtStmtList{},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `else :`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintAltFor(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtNamespace{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtAltFor{
|
|
|
|
Init: []ast.Vertex{
|
|
|
|
&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
Cond: []ast.Vertex{
|
|
|
|
&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
Loop: []ast.Vertex{
|
|
|
|
&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("c")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
Stmt: &ast.StmtStmtList{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("d")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `namespace {
|
|
|
|
for ($a; $b; $c) :
|
|
|
|
$d;
|
|
|
|
endfor;
|
|
|
|
}`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintAltForeach(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtNamespace{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtAltForeach{
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
|
|
|
|
Key: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("key")}},
|
|
|
|
Var: &ast.ExprReference{Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("val")}}},
|
|
|
|
Stmt: &ast.StmtStmtList{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("d")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `namespace {
|
|
|
|
foreach ($var as $key => &$val) :
|
|
|
|
$d;
|
|
|
|
endforeach;
|
|
|
|
}`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintAltIf(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtNamespace{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtAltIf{
|
|
|
|
Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Stmt: &ast.StmtStmtList{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("d")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
ElseIf: []ast.Vertex{
|
|
|
|
&ast.StmtAltElseIf{
|
|
|
|
Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
|
|
|
Stmt: &ast.StmtStmtList{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
&ast.StmtAltElseIf{
|
|
|
|
Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("c")}},
|
|
|
|
Stmt: &ast.StmtStmtList{},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
Else: &ast.StmtAltElse{
|
|
|
|
Stmt: &ast.StmtStmtList{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `namespace {
|
|
|
|
if ($a) :
|
|
|
|
$d;
|
|
|
|
elseif ($b) :
|
|
|
|
$b;
|
|
|
|
elseif ($c) :
|
|
|
|
else :
|
|
|
|
$b;
|
|
|
|
endif;
|
|
|
|
}`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtAltSwitch(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtNamespace{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtAltSwitch{
|
|
|
|
Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
|
|
|
|
CaseList: &ast.StmtCaseList{
|
|
|
|
Cases: []ast.Vertex{
|
|
|
|
&ast.StmtCase{
|
|
|
|
Cond: &ast.ScalarString{Value: []byte("'a'")},
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
&ast.StmtCase{
|
|
|
|
Cond: &ast.ScalarString{Value: []byte("'b'")},
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `namespace {
|
|
|
|
switch ($var) :
|
|
|
|
case 'a':
|
|
|
|
$a;
|
|
|
|
case 'b':
|
|
|
|
$b;
|
|
|
|
endswitch;
|
|
|
|
}`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintAltWhile(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtNamespace{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtAltWhile{
|
|
|
|
Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Stmt: &ast.StmtStmtList{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `namespace {
|
|
|
|
while ($a) :
|
|
|
|
$b;
|
|
|
|
endwhile;
|
|
|
|
}`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtBreak(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtBreak{
|
|
|
|
Expr: &ast.ScalarLnumber{Value: []byte("1")},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := "break 1;"
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtCase(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtCase{
|
|
|
|
Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `case $a:
|
|
|
|
$a;`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtCaseEmpty(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtCase{
|
|
|
|
Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Stmts: []ast.Vertex{},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := "case $a:"
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtCatch(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtNamespace{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtCatch{
|
|
|
|
Types: []ast.Vertex{
|
|
|
|
&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Exception")}}},
|
|
|
|
&ast.NameFullyQualified{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("RuntimeException")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("e")}},
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `namespace {
|
|
|
|
catch (Exception | \RuntimeException $e) {
|
|
|
|
$a;
|
|
|
|
}
|
|
|
|
}`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtClassMethod(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtClassMethod{
|
|
|
|
Modifiers: []ast.Vertex{&ast.Identifier{Value: []byte("public")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
ReturnsRef: true,
|
2020-05-17 19:56:32 +00:00
|
|
|
MethodName: &ast.Identifier{Value: []byte("foo")},
|
|
|
|
Params: []ast.Vertex{
|
|
|
|
&ast.Parameter{
|
|
|
|
Type: &ast.Nullable{Expr: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("int")}}}},
|
2020-07-05 19:47:46 +00:00
|
|
|
Var: &ast.Reference{Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
|
2020-05-17 19:56:32 +00:00
|
|
|
DefaultValue: &ast.ExprConstFetch{Const: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("null")}}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
&ast.Parameter{
|
2020-07-05 19:47:46 +00:00
|
|
|
Var: &ast.Variadic{Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
ReturnType: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("void")}}},
|
|
|
|
Stmt: &ast.StmtStmtList{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `public function &foo(?int &$a = null, ...$b): void
|
|
|
|
{
|
|
|
|
$a;
|
|
|
|
}`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
func TestPrintStmtAbstractClassMethod(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtClassMethod{
|
|
|
|
Modifiers: []ast.Vertex{&ast.Identifier{Value: []byte("public")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
ReturnsRef: true,
|
2020-05-17 19:56:32 +00:00
|
|
|
MethodName: &ast.Identifier{Value: []byte("foo")},
|
|
|
|
Params: []ast.Vertex{
|
|
|
|
&ast.Parameter{
|
|
|
|
Type: &ast.Nullable{Expr: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("int")}}}},
|
2020-07-05 19:47:46 +00:00
|
|
|
Var: &ast.Reference{Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
|
2020-05-17 19:56:32 +00:00
|
|
|
DefaultValue: &ast.ExprConstFetch{Const: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("null")}}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
&ast.Parameter{
|
2020-07-05 19:47:46 +00:00
|
|
|
Var: &ast.Variadic{Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
ReturnType: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("void")}}},
|
|
|
|
Stmt: &ast.StmtNop{},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `public function &foo(?int &$a = null, ...$b): void;`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtClass(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtNamespace{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtClass{
|
|
|
|
Modifiers: []ast.Vertex{&ast.Identifier{Value: []byte("abstract")}},
|
|
|
|
ClassName: &ast.Identifier{Value: []byte("Foo")},
|
|
|
|
Extends: &ast.StmtClassExtends{
|
|
|
|
ClassName: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Bar")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
Implements: &ast.StmtClassImplements{
|
|
|
|
InterfaceNames: []ast.Vertex{
|
|
|
|
&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Baz")}}},
|
|
|
|
&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Quuz")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtClassConstList{
|
|
|
|
Modifiers: []ast.Vertex{&ast.Identifier{Value: []byte("public")}},
|
|
|
|
Consts: []ast.Vertex{
|
|
|
|
&ast.StmtConstant{
|
|
|
|
ConstantName: &ast.Identifier{Value: []byte("FOO")},
|
|
|
|
Expr: &ast.ScalarString{Value: []byte("'bar'")},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `namespace {
|
|
|
|
abstract class Foo extends Bar implements Baz, Quuz
|
|
|
|
{
|
|
|
|
public const FOO = 'bar';
|
|
|
|
}
|
|
|
|
}`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtAnonymousClass(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtNamespace{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtClass{
|
|
|
|
Modifiers: []ast.Vertex{&ast.Identifier{Value: []byte("abstract")}},
|
|
|
|
ArgumentList: &ast.ArgumentList{
|
|
|
|
Arguments: []ast.Vertex{
|
|
|
|
&ast.Argument{
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
&ast.Argument{
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
Extends: &ast.StmtClassExtends{
|
|
|
|
ClassName: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Bar")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
Implements: &ast.StmtClassImplements{
|
|
|
|
InterfaceNames: []ast.Vertex{
|
|
|
|
&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Baz")}}},
|
|
|
|
&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Quuz")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtClassConstList{
|
|
|
|
Modifiers: []ast.Vertex{&ast.Identifier{Value: []byte("public")}},
|
|
|
|
Consts: []ast.Vertex{
|
|
|
|
&ast.StmtConstant{
|
|
|
|
ConstantName: &ast.Identifier{Value: []byte("FOO")},
|
|
|
|
Expr: &ast.ScalarString{Value: []byte("'bar'")},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `namespace {
|
|
|
|
abstract class($a, $b) extends Bar implements Baz, Quuz
|
|
|
|
{
|
|
|
|
public const FOO = 'bar';
|
|
|
|
}
|
|
|
|
}`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtClassConstList(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtClassConstList{
|
|
|
|
Modifiers: []ast.Vertex{&ast.Identifier{Value: []byte("public")}},
|
|
|
|
Consts: []ast.Vertex{
|
|
|
|
&ast.StmtConstant{
|
|
|
|
ConstantName: &ast.Identifier{Value: []byte("FOO")},
|
|
|
|
Expr: &ast.ScalarString{Value: []byte("'a'")},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
&ast.StmtConstant{
|
|
|
|
ConstantName: &ast.Identifier{Value: []byte("BAR")},
|
|
|
|
Expr: &ast.ScalarString{Value: []byte("'b'")},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `public const FOO = 'a', BAR = 'b';`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtConstant(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtConstant{
|
|
|
|
ConstantName: &ast.Identifier{Value: []byte("FOO")},
|
|
|
|
Expr: &ast.ScalarString{Value: []byte("'BAR'")},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := "FOO = 'BAR'"
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtContinue(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtContinue{
|
|
|
|
Expr: &ast.ScalarLnumber{Value: []byte("1")},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `continue 1;`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtDeclareStmts(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtStmtList{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtDeclare{
|
|
|
|
Consts: []ast.Vertex{
|
|
|
|
&ast.StmtConstant{
|
|
|
|
ConstantName: &ast.Identifier{Value: []byte("FOO")},
|
|
|
|
Expr: &ast.ScalarString{Value: []byte("'bar'")},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
Stmt: &ast.StmtStmtList{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtNop{},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `{
|
|
|
|
declare(FOO = 'bar') {
|
|
|
|
;
|
|
|
|
}
|
|
|
|
}`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtDeclareExpr(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtStmtList{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtDeclare{
|
|
|
|
Consts: []ast.Vertex{
|
|
|
|
&ast.StmtConstant{
|
|
|
|
ConstantName: &ast.Identifier{Value: []byte("FOO")},
|
|
|
|
Expr: &ast.ScalarString{Value: []byte("'bar'")},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
Stmt: &ast.StmtExpression{Expr: &ast.ScalarString{Value: []byte("'bar'")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `{
|
|
|
|
declare(FOO = 'bar')
|
|
|
|
'bar';
|
|
|
|
}`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtDeclareNop(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtDeclare{
|
|
|
|
Consts: []ast.Vertex{
|
|
|
|
&ast.StmtConstant{
|
|
|
|
ConstantName: &ast.Identifier{Value: []byte("FOO")},
|
|
|
|
Expr: &ast.ScalarString{Value: []byte("'bar'")},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
Stmt: &ast.StmtNop{},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `declare(FOO = 'bar');`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtDefalut(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtDefault{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `default:
|
|
|
|
$a;`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtDefalutEmpty(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtDefault{
|
|
|
|
Stmts: []ast.Vertex{},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `default:`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtDo_Expression(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtNamespace{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtDo{
|
|
|
|
Cond: &ast.ScalarLnumber{Value: []byte("1")},
|
|
|
|
Stmt: &ast.StmtExpression{
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `namespace {
|
|
|
|
do
|
|
|
|
$a;
|
|
|
|
while (1);
|
|
|
|
}`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtDo_StmtList(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtNamespace{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtDo{
|
|
|
|
Cond: &ast.ScalarLnumber{Value: []byte("1")},
|
|
|
|
Stmt: &ast.StmtStmtList{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `namespace {
|
|
|
|
do {
|
|
|
|
$a;
|
|
|
|
} while (1);
|
|
|
|
}`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtEcho(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtEcho{
|
|
|
|
Exprs: []ast.Vertex{
|
|
|
|
&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `echo $a, $b;`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtElseIfStmts(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtElseIf{
|
|
|
|
Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Stmt: &ast.StmtStmtList{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtNop{},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `elseif ($a) {
|
|
|
|
;
|
|
|
|
}`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtElseIfExpr(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtElseIf{
|
|
|
|
Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Stmt: &ast.StmtExpression{Expr: &ast.ScalarString{Value: []byte("'bar'")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `elseif ($a)
|
|
|
|
'bar';`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtElseIfNop(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtElseIf{
|
|
|
|
Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Stmt: &ast.StmtNop{},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `elseif ($a);`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtElseStmts(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtElse{
|
|
|
|
Stmt: &ast.StmtStmtList{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtNop{},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `else {
|
|
|
|
;
|
|
|
|
}`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtElseExpr(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtElse{
|
|
|
|
Stmt: &ast.StmtExpression{Expr: &ast.ScalarString{Value: []byte("'bar'")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `else
|
|
|
|
'bar';`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtElseNop(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtElse{
|
|
|
|
Stmt: &ast.StmtNop{},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `else;`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintExpression(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}})
|
2018-07-02 17:48:55 +00:00
|
|
|
|
|
|
|
expected := `$a;`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtFinally(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtNamespace{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtFinally{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtNop{},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `namespace {
|
|
|
|
finally {
|
|
|
|
;
|
|
|
|
}
|
|
|
|
}`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtForStmts(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtNamespace{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtFor{
|
|
|
|
Init: []ast.Vertex{
|
|
|
|
&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
Cond: []ast.Vertex{
|
|
|
|
&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("c")}},
|
|
|
|
&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("d")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
Loop: []ast.Vertex{
|
|
|
|
&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("e")}},
|
|
|
|
&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("f")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
Stmt: &ast.StmtStmtList{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtNop{},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `namespace {
|
|
|
|
for ($a, $b; $c, $d; $e, $f) {
|
|
|
|
;
|
|
|
|
}
|
|
|
|
}`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtForExpr(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtNamespace{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtFor{
|
|
|
|
Init: []ast.Vertex{
|
|
|
|
&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
Cond: []ast.Vertex{
|
|
|
|
&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
Loop: []ast.Vertex{
|
|
|
|
&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("c")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
Stmt: &ast.StmtExpression{Expr: &ast.ScalarString{Value: []byte("'bar'")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `namespace {
|
|
|
|
for ($a; $b; $c)
|
|
|
|
'bar';
|
|
|
|
}`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtForNop(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtFor{
|
|
|
|
Init: []ast.Vertex{
|
|
|
|
&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
Cond: []ast.Vertex{
|
|
|
|
&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
Loop: []ast.Vertex{
|
|
|
|
&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("c")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
Stmt: &ast.StmtNop{},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `for ($a; $b; $c);`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtForeachStmts(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtNamespace{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtForeach{
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
|
|
|
Stmt: &ast.StmtStmtList{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtNop{},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `namespace {
|
|
|
|
foreach ($a as $b) {
|
|
|
|
;
|
|
|
|
}
|
|
|
|
}`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtForeachExpr(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtNamespace{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtForeach{
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Key: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("k")}},
|
|
|
|
Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("v")}},
|
|
|
|
Stmt: &ast.StmtExpression{Expr: &ast.ScalarString{Value: []byte("'bar'")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `namespace {
|
|
|
|
foreach ($a as $k => $v)
|
|
|
|
'bar';
|
|
|
|
}`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtForeachNop(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtForeach{
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Key: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("k")}},
|
|
|
|
Var: &ast.ExprReference{Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("v")}}},
|
|
|
|
Stmt: &ast.StmtNop{},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `foreach ($a as $k => &$v);`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtFunction(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtNamespace{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtFunction{
|
2018-07-02 17:48:55 +00:00
|
|
|
ReturnsRef: true,
|
2020-05-17 19:56:32 +00:00
|
|
|
FunctionName: &ast.Identifier{Value: []byte("foo")},
|
|
|
|
Params: []ast.Vertex{
|
|
|
|
&ast.Parameter{
|
2020-07-05 19:47:46 +00:00
|
|
|
Var: &ast.Reference{Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
ReturnType: &ast.NameFullyQualified{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtNop{},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `namespace {
|
|
|
|
function &foo(&$var): \Foo {
|
|
|
|
;
|
|
|
|
}
|
|
|
|
}`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtGlobal(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtGlobal{
|
|
|
|
Vars: []ast.Vertex{
|
|
|
|
&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `global $a, $b;`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtGoto(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtGoto{
|
|
|
|
Label: &ast.Identifier{Value: []byte("FOO")},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `goto FOO;`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintHaltCompiler(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtHaltCompiler{})
|
2018-07-02 17:48:55 +00:00
|
|
|
|
|
|
|
expected := `__halt_compiler();`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintIfExpression(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtNamespace{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtIf{
|
|
|
|
Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Stmt: &ast.StmtExpression{
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
ElseIf: []ast.Vertex{
|
|
|
|
&ast.StmtElseIf{
|
|
|
|
Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("c")}},
|
|
|
|
Stmt: &ast.StmtStmtList{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtExpression{
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("d")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
&ast.StmtElseIf{
|
|
|
|
Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("e")}},
|
|
|
|
Stmt: &ast.StmtNop{},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
Else: &ast.StmtElse{
|
|
|
|
Stmt: &ast.StmtExpression{
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("f")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `namespace {
|
|
|
|
if ($a)
|
|
|
|
$b;
|
|
|
|
elseif ($c) {
|
|
|
|
$d;
|
|
|
|
}
|
|
|
|
elseif ($e);
|
|
|
|
else
|
|
|
|
$f;
|
|
|
|
}`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintIfStmtList(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtNamespace{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtIf{
|
|
|
|
Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Stmt: &ast.StmtStmtList{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtExpression{
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `namespace {
|
|
|
|
if ($a) {
|
|
|
|
$b;
|
|
|
|
}
|
|
|
|
}`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintIfNop(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtIf{
|
|
|
|
Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Stmt: &ast.StmtNop{},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `if ($a);`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintInlineHtml(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtInlineHtml{
|
|
|
|
Value: []byte("test"),
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `?>test<?php`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintInterface(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtNamespace{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtInterface{
|
|
|
|
InterfaceName: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
|
|
|
|
Extends: &ast.StmtInterfaceExtends{
|
|
|
|
InterfaceNames: []ast.Vertex{
|
|
|
|
&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Bar")}}},
|
|
|
|
&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Baz")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtClassMethod{
|
|
|
|
Modifiers: []ast.Vertex{&ast.Identifier{Value: []byte("public")}},
|
|
|
|
MethodName: &ast.Identifier{Value: []byte("foo")},
|
|
|
|
Params: []ast.Vertex{},
|
|
|
|
Stmt: &ast.StmtStmtList{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `namespace {
|
|
|
|
interface Foo extends Bar, Baz
|
|
|
|
{
|
|
|
|
public function foo()
|
|
|
|
{
|
|
|
|
$a;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintLabel(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtLabel{
|
|
|
|
LabelName: &ast.Identifier{Value: []byte("FOO")},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `FOO:`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintNamespace(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtNamespace{
|
2020-08-24 11:20:20 +00:00
|
|
|
Name: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `namespace Foo;`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintNamespaceWithStmts(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtStmtList{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtNamespace{
|
2020-08-24 11:20:20 +00:00
|
|
|
Name: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
|
2020-05-17 19:56:32 +00:00
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `{
|
|
|
|
namespace Foo {
|
|
|
|
$a;
|
|
|
|
}
|
|
|
|
}`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintNop(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtNop{})
|
2018-07-02 17:48:55 +00:00
|
|
|
|
|
|
|
expected := `;`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintPropertyList(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtPropertyList{
|
|
|
|
Modifiers: []ast.Vertex{
|
|
|
|
&ast.Identifier{Value: []byte("public")},
|
|
|
|
&ast.Identifier{Value: []byte("static")},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
Properties: []ast.Vertex{
|
|
|
|
&ast.StmtProperty{
|
|
|
|
Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
&ast.StmtProperty{
|
|
|
|
Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `public static $a, $b;`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintProperty(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtProperty{
|
|
|
|
Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Expr: &ast.ScalarLnumber{Value: []byte("1")},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a = 1`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintReturn(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtReturn{
|
|
|
|
Expr: &ast.ScalarLnumber{Value: []byte("1")},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `return 1;`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStaticVar(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtStaticVar{
|
|
|
|
Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Expr: &ast.ScalarLnumber{Value: []byte("1")},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `$a = 1`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStatic(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtStatic{
|
|
|
|
Vars: []ast.Vertex{
|
|
|
|
&ast.StmtStaticVar{
|
|
|
|
Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
&ast.StmtStaticVar{
|
|
|
|
Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `static $a, $b;`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtList(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtStmtList{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
|
|
|
|
&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `{
|
|
|
|
$a;
|
|
|
|
$b;
|
|
|
|
}`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtListNested(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtStmtList{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
|
|
|
|
&ast.StmtStmtList{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}}},
|
|
|
|
&ast.StmtStmtList{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("c")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `{
|
|
|
|
$a;
|
|
|
|
{
|
|
|
|
$b;
|
|
|
|
{
|
|
|
|
$c;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtSwitch(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtStmtList{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtSwitch{
|
|
|
|
Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
|
|
|
|
CaseList: &ast.StmtCaseList{
|
|
|
|
Cases: []ast.Vertex{
|
|
|
|
&ast.StmtCase{
|
|
|
|
Cond: &ast.ScalarString{Value: []byte("'a'")},
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
&ast.StmtCase{
|
|
|
|
Cond: &ast.ScalarString{Value: []byte("'b'")},
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `{
|
|
|
|
switch ($var) {
|
|
|
|
case 'a':
|
|
|
|
$a;
|
|
|
|
case 'b':
|
|
|
|
$b;
|
|
|
|
}
|
|
|
|
}`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtThrow(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtThrow{
|
|
|
|
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `throw $var;`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtTraitMethodRef(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtTraitMethodRef{
|
|
|
|
Trait: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
|
|
|
|
Method: &ast.Identifier{Value: []byte("a")},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `Foo::a`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtTraitUseAlias(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtTraitUseAlias{
|
|
|
|
Ref: &ast.StmtTraitMethodRef{
|
|
|
|
Trait: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
|
|
|
|
Method: &ast.Identifier{Value: []byte("a")},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
Modifier: &ast.Identifier{Value: []byte("public")},
|
|
|
|
Alias: &ast.Identifier{Value: []byte("b")},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `Foo::a as public b;`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtTraitUsePrecedence(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtTraitUsePrecedence{
|
|
|
|
Ref: &ast.StmtTraitMethodRef{
|
|
|
|
Trait: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
|
|
|
|
Method: &ast.Identifier{Value: []byte("a")},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
Insteadof: []ast.Vertex{
|
|
|
|
&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Bar")}}},
|
|
|
|
&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Baz")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `Foo::a insteadof Bar, Baz;`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtTraitUse(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtTraitUse{
|
|
|
|
Traits: []ast.Vertex{
|
|
|
|
&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
|
|
|
|
&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Bar")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `use Foo, Bar;`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtTraitAdaptations(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtNamespace{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtTraitUse{
|
|
|
|
Traits: []ast.Vertex{
|
|
|
|
&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
|
|
|
|
&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Bar")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
TraitAdaptationList: &ast.StmtTraitAdaptationList{
|
|
|
|
Adaptations: []ast.Vertex{
|
|
|
|
&ast.StmtTraitUseAlias{
|
|
|
|
Ref: &ast.StmtTraitMethodRef{
|
|
|
|
Trait: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
|
|
|
|
Method: &ast.Identifier{Value: []byte("a")},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
Alias: &ast.Identifier{Value: []byte("b")},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `namespace {
|
|
|
|
use Foo, Bar {
|
|
|
|
Foo::a as b;
|
|
|
|
}
|
|
|
|
}`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintTrait(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtNamespace{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtTrait{
|
|
|
|
TraitName: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtClassMethod{
|
|
|
|
Modifiers: []ast.Vertex{&ast.Identifier{Value: []byte("public")}},
|
|
|
|
MethodName: &ast.Identifier{Value: []byte("foo")},
|
|
|
|
Params: []ast.Vertex{},
|
|
|
|
Stmt: &ast.StmtStmtList{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `namespace {
|
|
|
|
trait Foo
|
|
|
|
{
|
|
|
|
public function foo()
|
|
|
|
{
|
|
|
|
$a;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtTry(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtNamespace{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtTry{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
Catches: []ast.Vertex{
|
|
|
|
&ast.StmtCatch{
|
|
|
|
Types: []ast.Vertex{
|
|
|
|
&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Exception")}}},
|
|
|
|
&ast.NameFullyQualified{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("RuntimeException")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("e")}},
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
2020-05-17 19:56:32 +00:00
|
|
|
Finally: &ast.StmtFinally{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtNop{},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `namespace {
|
|
|
|
try {
|
|
|
|
$a;
|
|
|
|
}
|
|
|
|
catch (Exception | \RuntimeException $e) {
|
|
|
|
$b;
|
|
|
|
}
|
|
|
|
finally {
|
|
|
|
;
|
|
|
|
}
|
|
|
|
}`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintStmtUset(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtUnset{
|
|
|
|
Vars: []ast.Vertex{
|
|
|
|
&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `unset($a, $b);`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-08-03 19:22:53 +00:00
|
|
|
func TestPrintUse(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
|
|
|
p.Print(&ast.StmtUse{
|
2020-08-22 13:59:26 +00:00
|
|
|
Type: &ast.Identifier{Value: []byte("function")},
|
|
|
|
UseDeclarations: []ast.Vertex{
|
|
|
|
&ast.StmtUseDeclaration{
|
|
|
|
Use: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
|
|
|
|
Alias: &ast.Identifier{Value: []byte("Bar")},
|
|
|
|
},
|
|
|
|
&ast.StmtUseDeclaration{
|
|
|
|
Use: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Baz")}}},
|
|
|
|
},
|
|
|
|
},
|
2020-08-03 19:22:53 +00:00
|
|
|
})
|
|
|
|
|
2020-08-22 13:59:26 +00:00
|
|
|
expected := `use function Foo as Bar, Baz;`
|
2020-08-03 19:22:53 +00:00
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-08-22 13:59:26 +00:00
|
|
|
func TestPrintStmtGroupUse(t *testing.T) {
|
2018-07-02 17:48:55 +00:00
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-08-22 13:59:26 +00:00
|
|
|
p.Print(&ast.StmtGroupUse{
|
|
|
|
Type: &ast.Identifier{Value: []byte("function")},
|
|
|
|
Prefix: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
|
2020-08-03 19:22:53 +00:00
|
|
|
UseDeclarations: []ast.Vertex{
|
|
|
|
&ast.StmtUseDeclaration{
|
2020-05-17 19:56:32 +00:00
|
|
|
Use: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
|
|
|
|
Alias: &ast.Identifier{Value: []byte("Bar")},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
2020-08-03 19:22:53 +00:00
|
|
|
&ast.StmtUseDeclaration{
|
2020-05-17 19:56:32 +00:00
|
|
|
Use: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Baz")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
2020-08-22 13:59:26 +00:00
|
|
|
expected := `use function Foo\{Foo as Bar, Baz}`
|
2018-07-02 17:48:55 +00:00
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-08-03 19:22:53 +00:00
|
|
|
func TestPrintUseDeclaration(t *testing.T) {
|
2018-07-02 17:48:55 +00:00
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-08-03 19:22:53 +00:00
|
|
|
p.Print(&ast.StmtUseDeclaration{
|
2020-08-22 13:59:26 +00:00
|
|
|
Type: &ast.Identifier{Value: []byte("function")},
|
2020-08-03 19:22:53 +00:00
|
|
|
Use: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
|
|
|
|
Alias: &ast.Identifier{Value: []byte("Bar")},
|
|
|
|
})
|
|
|
|
|
2018-07-02 17:48:55 +00:00
|
|
|
expected := `function Foo as Bar`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintWhileStmtList(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtNamespace{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtWhile{
|
|
|
|
Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Stmt: &ast.StmtStmtList{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `namespace {
|
|
|
|
while ($a) {
|
|
|
|
$a;
|
|
|
|
}
|
|
|
|
}`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintWhileExpression(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtNamespace{
|
|
|
|
Stmts: []ast.Vertex{
|
|
|
|
&ast.StmtWhile{
|
|
|
|
Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Stmt: &ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
|
2018-07-02 17:48:55 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
expected := `namespace {
|
|
|
|
while ($a)
|
|
|
|
$a;
|
|
|
|
}`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPrintWhileNop(t *testing.T) {
|
|
|
|
o := bytes.NewBufferString("")
|
|
|
|
|
|
|
|
p := printer.NewPrettyPrinter(o, " ")
|
2020-05-17 19:56:32 +00:00
|
|
|
p.Print(&ast.StmtWhile{
|
|
|
|
Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
|
|
|
|
Stmt: &ast.StmtNop{},
|
2018-07-02 17:48:55 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
expected := `while ($a);`
|
|
|
|
actual := o.String()
|
|
|
|
|
|
|
|
if expected != actual {
|
|
|
|
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
|
|
|
|
}
|
|
|
|
}
|