How to use Error method of ast Package

Best Syzkaller code snippet using ast.Error

service_test.go

Source:service_test.go Github

copy

Full Screen

...20 }))21 })22 t.Run("wrong", func(t *testing.T) {23 _, err := parser.Accept(fn, `(var)`)24 assert.Error(t, err)25 _, err = parser.Accept(fn, `()`)26 assert.Nil(t, err)27 })28}29func TestRoute(t *testing.T) {30 fn := func(p *api.ApiParserParser, v *ast.ApiVisitor) interface{} {31 return p.Route().Accept(v)32 }33 t.Run("normal", func(t *testing.T) {34 v, err := parser.Accept(fn, `post /foo/foo-bar/:bar (Foo) returns (Bar)`)35 assert.Nil(t, err)36 route := v.(*ast.Route)37 assert.True(t, route.Equal(&ast.Route{38 Method: ast.NewTextExpr("post"),39 Path: ast.NewTextExpr("/foo/foo-bar/:bar"),40 Req: &ast.Body{41 Lp: ast.NewTextExpr("("),42 Rp: ast.NewTextExpr(")"),43 Name: &ast.Literal{Literal: ast.NewTextExpr("Foo")},44 },45 ReturnToken: ast.NewTextExpr("returns"),46 Reply: &ast.Body{47 Lp: ast.NewTextExpr("("),48 Rp: ast.NewTextExpr(")"),49 Name: &ast.Literal{Literal: ast.NewTextExpr("Bar")},50 },51 }))52 v, err = parser.Accept(fn, `post /foo/foo-bar/:bar (Foo)`)53 assert.Nil(t, err)54 route = v.(*ast.Route)55 assert.True(t, route.Equal(&ast.Route{56 Method: ast.NewTextExpr("post"),57 Path: ast.NewTextExpr("/foo/foo-bar/:bar"),58 Req: &ast.Body{59 Lp: ast.NewTextExpr("("),60 Rp: ast.NewTextExpr(")"),61 Name: &ast.Literal{Literal: ast.NewTextExpr("Foo")},62 },63 }))64 v, err = parser.Accept(fn, `post /foo/foo-bar/:bar returns (Bar)`)65 assert.Nil(t, err)66 route = v.(*ast.Route)67 assert.True(t, route.Equal(&ast.Route{68 Method: ast.NewTextExpr("post"),69 Path: ast.NewTextExpr("/foo/foo-bar/:bar"),70 ReturnToken: ast.NewTextExpr("returns"),71 Reply: &ast.Body{72 Lp: ast.NewTextExpr("("),73 Rp: ast.NewTextExpr(")"),74 Name: &ast.Literal{Literal: ast.NewTextExpr("Bar")},75 },76 }))77 v, err = parser.Accept(fn, `post /foo/foo-bar/:bar returns ([]Bar)`)78 assert.Nil(t, err)79 route = v.(*ast.Route)80 assert.True(t, route.Equal(&ast.Route{81 Method: ast.NewTextExpr("post"),82 Path: ast.NewTextExpr("/foo/foo-bar/:bar"),83 ReturnToken: ast.NewTextExpr("returns"),84 Reply: &ast.Body{85 Lp: ast.NewTextExpr("("),86 Rp: ast.NewTextExpr(")"),87 Name: &ast.Array{88 ArrayExpr: ast.NewTextExpr("[]Bar"),89 LBrack: ast.NewTextExpr("["),90 RBrack: ast.NewTextExpr("]"),91 Literal: &ast.Literal{Literal: ast.NewTextExpr("Bar")},92 },93 },94 }))95 v, err = parser.Accept(fn, `post /foo/foo-bar/:bar returns ([]*Bar)`)96 assert.Nil(t, err)97 route = v.(*ast.Route)98 assert.True(t, route.Equal(&ast.Route{99 Method: ast.NewTextExpr("post"),100 Path: ast.NewTextExpr("/foo/foo-bar/:bar"),101 ReturnToken: ast.NewTextExpr("returns"),102 Reply: &ast.Body{103 Lp: ast.NewTextExpr("("),104 Rp: ast.NewTextExpr(")"),105 Name: &ast.Array{106 ArrayExpr: ast.NewTextExpr("[]*Bar"),107 LBrack: ast.NewTextExpr("["),108 RBrack: ast.NewTextExpr("]"),109 Literal: &ast.Pointer{110 PointerExpr: ast.NewTextExpr("*Bar"),111 Star: ast.NewTextExpr("*"),112 Name: ast.NewTextExpr("Bar"),113 },114 },115 },116 }))117 v, err = parser.Accept(fn, `post /foo/foo-bar/:bar`)118 assert.Nil(t, err)119 route = v.(*ast.Route)120 assert.True(t, route.Equal(&ast.Route{121 Method: ast.NewTextExpr("post"),122 Path: ast.NewTextExpr("/foo/foo-bar/:bar"),123 }))124 v, err = parser.Accept(fn, `125 // foo126 post /foo/foo-bar/:bar // bar`)127 assert.Nil(t, err)128 route = v.(*ast.Route)129 assert.True(t, route.Equal(&ast.Route{130 Method: ast.NewTextExpr("post"),131 Path: ast.NewTextExpr("/foo/foo-bar/:bar"),132 DocExpr: []ast.Expr{133 ast.NewTextExpr("// foo"),134 },135 CommentExpr: ast.NewTextExpr("// bar"),136 }))137 })138 t.Run("wrong", func(t *testing.T) {139 _, err := parser.Accept(fn, `posts /foo`)140 assert.Error(t, err)141 _, err = parser.Accept(fn, `gets /foo`)142 assert.Error(t, err)143 _, err = parser.Accept(fn, `post /foo/:`)144 assert.Error(t, err)145 _, err = parser.Accept(fn, `post /foo/`)146 assert.Error(t, err)147 _, err = parser.Accept(fn, `post foo/bar`)148 assert.Error(t, err)149 _, err = parser.Accept(fn, `post /foo/bar return (Bar)`)150 assert.Error(t, err)151 _, err = parser.Accept(fn, ` /foo/bar returns (Bar)`)152 assert.Error(t, err)153 _, err = parser.Accept(fn, ` post returns (Bar)`)154 assert.Error(t, err)155 _, err = parser.Accept(fn, ` post /foo/bar returns (int)`)156 assert.Nil(t, err)157 _, err = parser.Accept(fn, ` post /foo/bar returns (*int)`)158 assert.Error(t, err)159 _, err = parser.Accept(fn, ` post /foo/bar returns ([]var)`)160 assert.Error(t, err)161 _, err = parser.Accept(fn, ` post /foo/bar returns (const)`)162 assert.Error(t, err)163 })164}165func TestAtHandler(t *testing.T) {166 fn := func(p *api.ApiParserParser, v *ast.ApiVisitor) interface{} {167 return p.AtHandler().Accept(v)168 }169 t.Run("normal", func(t *testing.T) {170 v, err := parser.Accept(fn, `@handler foo`)171 assert.Nil(t, err)172 atHandler := v.(*ast.AtHandler)173 assert.True(t, atHandler.Equal(&ast.AtHandler{174 AtHandlerToken: ast.NewTextExpr("@handler"),175 Name: ast.NewTextExpr("foo"),176 }))177 v, err = parser.Accept(fn, `178 // foo179 @handler foo // bar`)180 assert.Nil(t, err)181 atHandler = v.(*ast.AtHandler)182 assert.True(t, atHandler.Equal(&ast.AtHandler{183 AtHandlerToken: ast.NewTextExpr("@handler"),184 Name: ast.NewTextExpr("foo"),185 DocExpr: []ast.Expr{186 ast.NewTextExpr("// foo"),187 },188 CommentExpr: ast.NewTextExpr("// bar"),189 }))190 })191 t.Run("wrong", func(t *testing.T) {192 _, err := parser.Accept(fn, ``)193 assert.Error(t, err)194 _, err = parser.Accept(fn, `@handler`)195 assert.Error(t, err)196 _, err = parser.Accept(fn, `@handler "foo"`)197 assert.Error(t, err)198 })199}200func TestAtDoc(t *testing.T) {201 fn := func(p *api.ApiParserParser, v *ast.ApiVisitor) interface{} {202 return p.AtDoc().Accept(v)203 }204 t.Run("normal", func(t *testing.T) {205 v, err := parser.Accept(fn, `@doc "foo"`)206 assert.Nil(t, err)207 atDoc := v.(*ast.AtDoc)208 assert.True(t, atDoc.Equal(&ast.AtDoc{209 AtDocToken: ast.NewTextExpr("@doc"),210 LineDoc: ast.NewTextExpr(`"foo"`),211 }))212 v, err = parser.Accept(fn, `@doc("foo")`)213 assert.Nil(t, err)214 atDoc = v.(*ast.AtDoc)215 assert.True(t, atDoc.Equal(&ast.AtDoc{216 AtDocToken: ast.NewTextExpr("@doc"),217 Lp: ast.NewTextExpr("("),218 Rp: ast.NewTextExpr(")"),219 LineDoc: ast.NewTextExpr(`"foo"`),220 }))221 v, err = parser.Accept(fn, `@doc(222 foo: bar223 )`)224 assert.Nil(t, err)225 atDoc = v.(*ast.AtDoc)226 assert.True(t, atDoc.Equal(&ast.AtDoc{227 AtDocToken: ast.NewTextExpr("@doc"),228 Lp: ast.NewTextExpr("("),229 Rp: ast.NewTextExpr(")"),230 Kv: []*ast.KvExpr{231 {232 Key: ast.NewTextExpr("foo"),233 Value: ast.NewTextExpr("bar"),234 },235 },236 }))237 v, err = parser.Accept(fn, `@doc(238 // foo239 foo: bar // bar240 )`)241 assert.Nil(t, err)242 atDoc = v.(*ast.AtDoc)243 assert.True(t, atDoc.Equal(&ast.AtDoc{244 AtDocToken: ast.NewTextExpr("@doc"),245 Lp: ast.NewTextExpr("("),246 Rp: ast.NewTextExpr(")"),247 Kv: []*ast.KvExpr{248 {249 Key: ast.NewTextExpr("foo"),250 Value: ast.NewTextExpr("bar"),251 DocExpr: []ast.Expr{252 ast.NewTextExpr("// foo"),253 },254 CommentExpr: ast.NewTextExpr("// bar"),255 },256 },257 }))258 })259 t.Run("wrong", func(t *testing.T) {260 _, err := parser.Accept(fn, `@doc("foo"`)261 assert.Error(t, err)262 _, err = parser.Accept(fn, `@doc "foo")`)263 assert.Error(t, err)264 })265}266func TestServiceRoute(t *testing.T) {267 fn := func(p *api.ApiParserParser, v *ast.ApiVisitor) interface{} {268 return p.ServiceRoute().Accept(v)269 }270 t.Run("normal", func(t *testing.T) {271 v, err := parser.Accept(fn, `272 @doc("foo")273 // foo/bar274 // foo275 @handler foo // bar276 // foo/bar277 // foo278 post /foo (Foo) returns (Bar) // bar279 `)280 assert.Nil(t, err)281 sr := v.(*ast.ServiceRoute)282 assert.True(t, sr.Equal(&ast.ServiceRoute{283 AtDoc: &ast.AtDoc{284 AtDocToken: ast.NewTextExpr("@doc"),285 Lp: ast.NewTextExpr("("),286 Rp: ast.NewTextExpr(")"),287 LineDoc: ast.NewTextExpr(`"foo"`),288 },289 AtHandler: &ast.AtHandler{290 AtHandlerToken: ast.NewTextExpr("@handler"),291 Name: ast.NewTextExpr("foo"),292 DocExpr: []ast.Expr{293 ast.NewTextExpr("// foo"),294 },295 CommentExpr: ast.NewTextExpr("// bar"),296 },297 Route: &ast.Route{298 Method: ast.NewTextExpr("post"),299 Path: ast.NewTextExpr("/foo"),300 Req: &ast.Body{301 Lp: ast.NewTextExpr("("),302 Rp: ast.NewTextExpr(")"),303 Name: &ast.Literal{Literal: ast.NewTextExpr("Foo")},304 },305 ReturnToken: ast.NewTextExpr("returns"),306 Reply: &ast.Body{307 Lp: ast.NewTextExpr("("),308 Rp: ast.NewTextExpr(")"),309 Name: &ast.Literal{Literal: ast.NewTextExpr("Bar")},310 },311 DocExpr: []ast.Expr{312 ast.NewTextExpr("// foo"),313 },314 CommentExpr: ast.NewTextExpr("// bar"),315 },316 }))317 })318 t.Run("wrong", func(t *testing.T) {319 _, err := parser.Accept(fn, `post /foo (Foo) returns (Bar) // bar`)320 assert.Error(t, err)321 _, err = parser.Accept(fn, `@handler foo`)322 assert.Error(t, err)323 })324}325func TestServiceApi(t *testing.T) {326 fn := func(p *api.ApiParserParser, v *ast.ApiVisitor) interface{} {327 return p.ServiceApi().Accept(v)328 }329 t.Run("normal", func(t *testing.T) {330 v, err := parser.Accept(fn, `331 service foo-api{332 @doc("foo")333 // foo/bar334 // foo335 @handler foo // bar336 // foo/bar337 // foo338 post /foo (Foo) returns (Bar) // bar339 }340 `)341 assert.Nil(t, err)342 api := v.(*ast.ServiceApi)343 assert.True(t, api.Equal(&ast.ServiceApi{344 ServiceToken: ast.NewTextExpr("service"),345 Name: ast.NewTextExpr("foo-api"),346 Lbrace: ast.NewTextExpr("{"),347 Rbrace: ast.NewTextExpr("}"),348 ServiceRoute: []*ast.ServiceRoute{349 {350 AtDoc: &ast.AtDoc{351 AtDocToken: ast.NewTextExpr("@doc"),352 Lp: ast.NewTextExpr("("),353 Rp: ast.NewTextExpr(")"),354 LineDoc: ast.NewTextExpr(`"foo"`),355 },356 AtHandler: &ast.AtHandler{357 AtHandlerToken: ast.NewTextExpr("@handler"),358 Name: ast.NewTextExpr("foo"),359 DocExpr: []ast.Expr{360 ast.NewTextExpr("// foo"),361 },362 CommentExpr: ast.NewTextExpr("// bar"),363 },364 Route: &ast.Route{365 Method: ast.NewTextExpr("post"),366 Path: ast.NewTextExpr("/foo"),367 Req: &ast.Body{368 Lp: ast.NewTextExpr("("),369 Rp: ast.NewTextExpr(")"),370 Name: &ast.Literal{Literal: ast.NewTextExpr("Foo")},371 },372 ReturnToken: ast.NewTextExpr("returns"),373 Reply: &ast.Body{374 Lp: ast.NewTextExpr("("),375 Rp: ast.NewTextExpr(")"),376 Name: &ast.Literal{Literal: ast.NewTextExpr("Bar")},377 },378 DocExpr: []ast.Expr{379 ast.NewTextExpr("// foo"),380 },381 CommentExpr: ast.NewTextExpr("// bar"),382 },383 },384 },385 }))386 })387 t.Run("wrong", func(t *testing.T) {388 _, err := parser.Accept(fn, `services foo-api{}`)389 assert.Error(t, err)390 _, err = parser.Accept(fn, `service foo-api{`)391 assert.Error(t, err)392 _, err = parser.Accept(fn, `service foo-api{393 post /foo394 }`)395 assert.Error(t, err)396 _, err = parser.Accept(fn, `service foo-api{397 @handler foo398 }`)399 assert.Error(t, err)400 })401}402func TestAtServer(t *testing.T) {403 fn := func(p *api.ApiParserParser, v *ast.ApiVisitor) interface{} {404 return p.AtServer().Accept(v)405 }406 t.Run("normal", func(t *testing.T) {407 v, err := parser.Accept(fn, `408 @server(409 // foo410 foo1: bar1 // bar411 // foo412 foo2: "bar2" // bar413 /**foo*/414 foo3: "foo415 bar" /**bar*/ 416 )417 `)418 assert.Nil(t, err)419 as := v.(*ast.AtServer)420 assert.True(t, as.Equal(&ast.AtServer{421 AtServerToken: ast.NewTextExpr("@server"),422 Lp: ast.NewTextExpr("("),423 Rp: ast.NewTextExpr(")"),424 Kv: []*ast.KvExpr{425 {426 Key: ast.NewTextExpr("foo1"),427 Value: ast.NewTextExpr("bar1"),428 DocExpr: []ast.Expr{429 ast.NewTextExpr("// foo"),430 },431 CommentExpr: ast.NewTextExpr("// bar"),432 },433 {434 Key: ast.NewTextExpr("foo2"),435 Value: ast.NewTextExpr(`"bar2"`),436 DocExpr: []ast.Expr{437 ast.NewTextExpr("// foo"),438 },439 CommentExpr: ast.NewTextExpr("// bar"),440 },441 {442 Key: ast.NewTextExpr("foo3"),443 Value: ast.NewTextExpr(`"foo444 bar"`),445 DocExpr: []ast.Expr{446 ast.NewTextExpr("/**foo*/"),447 },448 CommentExpr: ast.NewTextExpr("/**bar*/"),449 },450 },451 }))452 })453 t.Run("wrong", func(t *testing.T) {454 _, err := parser.Accept(fn, `server (455 foo:bar456 )`)457 assert.Error(t, err)458 _, err = parser.Accept(fn, `@server ()`)459 assert.Error(t, err)460 _, err = parser.Accept(fn, `@server (461 foo: bar462 `)463 assert.Error(t, err)464 })465}466func TestServiceSpec(t *testing.T) {467 fn := func(p *api.ApiParserParser, v *ast.ApiVisitor) interface{} {468 return p.ServiceSpec().Accept(v)469 }470 t.Run("normal", func(t *testing.T) {471 _, err := parser.Accept(fn, `472 service foo-api{473 @handler foo474 post /foo returns ([]int)475 }476 `)477 assert.Nil(t, err)...

Full Screen

Full Screen

type_test.go

Source:type_test.go Github

copy

Full Screen

...45 },46 CommentExpr: ast.NewTextExpr("// pointer type"),47 }))48 _, err = parser.Accept(fieldAccept, `interface`)49 assert.Error(t, err)50 _, err = parser.Accept(fieldAccept, `map`)51 assert.Error(t, err)52 })53 t.Run("normal", func(t *testing.T) {54 v, err := parser.Accept(fieldAccept, `User int`)55 assert.Nil(t, err)56 f := v.(*ast.TypeField)57 assert.True(t, f.Equal(&ast.TypeField{58 Name: ast.NewTextExpr("User"),59 DataType: &ast.Literal{Literal: ast.NewTextExpr("int")},60 }))61 v, err = parser.Accept(fieldAccept, `Foo Bar`)62 assert.Nil(t, err)63 f = v.(*ast.TypeField)64 assert.True(t, f.Equal(&ast.TypeField{65 Name: ast.NewTextExpr("Foo"),66 DataType: &ast.Literal{Literal: ast.NewTextExpr("Bar")},67 }))68 v, err = parser.Accept(fieldAccept, `Foo map[int]Bar`)69 assert.Nil(t, err)70 f = v.(*ast.TypeField)71 assert.True(t, f.Equal(&ast.TypeField{72 Name: ast.NewTextExpr("Foo"),73 DataType: &ast.Map{74 MapExpr: ast.NewTextExpr("map[int]Bar"),75 Map: ast.NewTextExpr("map"),76 LBrack: ast.NewTextExpr("["),77 RBrack: ast.NewTextExpr("]"),78 Key: ast.NewTextExpr("int"),79 Value: &ast.Literal{Literal: ast.NewTextExpr("Bar")},80 },81 }))82 })83}84func TestDataType_ID(t *testing.T) {85 dt := func(p *api.ApiParserParser, visitor *ast.ApiVisitor) interface{} {86 return p.DataType().Accept(visitor)87 }88 t.Run("Struct", func(t *testing.T) {89 v, err := parser.Accept(dt, `Foo`)90 assert.Nil(t, err)91 id := v.(ast.DataType)92 assert.True(t, id.Equal(&ast.Literal{Literal: ast.NewTextExpr("Foo")}))93 })94 t.Run("basic", func(t *testing.T) {95 v, err := parser.Accept(dt, `int`)96 assert.Nil(t, err)97 id := v.(ast.DataType)98 assert.True(t, id.Equal(&ast.Literal{Literal: ast.NewTextExpr("int")}))99 })100 t.Run("wrong", func(t *testing.T) {101 _, err := parser.Accept(dt, `map`)102 assert.Error(t, err)103 })104}105func TestDataType_Map(t *testing.T) {106 dt := func(p *api.ApiParserParser, visitor *ast.ApiVisitor) interface{} {107 return p.MapType().Accept(visitor)108 }109 t.Run("basicKey", func(t *testing.T) {110 v, err := parser.Accept(dt, `map[int]Bar`)111 assert.Nil(t, err)112 m := v.(ast.DataType)113 assert.True(t, m.Equal(&ast.Map{114 MapExpr: ast.NewTextExpr("map[int]Bar"),115 Map: ast.NewTextExpr("map"),116 LBrack: ast.NewTextExpr("["),117 RBrack: ast.NewTextExpr("]"),118 Key: ast.NewTextExpr("int"),119 Value: &ast.Literal{Literal: ast.NewTextExpr("Bar")},120 }))121 })122 t.Run("wrong", func(t *testing.T) {123 _, err := parser.Accept(dt, `map[var]Bar`)124 assert.Error(t, err)125 _, err = parser.Accept(dt, `map[*User]Bar`)126 assert.Error(t, err)127 _, err = parser.Accept(dt, `map[User]Bar`)128 assert.Error(t, err)129 })130}131func TestDataType_Array(t *testing.T) {132 dt := func(p *api.ApiParserParser, visitor *ast.ApiVisitor) interface{} {133 return p.ArrayType().Accept(visitor)134 }135 t.Run("basic", func(t *testing.T) {136 v, err := parser.Accept(dt, `[]int`)137 assert.Nil(t, err)138 array := v.(ast.DataType)139 assert.True(t, array.Equal(&ast.Array{140 ArrayExpr: ast.NewTextExpr("[]int"),141 LBrack: ast.NewTextExpr("["),142 RBrack: ast.NewTextExpr("]"),143 Literal: &ast.Literal{Literal: ast.NewTextExpr("int")},144 }))145 })146 t.Run("pointer", func(t *testing.T) {147 v, err := parser.Accept(dt, `[]*User`)148 assert.Nil(t, err)149 array := v.(ast.DataType)150 assert.True(t, array.Equal(&ast.Array{151 ArrayExpr: ast.NewTextExpr("[]*User"),152 LBrack: ast.NewTextExpr("["),153 RBrack: ast.NewTextExpr("]"),154 Literal: &ast.Pointer{155 PointerExpr: ast.NewTextExpr("*User"),156 Star: ast.NewTextExpr("*"),157 Name: ast.NewTextExpr("User"),158 },159 }))160 })161 t.Run("interface{}", func(t *testing.T) {162 v, err := parser.Accept(dt, `[]interface{}`)163 assert.Nil(t, err)164 array := v.(ast.DataType)165 assert.True(t, array.Equal(&ast.Array{166 ArrayExpr: ast.NewTextExpr("[]interface{}"),167 LBrack: ast.NewTextExpr("["),168 RBrack: ast.NewTextExpr("]"),169 Literal: &ast.Interface{Literal: ast.NewTextExpr("interface{}")},170 }))171 })172 t.Run("wrong", func(t *testing.T) {173 _, err := parser.Accept(dt, `[]var`)174 assert.Error(t, err)175 _, err = parser.Accept(dt, `[]interface`)176 assert.Error(t, err)177 })178}179func TestDataType_Interface(t *testing.T) {180 dt := func(p *api.ApiParserParser, visitor *ast.ApiVisitor) interface{} {181 return p.DataType().Accept(visitor)182 }183 t.Run("normal", func(t *testing.T) {184 v, err := parser.Accept(dt, `interface{}`)185 assert.Nil(t, err)186 inter := v.(ast.DataType)187 assert.True(t, inter.Equal(&ast.Interface{Literal: ast.NewTextExpr("interface{}")}))188 })189 t.Run("wrong", func(t *testing.T) {190 _, err := parser.Accept(dt, `interface`)191 assert.Error(t, err)192 })193 t.Run("wrong", func(t *testing.T) {194 _, err := parser.Accept(dt, `interface{`)195 assert.Error(t, err)196 })197}198func TestDataType_Time(t *testing.T) {199 dt := func(p *api.ApiParserParser, visitor *ast.ApiVisitor) interface{} {200 return p.DataType().Accept(visitor)201 }202 t.Run("normal", func(t *testing.T) {203 _, err := parser.Accept(dt, `time.Time`)204 assert.Error(t, err)205 })206}207func TestDataType_Pointer(t *testing.T) {208 dt := func(p *api.ApiParserParser, visitor *ast.ApiVisitor) interface{} {209 return p.PointerType().Accept(visitor)210 }211 t.Run("normal", func(t *testing.T) {212 v, err := parser.Accept(dt, `*int`)213 assert.Nil(t, err)214 assert.True(t, v.(ast.DataType).Equal(&ast.Pointer{215 PointerExpr: ast.NewTextExpr("*int"),216 Star: ast.NewTextExpr("*"),217 Name: ast.NewTextExpr("int"),218 }))219 })220 t.Run("wrong", func(t *testing.T) {221 _, err := parser.Accept(dt, `int`)222 assert.Error(t, err)223 })224}225func TestAlias(t *testing.T) {226 fn := func(p *api.ApiParserParser, visitor *ast.ApiVisitor) interface{} {227 return p.TypeAlias().Accept(visitor)228 }229 t.Run("normal", func(t *testing.T) {230 _, err := parser.Accept(fn, `Foo int`)231 assert.Error(t, err)232 _, err = parser.Accept(fn, `Foo=int`)233 assert.Error(t, err)234 _, err = parser.Accept(fn, `235 Foo int // comment`)236 assert.Error(t, err)237 _, err = parser.Accept(fn, `238 Foo int /**comment*/`)239 assert.Error(t, err)240 })241 t.Run("wrong", func(t *testing.T) {242 _, err := parser.Accept(fn, `Foo var`)243 assert.Error(t, err)244 _, err = parser.Accept(fn, `Foo 2`)245 assert.Error(t, err)246 })247}248func TestTypeStruct(t *testing.T) {249 fn := func(p *api.ApiParserParser, visitor *ast.ApiVisitor) interface{} {250 return p.TypeStruct().Accept(visitor)251 }252 t.Run("normal", func(t *testing.T) {253 v, err := parser.Accept(fn, "Foo {\n\t\t\tFoo string\n\t\t\tBar int `json:\"bar\"``\n\t\t}")254 assert.Nil(t, err)255 s := v.(*ast.TypeStruct)256 assert.True(t, s.Equal(&ast.TypeStruct{257 Name: ast.NewTextExpr("Foo"),258 LBrace: ast.NewTextExpr("{"),259 RBrace: ast.NewTextExpr("}"),260 Fields: []*ast.TypeField{261 {262 Name: ast.NewTextExpr("Foo"),263 DataType: &ast.Literal{Literal: ast.NewTextExpr("string")},264 },265 {266 Name: ast.NewTextExpr("Bar"),267 DataType: &ast.Literal{Literal: ast.NewTextExpr("int")},268 Tag: ast.NewTextExpr("`json:\"bar\"`"),269 },270 },271 }))272 v, err = parser.Accept(fn, "Foo struct{\n\t\t\tFoo string\n\t\t\tBar int `json:\"bar\"``\n\t\t}")273 assert.Nil(t, err)274 s = v.(*ast.TypeStruct)275 assert.True(t, s.Equal(&ast.TypeStruct{276 Name: ast.NewTextExpr("Foo"),277 LBrace: ast.NewTextExpr("{"),278 RBrace: ast.NewTextExpr("}"),279 Struct: ast.NewTextExpr("struct"),280 Fields: []*ast.TypeField{281 {282 Name: ast.NewTextExpr("Foo"),283 DataType: &ast.Literal{Literal: ast.NewTextExpr("string")},284 },285 {286 Name: ast.NewTextExpr("Bar"),287 DataType: &ast.Literal{Literal: ast.NewTextExpr("int")},288 Tag: ast.NewTextExpr("`json:\"bar\"`"),289 },290 },291 }))292 })293}294func TestTypeBlock(t *testing.T) {295 fn := func(p *api.ApiParserParser, visitor *ast.ApiVisitor) interface{} {296 return p.TypeBlock().Accept(visitor)297 }298 t.Run("normal", func(t *testing.T) {299 _, err := parser.Accept(fn, `type(300 // doc301 Foo int302 )`)303 assert.Error(t, err)304 v, err := parser.Accept(fn, `type (305 // doc306 Foo {307 Bar int308 }309 )`)310 assert.Nil(t, err)311 st := v.([]ast.TypeExpr)312 assert.True(t, st[0].Equal(&ast.TypeStruct{313 Name: ast.NewTextExpr("Foo"),314 LBrace: ast.NewTextExpr("{"),315 RBrace: ast.NewTextExpr("}"),316 DocExpr: []ast.Expr{317 ast.NewTextExpr("// doc"),318 },319 Fields: []*ast.TypeField{320 {321 Name: ast.NewTextExpr("Bar"),322 DataType: &ast.Literal{Literal: ast.NewTextExpr("int")},323 },324 },325 }))326 })327}328func TestTypeLit(t *testing.T) {329 fn := func(p *api.ApiParserParser, visitor *ast.ApiVisitor) interface{} {330 return p.TypeLit().Accept(visitor)331 }332 t.Run("normal", func(t *testing.T) {333 _, err := parser.Accept(fn, `type Foo int`)334 assert.Error(t, err)335 _, err = parser.Accept(fn, `type Foo = int`)336 assert.Error(t, err)337 _, err = parser.Accept(fn, `338 // doc339 type Foo = int // comment`)340 assert.Error(t, err)341 v, err := parser.Accept(fn, `342 // doc343 type Foo {// comment344 Bar int345 }`)346 assert.Nil(t, err)347 st := v.(*ast.TypeStruct)348 assert.True(t, st.Equal(&ast.TypeStruct{349 Name: ast.NewTextExpr("Foo"),350 Fields: []*ast.TypeField{351 {352 Name: ast.NewTextExpr("Bar"),353 DataType: &ast.Literal{Literal: ast.NewTextExpr("int")},354 DocExpr: []ast.Expr{355 ast.NewTextExpr("// comment"),356 },357 },358 },359 DocExpr: []ast.Expr{360 ast.NewTextExpr("// doc"),361 },362 }))363 v, err = parser.Accept(fn, `364 // doc365 type Foo {// comment366 Bar367 }`)368 assert.Nil(t, err)369 st = v.(*ast.TypeStruct)370 assert.True(t, st.Equal(&ast.TypeStruct{371 Name: ast.NewTextExpr("Foo"),372 Fields: []*ast.TypeField{373 {374 IsAnonymous: true,375 DataType: &ast.Literal{Literal: ast.NewTextExpr("Bar")},376 DocExpr: []ast.Expr{377 ast.NewTextExpr("// comment"),378 },379 },380 },381 DocExpr: []ast.Expr{382 ast.NewTextExpr("// doc"),383 },384 }))385 })386 t.Run("wrong", func(t *testing.T) {387 _, err := parser.Accept(fn, `type Foo`)388 assert.Error(t, err)389 })390}391func TestTypeUnExported(t *testing.T) {392 fn := func(p *api.ApiParserParser, visitor *ast.ApiVisitor) interface{} {393 return p.TypeSpec().Accept(visitor)394 }395 t.Run("type", func(t *testing.T) {396 _, err := parser.Accept(fn, `type foo {}`)397 assert.Nil(t, err)398 })399 t.Run("field", func(t *testing.T) {400 _, err := parser.Accept(fn, `type Foo {401 name int402 }`)...

Full Screen

Full Screen

apiparser_test.go

Source:apiparser_test.go Github

copy

Full Screen

...88)89func TestApiParser(t *testing.T) {90 t.Run("missDeclarationAPI", func(t *testing.T) {91 _, err := parser.ParseContent(missDeclarationAPI)92 assert.Error(t, err)93 fmt.Printf("%+v\n", err)94 })95 t.Run("missDeclarationAPI", func(t *testing.T) {96 _, err := parser.ParseContent(missDeclarationInArrayAPI)97 assert.Error(t, err)98 fmt.Printf("%+v\n", err)99 })100 t.Run("missDeclarationAPI", func(t *testing.T) {101 _, err := parser.ParseContent(missDeclarationInArrayAPI2)102 assert.Error(t, err)103 fmt.Printf("%+v\n", err)104 })105 t.Run("nestedImport", func(t *testing.T) {106 file := filepath.Join(util.MustTempDir(), "foo.api")107 err := ioutil.WriteFile(file, []byte(nestedAPIImport), os.ModePerm)108 if err != nil {109 return110 }111 _, err = parser.ParseContent(fmt.Sprintf(`import "%s"`, file))112 assert.Error(t, err)113 fmt.Printf("%+v\n", err)114 })115 t.Run("duplicateImport", func(t *testing.T) {116 _, err := parser.ParseContent(`117 import "foo.api"118 import "foo.api"119 `)120 assert.Error(t, err)121 })122 t.Run("duplicateKey", func(t *testing.T) {123 _, err := parser.ParseContent(`124 info (125 foo: bar126 foo: bar127 )128 `)129 assert.Error(t, err)130 })131 t.Run("ambiguousSyntax", func(t *testing.T) {132 file := filepath.Join(util.MustTempDir(), "foo.api")133 err := ioutil.WriteFile(file, []byte(ambiguousSyntax), os.ModePerm)134 if err != nil {135 return136 }137 _, err = parser.ParseContent(fmt.Sprintf(`138 syntax = "v1"139 import "%s"`, file))140 assert.Error(t, err)141 fmt.Printf("%+v\n", err)142 })143 t.Run("ambiguousSyntax", func(t *testing.T) {144 file := filepath.Join(util.MustTempDir(), "foo.api")145 err := ioutil.WriteFile(file, []byte(ambiguousSyntax), os.ModePerm)146 if err != nil {147 return148 }149 _, err = parser.ParseContent(fmt.Sprintf(`150 syntax = "v1"151 import "%s"`, file))152 assert.Error(t, err)153 fmt.Printf("%+v\n", err)154 })155 t.Run("ambiguousService", func(t *testing.T) {156 file := filepath.Join(util.MustTempDir(), "foo.api")157 err := ioutil.WriteFile(file, []byte(ambiguousService), os.ModePerm)158 if err != nil {159 return160 }161 _, err = parser.ParseContent(fmt.Sprintf(`162 import "%s"163 164 service foo-api{165 @handler foo166 post /foo167 }168 `, file))169 assert.Error(t, err)170 fmt.Printf("%+v\n", err)171 })172 t.Run("duplicateHandler", func(t *testing.T) {173 _, err := parser.ParseContent(`174 service foo-api{175 @handler foo176 post /foo177 178 @handler foo179 post /bar180 }181 `)182 assert.Error(t, err)183 file := filepath.Join(util.MustTempDir(), "foo.api")184 err = ioutil.WriteFile(file, []byte(duplicateHandler), os.ModePerm)185 if err != nil {186 return187 }188 _, err = parser.ParseContent(fmt.Sprintf(`189 import "%s"190 service bar-api{191 @handler foo192 post /foo193 }194 `, file))195 assert.Error(t, err)196 fmt.Printf("%+v\n", err)197 })198 t.Run("duplicateRoute", func(t *testing.T) {199 _, err := parser.ParseContent(`200 service foo-api{201 @handler foo202 post /foo203 204 @handler bar205 post /foo206 }207 `)208 assert.Error(t, err)209 file := filepath.Join(util.MustTempDir(), "foo.api")210 err = ioutil.WriteFile(file, []byte(duplicateRoute), os.ModePerm)211 if err != nil {212 return213 }214 _, err = parser.ParseContent(fmt.Sprintf(`215 import "%s"216 service bar-api{217 @handler foo218 post /foo219 }220 `, file))221 assert.Error(t, err)222 fmt.Printf("%+v\n", err)223 })224 t.Run("duplicateType", func(t *testing.T) {225 _, err := parser.ParseContent(`226 type Foo int227 type Foo bool228 `)229 assert.Error(t, err)230 file := filepath.Join(util.MustTempDir(), "foo.api")231 err = ioutil.WriteFile(file, []byte(duplicateType), os.ModePerm)232 if err != nil {233 return234 }235 _, err = parser.ParseContent(fmt.Sprintf(`236 import "%s"237 238 type Foo bool239 `, file))240 assert.Error(t, err)241 fmt.Printf("%+v\n", err)242 })243 t.Run("normal", func(t *testing.T) {244 v, err := parser.ParseContent(normalAPI)245 assert.Nil(t, err)246 body := &ast.Body{247 Lp: ast.NewTextExpr("("),248 Rp: ast.NewTextExpr(")"),249 Name: &ast.Literal{Literal: ast.NewTextExpr("Foo")},250 }251 assert.True(t, v.Equal(&ast.Api{252 Syntax: &ast.SyntaxExpr{253 Syntax: ast.NewTextExpr("syntax"),254 Assign: ast.NewTextExpr("="),...

Full Screen

Full Screen

Error

Using AI Code Generation

copy

Full Screen

1import (2func main() {3 f, err := parser.ParseFile(fset, "1.go", nil, parser.ParseComments)4 if err != nil {5 fmt.Println(err)6 }7 ast.Print(fset, f)8}9import (10func main() {11 f, err := parser.ParseFile(fset, "1.go", nil, parser.ParseComments)12 if err != nil {13 fmt.Println(err)14 }15 ast.Print(fset, f)16}171.go:5:1: expected 'package', found 'import'181.go:8:2: expected ';', found 'func'191.go:13:1: expected ';', found '}'201.go:13:1: expected 'package', found '}'211.go:5:1: expected 'package', found 'import'221.go:8:2: expected ';', found 'func'231.go:13:1: expected ';', found '}'241.go:13:1: expected 'package', found '}'25import (26func main() {27 f, err := parser.ParseFile(fset, "1.go", nil, parser.ParseComments)28 if err != nil {29 fmt.Println(err)30 }31 ast.Print(fset, f)32}

Full Screen

Full Screen

Error

Using AI Code Generation

copy

Full Screen

1import (2func main() {3 fset := token.NewFileSet()4 f, err := parser.ParseFile(fset, "1.go", nil, 0)5 if err != nil {6 fmt.Println(err)7 }8 ast.Print(fset, f)9}

Full Screen

Full Screen

Error

Using AI Code Generation

copy

Full Screen

1import (2func main() {3import "fmt"4func main() {5 fmt.Println("Hello, 世界")6}`7 f, err := parser.ParseFile(fset, "", src, 0)8 if err != nil {9 }

Full Screen

Full Screen

Error

Using AI Code Generation

copy

Full Screen

1import (2func main() {3 f, err := parser.ParseFile(fset, "1.go", nil, parser.ImportsOnly)4 if err != nil {5 }6 for _, s := range f.Imports {7 fmt.Println(s.Path.Value)8 }9}

Full Screen

Full Screen

Error

Using AI Code Generation

copy

Full Screen

1import (2func main() {3 x := ast.NewIdent("x")4 fmt.Println(x.Error())5}6import (7func main() {8 x := ast.NewIdent("x")9 fset := token.NewFileSet()10 f := fset.AddFile("3.go", fset.Base(), 100)11 fmt.Println(x.Eval(f))12}13&{<nil> 0}14import (15func main() {16 x := ast.NewIdent("x")17 f := func(d ast.Decl) bool {18 }19 fmt.Println(x.FilterDecl(f))20}21import (22func main() {23 x := ast.NewIdent("x")24 f := func(e ast.Expr) bool {25 }26 fmt.Println(x.FilterExpr(f))27}28import (29func main() {30 x := ast.NewIdent("x")31 f := func(f *ast.Field) bool {32 }33 fmt.Println(x.FilterField(f))34}35import (

Full Screen

Full Screen

Error

Using AI Code Generation

copy

Full Screen

1import (2func main() {3 n := ast.New(nil)4 n.Add("a", "b")5 n.Add("c", "d")6 n.Add("e", "f")7 n.Add("g", "h")8 n.Add("i", "j")9 n.Add("k", "l")10 n.Add("m", "n")11 n.Add("o", "p")12 n.Add("q", "r")13 n.Add("s", "t")14 n.Add("u", "v")15 n.Add("w", "x")16 n.Add("y", "z")17 n.Add("1", "2")18 n.Add("3", "4")19 n.Add("5", "6")20 n.Add("7", "8")21 n.Add("9", "0")22 n.Add("a", "b")23 n.Add("c", "d")24 n.Add("e", "f")25 n.Add("g", "h")26 n.Add("i", "j")27 n.Add("k", "l")28 n.Add("m", "n")29 n.Add("o", "p")30 n.Add("q", "r")31 n.Add("s", "t")32 n.Add("u", "v")33 n.Add("w", "x")34 n.Add("y", "z")

Full Screen

Full Screen

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.

LambdaTest Learning Hubs:

YouTube

You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.

Run Syzkaller automation tests on LambdaTest cloud grid

Perform automation testing on 3000+ real desktop and mobile devices online.

... View sample repo... View DocumentationSign up Free
›
_

Most used method in

Try LambdaTest Now !!

Get 100 minutes of automation test minutes FREE!!

...
Sign up with GoogleSign up with Email
Next-Gen App & Browser Testing Cloud

Was this article helpful?

Helpful

NotHelpful