How to use loadPrograms method of main Package

Best Syzkaller code snippet using main.loadPrograms

execprog.go

Source:execprog.go

...53	target, err := prog.GetTarget(*flagOS, *flagArch)54	if err != nil {55		log.Fatalf("%v", err)56	}57	entries := loadPrograms(target, flag.Args())58	if len(entries) == 0 {59		return60	}61	features, err := host.Check(target)62	if err != nil {63		log.Fatalf("%v", err)64	}65	if *flagOutput {66		for _, feat := range features.Supported() {67			log.Logf(0, "%-24v: %v", feat.Name, feat.Reason)68		}69	}70	config, execOpts := createConfig(target, features, featuresFlags)71	if err = host.Setup(target, features, featuresFlags, config.Executor); err != nil {72		log.Fatal(err)73	}74	var gateCallback func()75	if features[host.FeatureLeak].Enabled {76		gateCallback = func() {77			output, err := osutil.RunCmd(10*time.Minute, "", config.Executor, "leak")78			if err != nil {79				os.Stdout.Write(output)80				os.Exit(1)81			}82		}83	}84	ctx := &Context{85		entries:  entries,86		config:   config,87		execOpts: execOpts,88		gate:     ipc.NewGate(2**flagProcs, gateCallback),89		shutdown: make(chan struct{}),90		repeat:   *flagRepeat,91	}92	var wg sync.WaitGroup93	wg.Add(*flagProcs)94	for p := 0; p < *flagProcs; p++ {95		pid := p96		go func() {97			defer wg.Done()98			ctx.run(pid)99		}()100	}101	osutil.HandleInterrupts(ctx.shutdown)102	wg.Wait()103}104type Context struct {105	entries   []*prog.LogEntry106	config    *ipc.Config107	execOpts  *ipc.ExecOpts108	gate      *ipc.Gate109	shutdown  chan struct{}110	logMu     sync.Mutex111	posMu     sync.Mutex112	repeat    int113	pos       int114	lastPrint time.Time115}116func (ctx *Context) run(pid int) {117	env, err := ipc.MakeEnv(ctx.config, pid)118	if err != nil {119		log.Fatalf("failed to create ipc env: %v", err)120	}121	defer env.Close()122	for {123		select {124		case <-ctx.shutdown:125			return126		default:127		}128		idx := ctx.getProgramIndex()129		if ctx.repeat > 0 && idx >= len(ctx.entries)*ctx.repeat {130			return131		}132		entry := ctx.entries[idx%len(ctx.entries)]133		ctx.execute(pid, env, entry)134	}135}136func (ctx *Context) execute(pid int, env *ipc.Env, entry *prog.LogEntry) {137	// Limit concurrency window.138	ticket := ctx.gate.Enter()139	defer ctx.gate.Leave(ticket)140	callOpts := ctx.execOpts141	if *flagFaultCall == -1 && entry.Fault {142		newOpts := *ctx.execOpts143		newOpts.Flags |= ipc.FlagInjectFault144		newOpts.FaultCall = entry.FaultCall145		newOpts.FaultNth = entry.FaultNth146		callOpts = &newOpts147	}148	if *flagOutput {149		ctx.logProgram(pid, entry.P, callOpts)150	}151	output, info, hanged, err := env.Exec(callOpts, entry.P)152	if ctx.config.Flags&ipc.FlagDebug != 0 || err != nil {153		log.Logf(0, "result: hanged=%v err=%v\n\n%s", hanged, err, output)154	}155	if info != nil {156		ctx.printCallResults(info)157		if *flagHints {158			ctx.printHints(entry.P, info)159		}160		if *flagCoverFile != "" {161			ctx.dumpCoverage(*flagCoverFile, info)162		}163	} else {164		log.Logf(1, "RESULT: no calls executed")165	}166}167func (ctx *Context) logProgram(pid int, p *prog.Prog, callOpts *ipc.ExecOpts) {168	strOpts := ""169	if callOpts.Flags&ipc.FlagInjectFault != 0 {170		strOpts = fmt.Sprintf(" (fault-call:%v fault-nth:%v)",171			callOpts.FaultCall, callOpts.FaultNth)172	}173	data := p.Serialize()174	ctx.logMu.Lock()175	log.Logf(0, "executing program %v%v:\n%s", pid, strOpts, data)176	ctx.logMu.Unlock()177}178func (ctx *Context) printCallResults(info *ipc.ProgInfo) {179	for i, inf := range info.Calls {180		if inf.Flags&ipc.CallExecuted == 0 {181			continue182		}183		flags := ""184		if inf.Flags&ipc.CallFinished == 0 {185			flags += " unfinished"186		}187		if inf.Flags&ipc.CallBlocked != 0 {188			flags += " blocked"189		}190		if inf.Flags&ipc.CallFaultInjected != 0 {191			flags += " faulted"192		}193		log.Logf(1, "CALL %v: signal %v, coverage %v errno %v%v",194			i, len(inf.Signal), len(inf.Cover), inf.Errno, flags)195	}196}197func (ctx *Context) printHints(p *prog.Prog, info *ipc.ProgInfo) {198	ncomps, ncandidates := 0, 0199	for i := range p.Calls {200		if *flagOutput {201			fmt.Printf("call %v:\n", i)202		}203		comps := info.Calls[i].Comps204		for v, args := range comps {205			ncomps += len(args)206			if *flagOutput {207				fmt.Printf("comp 0x%x:", v)208				for arg := range args {209					fmt.Printf(" 0x%x", arg)210				}211				fmt.Printf("\n")212			}213		}214		p.MutateWithHints(i, comps, func(p *prog.Prog) {215			ncandidates++216			if *flagOutput {217				log.Logf(1, "PROGRAM:\n%s", p.Serialize())218			}219		})220	}221	log.Logf(0, "ncomps=%v ncandidates=%v", ncomps, ncandidates)222}223func (ctx *Context) dumpCallCoverage(coverFile string, info *ipc.CallInfo) {224	if len(info.Cover) == 0 {225		return226	}227	buf := new(bytes.Buffer)228	for _, pc := range info.Cover {229		fmt.Fprintf(buf, "0x%x\n", cover.RestorePC(pc, 0xffffffff))230	}231	err := osutil.WriteFile(coverFile, buf.Bytes())232	if err != nil {233		log.Fatalf("failed to write coverage file: %v", err)234	}235}236func (ctx *Context) dumpCoverage(coverFile string, info *ipc.ProgInfo) {237	for i, inf := range info.Calls {238		log.Logf(0, "call #%v: signal %v, coverage %v", i, len(inf.Signal), len(inf.Cover))239		ctx.dumpCallCoverage(fmt.Sprintf("%v.%v", coverFile, i), &inf)240	}241	log.Logf(0, "extra: signal %v, coverage %v", len(info.Extra.Signal), len(info.Extra.Cover))242	ctx.dumpCallCoverage(fmt.Sprintf("%v.extra", coverFile), &info.Extra)243}244func (ctx *Context) getProgramIndex() int {245	ctx.posMu.Lock()246	idx := ctx.pos247	ctx.pos++248	if idx%len(ctx.entries) == 0 && time.Since(ctx.lastPrint) > 5*time.Second {249		log.Logf(0, "executed programs: %v", idx)250		ctx.lastPrint = time.Now()251	}252	ctx.posMu.Unlock()253	return idx254}255func loadPrograms(target *prog.Target, files []string) []*prog.LogEntry {256	var entries []*prog.LogEntry257	for _, fn := range files {258		data, err := ioutil.ReadFile(fn)259		if err != nil {260			log.Fatalf("failed to read log file: %v", err)261		}262		entries = append(entries, target.ParseLog(data)...)263	}264	log.Logf(0, "parsed %v programs", len(entries))265	return entries266}267func createConfig(target *prog.Target,268	features *host.Features, featuresFlags csource.Features) (269	*ipc.Config, *ipc.ExecOpts) {...

main_test.go

Source:main_test.go

...21)22//go:embed programs/*23var programsFolder embed.FS24func BenchmarkScriggo(b *testing.B) {25	programs, err := loadPrograms("go")26	if err != nil {27		b.Fatal(err)28	}29	opts := &scriggo.BuildOptions{30		Packages: native.Packages{31			"strings": native.Package{32				Name: "strings",33				Declarations: native.Declarations{34					"ContainsRune": strings.ContainsRune,35				},36			},37		},38	}39	for _, program := range programs {40		s, err := scriggo.Build(scriggo.Files{"main.go": program.Code}, opts)41		if err != nil {42			b.Fatal(err)43		}44		b.Run(program.Name, func(b *testing.B) {45			b.ReportAllocs()46			for n := 0; n < b.N; n++ {47				err := s.Run(nil)48				if err != nil {49					b.Fatal(err)50				}51			}52		})53	}54}55func BenchmarkYaegi(b *testing.B) {56	programs, err := loadPrograms("go")57	if err != nil {58		b.Fatal(err)59	}60	for _, program := range programs {61		i := interp.New(interp.Options{})62		err = i.Use(stdlib.Symbols)63		if err != nil {64			b.Fatal(err)65		}66		code := string(program.Code)67		if index := strings.LastIndex(code, "// YAEGI\n"); index > 0 {68			// This assumes that the programs do not contain multibyte utf8 characters69			code = code[index+9:]70			_, err = i.Eval(`import "strings"`)71			if err != nil {72				b.Fatal(err)73			}74		}75		b.Run(program.Name, func(b *testing.B) {76			b.ReportAllocs()77			for n := 0; n < b.N; n++ {78				_, err = i.Eval(code)79				if err != nil {80					b.Fatal(err)81				}82			}83		})84	}85}86func BenchmarkTengo(b *testing.B) {87	programs, err := loadPrograms("tengo")88	if err != nil {89		b.Fatal(err)90	}91	for _, program := range programs {92		tengoScript := tengo.NewScript(program.Code)93		var imports []string94		if bytes.Contains(program.Code, []byte(`import("text")`)) {95			imports = append(imports, "text")96		}97		if bytes.Contains(program.Code, []byte(`import("fmt")`)) {98			imports = append(imports, "fmt")99		}100		tengoScript.SetImports(tengoDtdlib.GetModuleMap(imports...))101		b.Run(program.Name, func(b *testing.B) {102			b.ReportAllocs()103			for n := 0; n < b.N; n++ {104				_, err = tengoScript.Run()105				if err != nil {106					b.Fatal(err)107				}108			}109		})110	}111}112func BenchmarkGoLua(b *testing.B) {113	programs, err := loadPrograms("lua")114	if err != nil {115		b.Fatal(err)116	}117	L := lua.NewState()118	lua.OpenLibraries(L)119	for _, program := range programs {120		b.Run(program.Name, func(b *testing.B) {121			b.ReportAllocs()122			for n := 0; n < b.N; n++ {123				err = lua.DoString(L, string(program.Code))124				if err != nil {125					b.Fatal(err)126				}127			}128		})129	}130}131func BenchmarkGopherLua(b *testing.B) {132	programs, err := loadPrograms("lua")133	if err != nil {134		b.Fatal(err)135	}136	L := gophlua.NewState()137	defer L.Close()138	for _, program := range programs {139		b.Run(program.Name, func(b *testing.B) {140			b.ReportAllocs()141			for n := 0; n < b.N; n++ {142				err = L.DoString(string(program.Code))143				if err != nil {144					b.Fatal(err)145				}146			}147		})148	}149}150func BenchmarkGoja(b *testing.B) {151	programs, err := loadPrograms("javascript")152	if err != nil {153		b.Fatal(err)154	}155	for _, program := range programs {156		b.Run(program.Name, func(b *testing.B) {157			b.ReportAllocs()158			for n := 0; n < b.N; n++ {159				vm := goja.New()160				_, err = vm.RunString(string(program.Code))161				if err != nil {162					b.Fatal(err)163				}164			}165		})166	}167}168type testFile struct {169	Name string170	Code []byte171}172var extensionOf = map[string]string{173	"go":         "go",174	"javascript": "js",175	"lua":        "lua",176	"tengo":      "tengo",177}178func loadPrograms(language string) ([]testFile, error) {179	var tests []testFile180	err := fs.WalkDir(programsFolder, "programs", func(path string, d fs.DirEntry, err error) error {181		if err != nil {182			return err183		}184		if d.IsDir() && (path != "programs" && path != "programs/"+language) {185			return fs.SkipDir186		}187		if d.IsDir() {188			return nil189		}190		if !strings.HasSuffix(d.Name(), "."+extensionOf[language]) {191			return nil192		}...

syz-serialize.go

Source:syz-serialize.go

...20	if err != nil {21		log.Fatalf("%v", err)22	}23	file := args[len(args)-1]24	entries := loadPrograms(target, file)25	unpack(entries)26}27func loadPrograms(target *prog.Target, file string) []*prog.LogEntry {28	var entries []*prog.LogEntry29	data, err := ioutil.ReadFile(file)30	if err != nil {31		log.Fatalf("failed to read log file: %v", err)32	}33	entries = append(entries, target.ParseLog(data)...)34	log.Logf(0, "parsed %v programs", len(entries))35	return entries36}37func unpack(entries []*prog.LogEntry) {38	for _, entry := range entries {39		exec := make([]byte, prog.ExecBufferSize)40		entry.P.SerializeForExec(exec)41		name := hash.String(entry.P.Serialize())...

loadPrograms

Using AI Code Generation

1func main() {2    mainObj.loadPrograms()3}4func main() {5    mainObj.loadPrograms()6}7func main() {8    mainObj.loadPrograms()9}10func main() {11    mainObj.loadPrograms()12}13func main() {14    mainObj.loadPrograms()15}16func main() {17    mainObj.loadPrograms()18}19func main() {20    mainObj.loadPrograms()21}22func main() {23    mainObj.loadPrograms()24}25func main() {26    mainObj.loadPrograms()27}28func main() {29    mainObj.loadPrograms()30}31func main() {32    mainObj.loadPrograms()33}34func main() {35    mainObj.loadPrograms()36}37func main() {38    mainObj.loadPrograms()39}40func main() {41    mainObj.loadPrograms()

loadPrograms

Using AI Code Generation

1import (2func main() {3	program := new(Program)4	program.loadPrograms()5	fmt.Println("Programs loaded successfully.")6}7import (8type Program struct {9}10func (p *Program) loadPrograms() {11	jsonFile, err := ioutil.ReadFile("programs.json")12	if err != nil {13		fmt.Println(err)14	}15	fmt.Println("Successfully Opened programs.json")16	var programs map[string]interface{}17	json.Unmarshal(jsonFile, &programs)18	fmt.Println(programs)19	fmt.Println(reflect.TypeOf(programs))20}21{22        {23        },24        {25        },26        {27        }28}29panic: interface conversion: interface {} is map[string]interface {}, not string30main.(*Program).loadPrograms(0xc0000b5f78)31main.main()32import (33type Program struct {34}35func main() {36    jsonFile, err := ioutil.ReadFile("programs.json")37    if err != nil {38        fmt.Println(err)39    }40    fmt.Println("Successfully Opened programs.json")41    var programs map[string]interface{}42    json.Unmarshal(jsonFile, &programs)43    fmt.Println(programs)44    for _, p := range programs {45        programList = append(programList, Program{Name: p.(string)})46    }47    fmt.Println(programList)48}

loadPrograms

Using AI Code Generation

1import (2func main() {3    fmt.Println("programFullPath:", programFullPath)4    if _, err := os.Stat(programFullPath); os.IsNotExist(err) {5        fmt.Println("Program does not exist")6    } else {7        fmt.Println("Program exists")8        var program string = loadProgram(programFullPath)9        fmt.Println("program:", program)10    }11}12import (13func main() {14    fmt.Println("programFullPath:", programFullPath)15    if _, err := os.Stat(programFullPath); os.IsNotExist(err) {16        fmt.Println("Program does not exist")17    } else {18        fmt.Println("Program exists")19        var program string = loadProgram(programFullPath)20        fmt.Println("program:", program)21    }22}23import (24func main() {25    fmt.Println("programFullPath:", programFullPath)26    if _, err := os.Stat(programFullPath); os.IsNotExist(err) {27        fmt.Println("Program does not exist")28    } else {29        fmt.Println("Program exists")30        var program string = loadProgram(programFullPath)31        fmt.Println("program:", program)32    }33}

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.