809 lines
15 KiB
Go
809 lines
15 KiB
Go
package jen_test
|
|
|
|
import (
|
|
"testing"
|
|
|
|
. "github.com/dave/jennifer/jen"
|
|
)
|
|
|
|
var gencases = []tc{
|
|
{
|
|
desc: `bool group`,
|
|
code: BlockFunc(func(g *Group) {
|
|
g.Bool()
|
|
}),
|
|
expect: `{
|
|
bool
|
|
}`,
|
|
},
|
|
{
|
|
desc: `recover func`,
|
|
code: Recover(),
|
|
expect: `recover()`,
|
|
},
|
|
{
|
|
desc: `recover statement`,
|
|
code: Null().Recover(),
|
|
expect: `recover()`,
|
|
},
|
|
{
|
|
desc: `recover group`,
|
|
code: BlockFunc(func(g *Group) {
|
|
g.Recover()
|
|
}),
|
|
expect: `{
|
|
recover()
|
|
}`,
|
|
},
|
|
{
|
|
desc: `real func`,
|
|
code: Real(Id("a")),
|
|
expect: `real(a)`,
|
|
},
|
|
{
|
|
desc: `real statement`,
|
|
code: Null().Real(Id("a")),
|
|
expect: `real(a)`,
|
|
},
|
|
{
|
|
desc: `real group`,
|
|
code: BlockFunc(func(g *Group) {
|
|
g.Real(Id("a"))
|
|
}),
|
|
expect: `{
|
|
real(a)
|
|
}`,
|
|
},
|
|
{
|
|
desc: `printlnfunc func`,
|
|
code: PrintlnFunc(func(g *Group) { g.Id("a") }),
|
|
expect: `println(a)`,
|
|
},
|
|
{
|
|
desc: `printlnfunc statement`,
|
|
code: Null().PrintlnFunc(func(g *Group) { g.Id("a") }),
|
|
expect: `println(a)`,
|
|
},
|
|
{
|
|
desc: `printlnfunc group`,
|
|
code: BlockFunc(func(bg *Group) {
|
|
bg.PrintlnFunc(func(pg *Group) { pg.Id("a") })
|
|
}),
|
|
expect: `{
|
|
println(a)
|
|
}`,
|
|
},
|
|
{
|
|
desc: `println func`,
|
|
code: Println(Id("a")),
|
|
expect: `println(a)`,
|
|
},
|
|
{
|
|
desc: `println statement`,
|
|
code: Null().Println(Id("a")),
|
|
expect: `println(a)`,
|
|
},
|
|
{
|
|
desc: `println group`,
|
|
code: BlockFunc(func(g *Group) {
|
|
g.Println(Id("a"))
|
|
}),
|
|
expect: `{
|
|
println(a)
|
|
}`,
|
|
},
|
|
{
|
|
desc: `printfunc func`,
|
|
code: PrintFunc(func(g *Group) { g.Id("a") }),
|
|
expect: `print(a)`,
|
|
},
|
|
{
|
|
desc: `printfunc statement`,
|
|
code: Null().PrintFunc(func(g *Group) { g.Id("a") }),
|
|
expect: `print(a)`,
|
|
},
|
|
{
|
|
desc: `printfunc group`,
|
|
code: BlockFunc(func(bg *Group) {
|
|
bg.PrintFunc(func(pg *Group) { pg.Id("a") })
|
|
}),
|
|
expect: `{
|
|
print(a)
|
|
}`,
|
|
},
|
|
{
|
|
desc: `print func`,
|
|
code: Print(Id("a")),
|
|
expect: `print(a)`,
|
|
},
|
|
{
|
|
desc: `print statement`,
|
|
code: Null().Print(Id("a")),
|
|
expect: `print(a)`,
|
|
},
|
|
{
|
|
desc: `print group`,
|
|
code: BlockFunc(func(g *Group) {
|
|
g.Print(Id("a"))
|
|
}),
|
|
expect: `{
|
|
print(a)
|
|
}`,
|
|
},
|
|
{
|
|
desc: `panic func`,
|
|
code: Panic(Id("a")),
|
|
expect: `panic(a)`,
|
|
},
|
|
{
|
|
desc: `panic statement`,
|
|
code: Null().Panic(Id("a")),
|
|
expect: `panic(a)`,
|
|
},
|
|
{
|
|
desc: `panic group`,
|
|
code: BlockFunc(func(g *Group) {
|
|
g.Panic(Id("a"))
|
|
}),
|
|
expect: `{
|
|
panic(a)
|
|
}`,
|
|
},
|
|
{
|
|
desc: `new func`,
|
|
code: New(Id("a")),
|
|
expect: `new(a)`,
|
|
},
|
|
{
|
|
desc: `new statement`,
|
|
code: Id("a").Op(":=").New(Id("a")),
|
|
expect: `a := new(a)`,
|
|
},
|
|
{
|
|
desc: `new group`,
|
|
code: BlockFunc(func(g *Group) {
|
|
g.New(Id("a"))
|
|
}),
|
|
expect: `{
|
|
new(a)
|
|
}`,
|
|
},
|
|
{
|
|
desc: `make func`,
|
|
code: Make(Id("a")),
|
|
expect: `make(a)`,
|
|
},
|
|
{
|
|
desc: `make statement`,
|
|
code: Id("a").Op(":=").Make(Id("a")),
|
|
expect: `a := make(a)`,
|
|
},
|
|
{
|
|
desc: `make group`,
|
|
code: BlockFunc(func(g *Group) {
|
|
g.Make(Id("a"))
|
|
}),
|
|
expect: `{
|
|
make(a)
|
|
}`,
|
|
},
|
|
{
|
|
desc: `len func`,
|
|
code: Len(Id("a")),
|
|
expect: `len(a)`,
|
|
},
|
|
{
|
|
desc: `len statement`,
|
|
code: Id("a").Op(":=").Len(Id("a")),
|
|
expect: `a := len(a)`,
|
|
},
|
|
{
|
|
desc: `len group`,
|
|
code: BlockFunc(func(g *Group) {
|
|
g.Len(Id("a"))
|
|
}),
|
|
expect: `{
|
|
len(a)
|
|
}`,
|
|
},
|
|
{
|
|
desc: `imag func`,
|
|
code: Imag(Id("a")),
|
|
expect: `imag(a)`,
|
|
},
|
|
{
|
|
desc: `imag statement`,
|
|
code: Id("a").Op(":=").Imag(Id("a")),
|
|
expect: `a := imag(a)`,
|
|
},
|
|
{
|
|
desc: `imag group`,
|
|
code: BlockFunc(func(g *Group) {
|
|
g.Imag(Id("a"))
|
|
}),
|
|
expect: `{
|
|
imag(a)
|
|
}`,
|
|
},
|
|
{
|
|
desc: `delete func`,
|
|
code: Delete(Id("a"), Id("b")),
|
|
expect: `delete(a, b)`,
|
|
},
|
|
{
|
|
desc: `delete statement`,
|
|
code: Null().Delete(Id("a"), Id("b")),
|
|
expect: `delete(a, b)`,
|
|
},
|
|
{
|
|
desc: `delete group`,
|
|
code: BlockFunc(func(g *Group) {
|
|
g.Delete(Id("a"), Id("b"))
|
|
}),
|
|
expect: `{
|
|
delete(a, b)
|
|
}`,
|
|
},
|
|
{
|
|
desc: `copy func`,
|
|
code: Copy(Id("a"), Id("b")),
|
|
expect: `copy(a, b)`,
|
|
},
|
|
{
|
|
desc: `copy statement`,
|
|
code: Id("a").Op(":=").Copy(Id("a"), Id("b")),
|
|
expect: `a := copy(a, b)`,
|
|
},
|
|
{
|
|
desc: `copy group`,
|
|
code: BlockFunc(func(g *Group) {
|
|
g.Copy(Id("a"), Id("b"))
|
|
}),
|
|
expect: `{
|
|
copy(a, b)
|
|
}`,
|
|
},
|
|
{
|
|
desc: `complex func`,
|
|
code: Complex(Id("a"), Id("b")),
|
|
expect: `complex(a, b)`,
|
|
},
|
|
{
|
|
desc: `complex statement`,
|
|
code: Id("a").Op(":=").Complex(Id("a"), Id("b")),
|
|
expect: `a := complex(a, b)`,
|
|
},
|
|
{
|
|
desc: `complex group`,
|
|
code: BlockFunc(func(g *Group) {
|
|
g.Complex(Id("a"), Id("b"))
|
|
}),
|
|
expect: `{
|
|
complex(a, b)
|
|
}`,
|
|
},
|
|
{
|
|
desc: `close group`,
|
|
code: BlockFunc(func(g *Group) { g.Close(Id("a")) }),
|
|
expect: `{
|
|
close(a)
|
|
}`,
|
|
},
|
|
{
|
|
desc: `cap func`,
|
|
code: Cap(Id("a")),
|
|
expect: `cap(a)`,
|
|
},
|
|
{
|
|
desc: `cap statement`,
|
|
code: Id("a").Op(":=").Cap(Id("b")),
|
|
expect: `a := cap(b)`,
|
|
},
|
|
{
|
|
desc: `cap group`,
|
|
code: BlockFunc(func(g *Group) {
|
|
g.Cap(Id("a"))
|
|
}),
|
|
expect: `{
|
|
cap(a)
|
|
}`,
|
|
},
|
|
{
|
|
desc: `append group`,
|
|
code: BlockFunc(func(g *Group) {
|
|
g.Append(Id("a"))
|
|
}),
|
|
expect: `{
|
|
append(a)
|
|
}`,
|
|
},
|
|
{
|
|
desc: `appendfunc statement`,
|
|
code: Id("a").Op("=").AppendFunc(func(ag *Group) { ag.Id("a") }),
|
|
expect: `a = append(a)`,
|
|
},
|
|
{
|
|
desc: `appendfunc func`,
|
|
code: AppendFunc(func(ag *Group) { ag.Id("a") }),
|
|
expect: `append(a)`,
|
|
},
|
|
{
|
|
desc: `appendfunc group`,
|
|
code: BlockFunc(func(bg *Group) {
|
|
bg.AppendFunc(func(ag *Group) { ag.Id("a") })
|
|
}),
|
|
expect: `{
|
|
append(a)
|
|
}`,
|
|
},
|
|
{
|
|
desc: `casefunc group`,
|
|
code: Switch().BlockFunc(func(g *Group) {
|
|
g.CaseFunc(func(g *Group) { g.Id("a") }).Block()
|
|
}),
|
|
expect: `switch {
|
|
case a:
|
|
}`,
|
|
},
|
|
{
|
|
desc: `case group`,
|
|
code: Switch().BlockFunc(func(g *Group) {
|
|
g.Case(Id("a")).Block()
|
|
}),
|
|
expect: `switch {
|
|
case a:
|
|
}`,
|
|
},
|
|
{
|
|
desc: `structfunc statement`,
|
|
code: Id("a").Op(":=").StructFunc(func(g *Group) {}).Values(),
|
|
expect: `a := struct{}{}`,
|
|
},
|
|
{
|
|
desc: `structfunc group`,
|
|
// Don't do this! ListFunc used to kludge Group.Struct usage
|
|
// without syntax error.
|
|
code: Id("a").Op(":=").ListFunc(func(g *Group) { g.StructFunc(func(g *Group) {}) }).Values(),
|
|
expect: `a := struct{}{}`,
|
|
},
|
|
{
|
|
desc: `structfunc func`,
|
|
code: Id("a").Op(":=").Add(StructFunc(func(g *Group) {})).Values(),
|
|
expect: `a := struct{}{}`,
|
|
},
|
|
{
|
|
desc: `struct group`,
|
|
// Don't do this! ListFunc used to kludge Group.Struct usage
|
|
// without syntax error.
|
|
code: Id("a").Op(":=").ListFunc(func(g *Group) { g.Struct() }).Values(),
|
|
expect: `a := struct{}{}`,
|
|
},
|
|
{
|
|
desc: `struct func`,
|
|
code: Id("a").Op(":=").Add(Struct()).Values(),
|
|
expect: `a := struct{}{}`,
|
|
},
|
|
{
|
|
desc: `interfacefunc func`,
|
|
code: Id("a").Assert(InterfaceFunc(func(g *Group) {
|
|
g.Id("a").Call().Int()
|
|
g.Id("b").Call().Int()
|
|
})),
|
|
expect: `a.(interface{
|
|
a() int
|
|
b() int
|
|
})`,
|
|
},
|
|
{
|
|
desc: `interfacefunc statement`,
|
|
code: Id("a").Assert(Null().InterfaceFunc(func(g *Group) {
|
|
g.Id("a").Call().Int()
|
|
g.Id("b").Call().Int()
|
|
})),
|
|
expect: `a.(interface{
|
|
a() int
|
|
b() int
|
|
})`,
|
|
},
|
|
{
|
|
desc: `interfacefunc group`,
|
|
// Don't do this! ListFunc used to kludge Group.InterfaceFunc usage
|
|
// without syntax error.
|
|
code: Id("a").Assert(ListFunc(func(lg *Group) {
|
|
lg.InterfaceFunc(func(ig *Group) {
|
|
ig.Id("a").Call().Int()
|
|
ig.Id("b").Call().Int()
|
|
})
|
|
})),
|
|
expect: `a.(interface{
|
|
a() int
|
|
b() int
|
|
})`,
|
|
},
|
|
{
|
|
desc: `interface func`,
|
|
code: Interface().Parens(Id("a")),
|
|
expect: `interface{}(a)`,
|
|
},
|
|
{
|
|
desc: `interface group`,
|
|
code: BlockFunc(func(g *Group) {
|
|
g.Interface().Parens(Id("a"))
|
|
}),
|
|
expect: `{
|
|
interface{}(a)
|
|
}`,
|
|
},
|
|
{
|
|
desc: `interface statement`,
|
|
code: Null().Interface().Parens(Id("a")),
|
|
expect: `interface{}(a)`,
|
|
},
|
|
{
|
|
desc: `switchfunc func`,
|
|
code: SwitchFunc(func(rg *Group) {
|
|
rg.Id("a")
|
|
}).Block(),
|
|
expect: `switch a {}`,
|
|
},
|
|
{
|
|
desc: `switchfunc statement`,
|
|
code: Null().SwitchFunc(func(rg *Group) {
|
|
rg.Id("a")
|
|
}).Block(),
|
|
expect: `switch a {
|
|
}`,
|
|
},
|
|
{
|
|
desc: `switchfunc group`,
|
|
code: BlockFunc(func(bg *Group) {
|
|
bg.SwitchFunc(func(rg *Group) {
|
|
rg.Id("a")
|
|
}).Block()
|
|
}),
|
|
expect: `{
|
|
switch a {
|
|
}
|
|
}`,
|
|
},
|
|
{
|
|
desc: `switch group`,
|
|
code: BlockFunc(func(bg *Group) {
|
|
bg.Switch().Block()
|
|
}),
|
|
expect: `{
|
|
switch {
|
|
}
|
|
}`,
|
|
},
|
|
{
|
|
desc: `forfunc func`,
|
|
code: ForFunc(func(rg *Group) {
|
|
rg.Id("a")
|
|
}).Block(),
|
|
expect: `for a {}`,
|
|
},
|
|
{
|
|
desc: `forfunc statement`,
|
|
code: Null().ForFunc(func(rg *Group) {
|
|
rg.Id("a")
|
|
}).Block(),
|
|
expect: `for a {
|
|
}`,
|
|
},
|
|
{
|
|
desc: `forfunc group`,
|
|
code: BlockFunc(func(bg *Group) {
|
|
bg.ForFunc(func(rg *Group) {
|
|
rg.Id("a")
|
|
}).Block()
|
|
}),
|
|
expect: `{
|
|
for a {
|
|
}
|
|
}`,
|
|
},
|
|
{
|
|
desc: `for group`,
|
|
code: BlockFunc(func(g *Group) {
|
|
g.For(Id("a")).Block()
|
|
}),
|
|
expect: `{
|
|
for a {}
|
|
}`,
|
|
},
|
|
{
|
|
desc: `returnfunc func`,
|
|
code: ReturnFunc(func(rg *Group) {
|
|
rg.Lit(1)
|
|
rg.Lit(2)
|
|
}),
|
|
expect: `return 1, 2`,
|
|
},
|
|
{
|
|
desc: `returnfunc statement`,
|
|
code: Empty().ReturnFunc(func(rg *Group) {
|
|
rg.Lit(1)
|
|
rg.Lit(2)
|
|
}),
|
|
expect: `return 1, 2`,
|
|
},
|
|
{
|
|
desc: `returnfunc group`,
|
|
code: BlockFunc(func(bg *Group) {
|
|
bg.ReturnFunc(func(rg *Group) {
|
|
rg.Lit(1)
|
|
rg.Lit(2)
|
|
})
|
|
}),
|
|
expect: `{
|
|
return 1, 2
|
|
}`,
|
|
},
|
|
{
|
|
desc: `return group`,
|
|
code: BlockFunc(func(g *Group) {
|
|
g.Return()
|
|
}),
|
|
expect: `{
|
|
return
|
|
}`,
|
|
},
|
|
{
|
|
desc: `iffunc group`,
|
|
code: BlockFunc(func(bg *Group) {
|
|
bg.IfFunc(func(ig *Group) {
|
|
ig.Id("a")
|
|
}).Block()
|
|
}),
|
|
expect: `{
|
|
if a {}
|
|
}`,
|
|
},
|
|
{
|
|
desc: `iffunc func`,
|
|
code: IfFunc(func(ig *Group) {
|
|
ig.Id("a")
|
|
}).Block(),
|
|
expect: `if a {}`,
|
|
},
|
|
{
|
|
desc: `iffunc statement`,
|
|
code: Null().IfFunc(func(ig *Group) {
|
|
ig.Id("a")
|
|
}).Block(),
|
|
expect: `if a {}`,
|
|
},
|
|
{
|
|
desc: `if group`,
|
|
code: BlockFunc(func(g *Group) { g.If(Id("a")).Block() }),
|
|
expect: `{
|
|
if a {}
|
|
}`,
|
|
},
|
|
{
|
|
desc: `map group`,
|
|
code: BlockFunc(func(g *Group) { g.Map(Int()).Int().Values(Dict{Lit(1): Lit(1)}) }),
|
|
expect: `{
|
|
map[int]int{1:1}
|
|
}`,
|
|
},
|
|
{
|
|
desc: `assert group`,
|
|
// Don't do this! ListFunc used to kludge Group.Assert usage without
|
|
// syntax error.
|
|
code: Id("a").ListFunc(func(g *Group) { g.Assert(Id("b")) }),
|
|
expect: `a.(b)`,
|
|
},
|
|
{
|
|
desc: `assert func`,
|
|
code: Id("a").Add(Assert(Id("b"))),
|
|
expect: `a.(b)`,
|
|
},
|
|
{
|
|
desc: `paramsfunc group`,
|
|
// Don't do this! ListFunc used to kludge Group.ParamsFunc usage without
|
|
// syntax error.
|
|
code: Id("a").ListFunc(func(lg *Group) { lg.ParamsFunc(func(cg *Group) { cg.Lit(1) }) }),
|
|
expect: `a(1)`,
|
|
},
|
|
{
|
|
desc: `paramsfunc func`,
|
|
code: Id("a").Add(ParamsFunc(func(g *Group) { g.Lit(1) })),
|
|
expect: `a(1)`,
|
|
},
|
|
{
|
|
desc: `paramsfunc statement`,
|
|
code: Id("a").ParamsFunc(func(g *Group) { g.Lit(1) }),
|
|
expect: `a(1)`,
|
|
},
|
|
{
|
|
desc: `params group`,
|
|
// Don't do this! ListFunc used to kludge Group.Params usage without
|
|
// syntax error.
|
|
code: Id("a").ListFunc(func(g *Group) { g.Params(Lit(1)) }),
|
|
expect: `a(1)`,
|
|
},
|
|
{
|
|
desc: `params func`,
|
|
code: Id("a").Add(Params(Lit(1))),
|
|
expect: `a(1)`,
|
|
},
|
|
{
|
|
desc: `callfunc group`,
|
|
// Don't do this! ListFunc used to kludge Group.CallFunc usage without
|
|
// syntax error.
|
|
code: Id("a").ListFunc(func(lg *Group) { lg.CallFunc(func(cg *Group) { cg.Lit(1) }) }),
|
|
expect: `a(1)`,
|
|
},
|
|
{
|
|
desc: `callfunc func`,
|
|
code: Id("a").Add(CallFunc(func(g *Group) { g.Lit(1) })),
|
|
expect: `a(1)`,
|
|
},
|
|
{
|
|
desc: `call group`,
|
|
// Don't do this! ListFunc used to kludge Group.Call usage without
|
|
// syntax error.
|
|
code: Id("a").ListFunc(func(g *Group) { g.Call(Lit(1)) }),
|
|
expect: `a(1)`,
|
|
},
|
|
{
|
|
desc: `call func`,
|
|
code: Id("a").Add(Call(Lit(1))),
|
|
expect: `a(1)`,
|
|
},
|
|
{
|
|
desc: `defsfunc statement`,
|
|
code: Const().DefsFunc(func(g *Group) { g.Id("a").Op("=").Lit(1) }),
|
|
expect: `const (
|
|
a = 1
|
|
)`,
|
|
},
|
|
{
|
|
desc: `defsfunc func`,
|
|
code: Const().Add(DefsFunc(func(g *Group) { g.Id("a").Op("=").Lit(1) })),
|
|
expect: `const (
|
|
a = 1
|
|
)`,
|
|
},
|
|
{
|
|
desc: `defsfunc group`,
|
|
// Don't do this! ListFunc used to kludge Group.DefsFunc usage without
|
|
// syntax error.
|
|
code: Const().ListFunc(func(lg *Group) { lg.DefsFunc(func(dg *Group) { dg.Id("a").Op("=").Lit(1) }) }),
|
|
expect: `const (
|
|
a = 1
|
|
)`,
|
|
},
|
|
{
|
|
desc: `defs group`,
|
|
// Don't do this! ListFunc used to kludge Group.Defs usage without
|
|
// syntax error.
|
|
code: Const().ListFunc(func(g *Group) { g.Defs(Id("a").Op("=").Lit(1)) }),
|
|
expect: `const (
|
|
a = 1
|
|
)`,
|
|
},
|
|
{
|
|
desc: `defs func`,
|
|
code: Const().Add(Defs(Id("a").Op("=").Lit(1))),
|
|
expect: `const (
|
|
a = 1
|
|
)`,
|
|
},
|
|
{
|
|
desc: `blockfunc group`,
|
|
code: BlockFunc(func(g *Group) { g.BlockFunc(func(g *Group) {}) }),
|
|
expect: `{{}}`,
|
|
},
|
|
{
|
|
desc: `block group`,
|
|
code: BlockFunc(func(g *Group) { g.Block() }),
|
|
expect: `{{}}`,
|
|
},
|
|
{
|
|
desc: `indexfunc group`,
|
|
code: BlockFunc(func(g *Group) { g.IndexFunc(func(g *Group) { g.Lit(1) }).Int().Values(Lit(1)) }),
|
|
expect: `{[1]int{1}}`,
|
|
},
|
|
{
|
|
desc: `indexfunc statement`,
|
|
code: Id("a").IndexFunc(func(g *Group) { g.Lit(1) }),
|
|
expect: `a[1]`,
|
|
},
|
|
{
|
|
desc: `indexfunc func`,
|
|
code: Id("a").Add(IndexFunc(func(g *Group) { g.Lit(1) })),
|
|
expect: `a[1]`,
|
|
},
|
|
{
|
|
desc: `index group`,
|
|
code: BlockFunc(func(g *Group) { g.Index(Lit(1)).Int().Values(Lit(1)) }),
|
|
expect: `{[1]int{1}}`,
|
|
},
|
|
{
|
|
desc: `index func`,
|
|
code: Id("a").Add(Index(Lit(1))),
|
|
expect: `a[1]`,
|
|
},
|
|
{
|
|
desc: `valuesfunc func`,
|
|
code: ValuesFunc(func(vg *Group) {
|
|
vg.Lit(1)
|
|
}),
|
|
expect: `{1}`,
|
|
},
|
|
{
|
|
desc: `valuesfunc group`,
|
|
code: BlockFunc(func(bg *Group) {
|
|
bg.ValuesFunc(func(vg *Group) {
|
|
vg.Lit(1)
|
|
})
|
|
}),
|
|
expect: `{
|
|
{1}
|
|
}`,
|
|
},
|
|
{
|
|
desc: `values group`,
|
|
code: BlockFunc(func(g *Group) {
|
|
g.Values(Lit(1))
|
|
}),
|
|
expect: `{
|
|
{1}
|
|
}`,
|
|
},
|
|
{
|
|
desc: `listfunc statement`,
|
|
code: Add(Null()).ListFunc(func(lg *Group) {
|
|
lg.Id("a")
|
|
lg.Id("b")
|
|
}).Op("=").Id("c"),
|
|
expect: `a, b = c`,
|
|
},
|
|
{
|
|
desc: `listfunc func`,
|
|
code: ListFunc(func(lg *Group) {
|
|
lg.Id("a")
|
|
lg.Id("b")
|
|
}).Op("=").Id("c"),
|
|
expect: `a, b = c`,
|
|
},
|
|
{
|
|
desc: `listfunc group`,
|
|
code: BlockFunc(func(bg *Group) {
|
|
bg.ListFunc(func(lg *Group) {
|
|
lg.Id("a")
|
|
lg.Id("b")
|
|
}).Op("=").Id("c")
|
|
}),
|
|
expect: `{
|
|
a, b = c
|
|
}`,
|
|
},
|
|
{
|
|
desc: `list group`,
|
|
code: BlockFunc(func(g *Group) { g.List(Id("a"), Id("b")).Op("=").Id("c") }),
|
|
expect: `{
|
|
a, b = c
|
|
}`,
|
|
},
|
|
{
|
|
desc: `parens func`,
|
|
code: Parens(Lit(1)),
|
|
expect: `(1)`,
|
|
},
|
|
{
|
|
desc: `parens group`,
|
|
code: BlockFunc(func(g *Group) { g.Parens(Lit(1)) }),
|
|
expect: `{
|
|
(1)
|
|
}`,
|
|
},
|
|
}
|
|
|
|
func TestGen(t *testing.T) {
|
|
caseTester(t, gencases)
|
|
}
|