How to use setRef method of prog Package

Best Syzkaller code snippet using prog.setRef

types.go

Source:types.go

...90	mutate(r *randGen, s *state, arg Arg, ctx ArgCtx) (calls []*Call, retry, preserve bool)91	getMutationPrio(target *Target, arg Arg, ignoreSpecial bool) (prio float64, stopRecursion bool)92	minimize(ctx *minimizeArgsCtx, arg Arg, path string) bool93	ref() Ref94	setRef(ref Ref)95}96type Ref uint3297func (ti Ref) String() string       { panic("prog.Ref method called") }98func (ti Ref) Name() string         { panic("prog.Ref method called") }99func (ti Ref) TemplateName() string { panic("prog.Ref method called") }100func (ti Ref) Optional() bool                                        { panic("prog.Ref method called") }101func (ti Ref) Varlen() bool                                          { panic("prog.Ref method called") }102func (ti Ref) Size() uint64                                          { panic("prog.Ref method called") }103func (ti Ref) TypeBitSize() uint64                                   { panic("prog.Ref method called") }104func (ti Ref) Format() BinaryFormat                                  { panic("prog.Ref method called") }105func (ti Ref) BitfieldOffset() uint64                                { panic("prog.Ref method called") }106func (ti Ref) BitfieldLength() uint64                                { panic("prog.Ref method called") }107func (ti Ref) IsBitfield() bool                                      { panic("prog.Ref method called") }108func (ti Ref) UnitSize() uint64                                      { panic("prog.Ref method called") }109func (ti Ref) UnitOffset() uint64                                    { panic("prog.Ref method called") }110func (ti Ref) DefaultArg(dir Dir) Arg                                { panic("prog.Ref method called") }111func (ti Ref) Clone() Type                                           { panic("prog.Ref method called") }112func (ti Ref) isDefaultArg(arg Arg) bool                             { panic("prog.Ref method called") }113func (ti Ref) generate(r *randGen, s *state, dir Dir) (Arg, []*Call) { panic("prog.Ref method called") }114func (ti Ref) mutate(r *randGen, s *state, arg Arg, ctx ArgCtx) ([]*Call, bool, bool) {115	panic("prog.Ref method called")116}117func (ti Ref) getMutationPrio(target *Target, arg Arg, ignoreSpecial bool) (float64, bool) {118	panic("prog.Ref method called")119}120func (ti Ref) minimize(ctx *minimizeArgsCtx, arg Arg, path string) bool {121	panic("prog.Ref method called")122}123func (ti Ref) ref() Ref       { panic("prog.Ref method called") }124func (ti Ref) setRef(ref Ref) { panic("prog.Ref method called") }125func IsPad(t Type) bool {126	if ct, ok := t.(*ConstType); ok && ct.IsPad {127		return true128	}129	return false130}131type TypeCommon struct {132	TypeName string133	// Static size of the type, or 0 for variable size types and all but last bitfields in the group.134	TypeSize   uint64135	IsOptional bool136	IsVarlen   bool137	self Ref138}139func (t *TypeCommon) Name() string {140	return t.TypeName141}142func (t *TypeCommon) TemplateName() string {143	name := t.TypeName144	if pos := strings.IndexByte(name, '['); pos != -1 {145		name = name[:pos]146	}147	return name148}149func (t *TypeCommon) Optional() bool {150	return t.IsOptional151}152func (t *TypeCommon) Size() uint64 {153	if t.IsVarlen {154		panic(fmt.Sprintf("static type size is not known: %#v", t))155	}156	return t.TypeSize157}158func (t *TypeCommon) TypeBitSize() uint64 {159	panic("cannot get the bitsize for a non-integer type")160}161func (t *TypeCommon) Varlen() bool {162	return t.IsVarlen163}164func (t *TypeCommon) Format() BinaryFormat {165	return FormatNative166}167func (t *TypeCommon) BitfieldOffset() uint64 {168	return 0169}170func (t *TypeCommon) BitfieldLength() uint64 {171	return 0172}173func (t *TypeCommon) UnitSize() uint64 {174	return t.Size()175}176func (t *TypeCommon) UnitOffset() uint64 {177	return 0178}179func (t *TypeCommon) IsBitfield() bool {180	return false181}182func (t *TypeCommon) ref() Ref {183	if t.self == 0 {184		panic("ref is not assigned yet")185	}186	return t.self187}188func (t *TypeCommon) setRef(ref Ref) {189	t.self = ref190}191type ResourceDesc struct {192	Name   string193	Kind   []string194	Values []uint64195	Ctors  []ResourceCtor196}197type ResourceCtor struct {198	Call    int // Index in Target.Syscalls199	Precise bool200}201type ResourceType struct {202	TypeCommon...

infer_test.go

Source:infer_test.go

1package infer2import (3	"dandelion/ast"4	"dandelion/types"5	"fmt"6	"strings"7	"testing"8)9//func TestInfer(t *testing.T) {10//	src := `11//a = 1;12//b = a + 4;13//`14//15//	progAst := parser.ParseProgram(src)16//	InferTypes(progAst.Funcs["main"])17//}18func TestViralVarReplacement(t *testing.T) {19	i := NewInferer()20	root := i.NewVar()21	left := i.NewVar()22	right := i.NewVar()23	i.SetRef(left, right)24	i.SetRef(left, root)25	v := i.NewVar()26	i.SetRef(left, v)27	lastV := i.Resolve(v)28	if i.Resolve(root) == lastV && i.Resolve(left) == lastV && i.Resolve(right) == lastV {29	} else {30		t.Fail()31	}32}33func TestViralReplacementBaseAndVar(t *testing.T) {34	i := NewInferer()35	base := i.BaseRef(TypeBase{types.IntType{}})36	root := i.NewVar()37	left := i.NewVar()38	right := i.NewVar()39	i.SetRef(left, root)40	i.SetRef(right, left)41	i.SetRef(right, base)42	lastV := i.Resolve(base)43	if i.Resolve(root) == lastV && i.Resolve(left) == lastV && i.Resolve(right) == lastV {44	} else {45		t.Fail()46	}47}48func TestViralReplacementFunc(t *testing.T) {49	i := NewInferer()50	t1 := i.NewVar()51	t2 := i.NewVar()52	t3 := i.NewVar()53	base := i.BaseRef(TypeBase{types.IntType{}})54	fun := i.FuncRef(KindFunc, t1, t2, t3)55	fun2 := i.FuncRef(KindFunc, t1, t2)56	i.SetRef(t1, base)57	i.SetRef(t3, fun2)58	fmt.Println(i.String(fun))59	if i.String(fun) != "(t2, (t2) -> <int>) -> <int>" {60		t.Fail()61	}62}63func TestTypeFuncContainsSimple(t *testing.T) {64	i := NewInferer()65	t1 := i.NewVar()66	t2 := i.NewVar()67	t3 := i.NewVar()68	fun := i.FuncRef(KindFunc, t1, t2, t3)69	if !i.Contains(i.Resolve(fun).(TypeFunc), t3) || !i.Contains(i.Resolve(fun).(TypeFunc), t1) {70		t.Fail()71	}72}73func TestTypeFuncContainsComplex(t *testing.T) {74	i := NewInferer()75	t1 := i.NewVar()76	t2 := i.NewVar()77	t3 := i.NewVar()78	t4 := i.NewVar()79	t5 := i.NewVar()80	t6 := i.NewVar()81	fun := i.FuncRef(KindFunc, t1, t2, t3)82	fun2 := i.FuncRef(KindFunc, t4, t5, t6)83	i.SetRef(t3, fun2)84	if !i.Contains(i.Resolve(fun).(TypeFunc), t4) || !i.Contains(i.Resolve(fun).(TypeFunc), t6) {85		t.Fail()86	}87}88func TestViralReplaceFuncsPanic(t *testing.T) {89	i := NewInferer()90	t1 := i.NewVar()91	t2 := i.NewVar()92	t3 := i.NewVar()93	t4 := i.NewVar()94	fun := i.FuncRef(KindFunc, t1, t2)95	fun2 := i.FuncRef(KindFunc, t3, t4)96	unrelatedFun := i.FuncRef(KindFunc, t1, t2, t3, t4)97	i.SetRef(fun, fun2)98	defer func() {99		r := recover()100		if r != nil && strings.Contains(r.(string), "replacement would result in recursive overflow") {101			fmt.Println("recovered: ", r)102			return103		}104		t.Fail()105	}()106	i.SetRef(t3, unrelatedFun)107}108func TestSameReplacement(t *testing.T) {109	i := NewInferer()110	t1 := i.NewVar()111	t2 := i.NewVar()112	i.SetRef(t1, t1)113	i.SetRef(t1, t2)114	if i.String(t1) != "t2" {115		t.Fail()116	}117}118func TestReplacement(t *testing.T) {119	i := NewInferer()120	fun := &ast.FunDef{}121	genRef := i.TypeRef(fun)122	funRef := i.FuncRef(KindFunc, i.NewVar())123	fmt.Println(i.String(genRef))124	fmt.Println(i.String(funRef))125	fmt.Println(i.varLibrary)126}127func TestReplaceFunc(t *testing.T) {128	i := NewInferer()129	funRef := i.FuncRef(KindTupleAccess, i.NewVar())130	t3 := i.NewVar()131	t4 := i.NewVar()132	i.SetRef(t3, funRef)133	i.SetRef(funRef, t4)134	if !stringsEqual(i.String(t3), i.String(t4), i.String(funRef)) {135		t.Fail()136	}137}138func TestFuncMeta(t *testing.T) {139	i := NewInferer()140	t1 := i.NewVar()141	meta := i.FuncMeta(45)142	funRef := i.FuncRef(KindTupleAccess, meta, i.NewVar())143	i.SetRef(funRef, t1)144	fmt.Println(i.String(t1), i.String(funRef), i.String(meta))145}146func TestReplaceTwoFunc(t *testing.T) {147	i := NewInferer()148	t1 := i.NewVar()149	fun1 := i.FuncRef(KindTupleAccess, i.NewVar(), i.NewVar())150	fun2 := i.FuncRef(KindArray, i.NewVar(), i.NewVar())151	i.SetRef(t1, fun1)152	i.SetRef(t1, fun2)153	if !stringsEqual(i.String(t1), i.String(fun1), i.String(fun2)) {154		t.Fail()155	}156}157func stringsEqual(strs... string) bool {158	str1 := strs[0]159	for _, str := range strs[1:] {160		if str != str1 {161			return false162		}163	}164	return true165}...

prog_test.go

Source:prog_test.go

1package exp_test2import (3	"strings"4	"testing"5	"xelf.org/xelf/exp"6	"xelf.org/xelf/lib/extlib"7	"xelf.org/xelf/lit"8	"xelf.org/xelf/typ"9)10type Point struct{ X, Y int }11func TestProgEval(t *testing.T) {12	tests := []struct {13		raw  string14		want string15	}{16		{`(@test.point {})`, `{x:0 y:0}`},17		{`(dot {a:[{b:2}]} .a.0.b)`, `2`},18		{`(dot {a:[{b:2}, {b:3}]} .a/b)`, `[2 3]`},19		{`(dot {a:'2021-08-19T15:00:00Z'} (month .a))`, `8`},20		{`(dyn (month $now))`, `8`},21	}22	reg := &lit.Reg{}23	mut := reg.MustProxy(&Point{})24	reg.SetRef("test.point", mut.Type(), mut)25	env := &exp.ArgEnv{Par: extlib.Std, Typ: typ.Dict, Val: &lit.Dict{Reg: reg, Keyed: []lit.KeyVal{26		{Key: "now", Val: lit.Str("2021-08-19T15:00:00Z")},27	}}}28	for _, test := range tests {29		got, err := exp.Eval(nil, reg, env, test.raw)30		if err != nil {31			t.Errorf("eval %s failed: %v", test.raw, err)32			continue33		}34		str := got.String()35		if str != test.want {36			t.Errorf("eval %s want res %s got %s", test.raw, test.want, str)37		}38	}39}40func TestProgResl(t *testing.T) {41	tests := []struct {42		raw  string43		want string44		sig  string45	}{46		{`(if true 1 2)`, `<num@1>`,47			`<form if <tupl cond:any act:exp|num@1> else:exp?|num@1 num@1>`},48		{`(if true "one")`, `<char@1>`,49			`<form if <tupl cond:any act:exp|char@1> else:exp?|char@1 char@1>`},50		{`(make @test.point {})`, `<obj exp_test.Point>`, ``},51	}52	reg := &lit.Reg{}53	mut := reg.MustProxy(&Point{})54	reg.SetRef("test.point", mut.Type(), mut)55	for _, test := range tests {56		e, err := exp.Read(reg, strings.NewReader(test.raw), "test")57		if err != nil {58			t.Errorf("read %s failed: %v", test.raw, err)59			continue60		}61		p := exp.NewProg(nil, reg, extlib.Std, e)62		got, err := p.Resl(p.Root, p.Exp, typ.Void)63		if err != nil {64			t.Errorf("resl %s failed: %v", test.raw, err)65			continue66		}67		ts := got.Resl().String()68		if ts != test.want {69			t.Errorf("resl %s want res %s got %s", test.raw, test.want, ts)70		}71		if test.sig == "" {72			continue73		}74		c, ok := got.(*exp.Call)75		if !ok {76			t.Errorf("resl %s want call got %T", test.raw, got)77		}78		ss := c.Sig.String()79		if ss != test.sig {80			t.Errorf("resl %s want sig %s got %s", test.raw, test.sig, ss)81		}82	}83}...

setRef

Using AI Code Generation

1import (2type prog struct {3}4func (p *prog) setRef(ref string) {5}6func (p *prog) getRef() string {7}8func main() {9	p1 := prog{10	}11	p1.setRef("Golang")12	fmt.Println("Path:", p1.getRef())13	p2 := prog{14	}15	p2.setRef("C++11")16	fmt.Println("Path:", p2.getRef())17	p3 := prog{18	}19	p3.setRef("Java8")20	fmt.Println("Path:", p3.getRef())21}22import (23type prog struct {24}25func (p *prog) setRef(ref string) {26}27func (p *prog) getRef() string {28}29type web struct {30}31func (w *web) setRef(ref string) {32}33func (w *web) getRef() string {34}35func main() {36	w1 := web{37		prog: prog{38		},39	}40	w1.setRef("Golang")41	fmt.Println("Path:", w1.getRef())

setRef

Using AI Code Generation

1import "fmt"2func main() {3    fmt.Printf("Address of a variable: %x4    fmt.Printf("Address stored in ip variable: %x5    fmt.Printf("Value of *ip variable: %d6}7The value of a pointer to a pointer is the address of the pointer to the variable. To get the value of a pointer to a pointer, we must use the indirection operator ( * ) twice. For example,8fmt.Printf("Value of a = %d9fmt.Printf("Value available at *ptr = %d10fmt.Printf("Value available at **pptr = %d

setRef

Using AI Code Generation

1import (2type Prog struct {3}4func (p *Prog) setRef(i int) {5}6func main() {7	p := new(Prog)8	fmt.Println(p.ref)9	p.setRef(10)10	fmt.Println(p.ref)11}12import (13type Prog struct {14}15func (p Prog) setRef(i int) {16}17func main() {18	p := new(Prog)19	fmt.Println(p.ref)20	p.setRef(10)21	fmt.Println(p.ref)22}

setRef

Using AI Code Generation

1import (2type prog struct {3}4func main() {5	p1 := prog{"Naveen", 50}6	p2 := prog{"Praveen", 40}7	p1.setRef(&p2)8	fmt.Println(p1)9	fmt.Println(p2)10}11func (p prog) setRef(p2 *prog) {12}13import (14type prog struct {15}16func main() {17	p1 := prog{"Naveen", 50}18	p2 := prog{"Praveen", 40}19	p1.setRef(&p2)20	fmt.Println(p1)21	fmt.Println(p2)22}23func (p *prog) setRef(p2 *prog) {24}25import (26type prog struct {27}28func main() {29	p1 := prog{"Naveen", 50}30	p2 := prog{"Praveen", 40}31	p1.setRef(&p2)32	fmt.Println(p1)33	fmt.Println(p2)34}35func (p *prog) setRef(p2 *prog) {36}

setRef

Using AI Code Generation

1import (2func main() {3	p := prog.Prog{}4	p.SetRef(10)5	fmt.Println(p.GetRef())6}7type Prog struct {8}9func (p *Prog) SetRef(v int) {10}11func (p *Prog) GetRef() int {12}

setRef

Using AI Code Generation

1import "fmt"2func main() {3    a.setRef(10)4    fmt.Println(a.getRef())5}6type prog struct {7}8func (p *prog) setRef(i int) {9}10func (p prog) getRef() int {11}

setRef

Using AI Code Generation

1import (2func main() {3 p.setRef(10)4 fmt.Println(p.i)5}6type prog struct {7}8func (p *prog) setRef(i int) {9}

setRef

Using AI Code Generation

1import "fmt"2func main() {3    p.setRef(5)4    fmt.Println(p.getRef())5}6type prog struct {7}8func (p *prog) setRef(i int) {9}10func (p prog) getRef() int {11}

setRef

Using AI Code Generation

1import (2func main() {3	p := prog.New()4	p.SetRef(1)5	fmt.Println(p.Ref())6}7import "fmt"8type Prog struct {9}10func New() *Prog {11	return &Prog{}12}13func (p *Prog) SetRef(ref int) {14}15func (p *Prog) Ref() int {16}17import (18func TestSetRef(t *testing.T) {19	p := New()20	p.SetRef(1)21	if p.Ref() != 1 {22		t.Errorf("Expected 1, got %d", p.Ref())23	}24}25func ExampleSetRef() {26	p := New()27	p.SetRef(1)28	fmt.Println(p.Ref())29}30func ExampleRef() {31	p := New()32	p.SetRef(1)33	fmt.Println(p.Ref())34}35func ExampleNew() {36	p := New()37	p.SetRef(1)38	fmt.Println(p.Ref())39}40func BenchmarkSetRef(b *testing.B) {41	p := New()42	for i := 0; i < b.N; i++ {43		p.SetRef(1)44	}45}46func BenchmarkRef(b *testing.B) {47	p := New()48	for i := 0; i < b.N; i++ {49		p.Ref()50	}51}52func BenchmarkNew(b *testing.B) {53	for i := 0; i < b.N; i++ {54		New()55	}56}57import "fmt"58type Prog struct {59}60func New() *Prog {61	return &Prog{}62}

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.