How to use parseOutputType method of main Package

Best Syzkaller code snippet using main.parseOutputType

fuzzer.go

Source:fuzzer.go

...101		flagTest    = flag.Bool("test", false, "enable image testing mode")      // used by syz-ci102		flagRunTest = flag.Bool("runtest", false, "enable program testing mode") // used by pkg/runtest103	)104	flag.Parse()105	outputType := parseOutputType(*flagOutput)106	log.Logf(0, "fuzzer started")107	target, err := prog.GetTarget(*flagOS, *flagArch)108	if err != nil {109		log.Fatalf("%v", err)110	}111	config, execOpts, err := ipcconfig.Default(target)112	if err != nil {113		log.Fatalf("failed to create default ipc config: %v", err)114	}115	sandbox := ipc.FlagsToSandbox(config.Flags)116	shutdown := make(chan struct{})117	osutil.HandleInterrupts(shutdown)118	go func() {119		// Handles graceful preemption on GCE.120		<-shutdown121		log.Logf(0, "SYZ-FUZZER: PREEMPTED")122		os.Exit(1)123	}()124	checkArgs := &checkArgs{125		target:      target,126		sandbox:     sandbox,127		ipcConfig:   config,128		ipcExecOpts: execOpts,129	}130	if *flagTest {131		testImage(*flagManager, checkArgs)132		return133	}134	if *flagPprof != "" {135		go func() {136			err := http.ListenAndServe(*flagPprof, nil)137			log.Fatalf("failed to serve pprof profiles: %v", err)138		}()139	} else {140		runtime.MemProfileRate = 0141	}142	log.Logf(0, "dialing manager at %v", *flagManager)143	manager, err := rpctype.NewRPCClient(*flagManager)144	if err != nil {145		log.Fatalf("failed to connect to manager: %v ", err)146	}147	log.Logf(1, "connecting to manager...")148	a := &rpctype.ConnectArgs{Name: *flagName}149	r := &rpctype.ConnectRes{}150	if err := manager.Call("Manager.Connect", a, r); err != nil {151		log.Fatalf("failed to connect to manager: %v ", err)152	}153	featureFlags, err := csource.ParseFeaturesFlags("none", "none", true)154	if err != nil {155		log.Fatal(err)156	}157	if r.CheckResult == nil {158		checkArgs.gitRevision = r.GitRevision159		checkArgs.targetRevision = r.TargetRevision160		checkArgs.enabledCalls = r.EnabledCalls161		checkArgs.allSandboxes = r.AllSandboxes162		checkArgs.featureFlags = featureFlags163		r.CheckResult, err = checkMachine(checkArgs)164		if err != nil {165			if r.CheckResult == nil {166				r.CheckResult = new(rpctype.CheckArgs)167			}168			r.CheckResult.Error = err.Error()169		}170		r.CheckResult.Name = *flagName171		if err := manager.Call("Manager.Check", r.CheckResult, nil); err != nil {172			log.Fatalf("Manager.Check call failed: %v", err)173		}174		if r.CheckResult.Error != "" {175			log.Fatalf("%v", r.CheckResult.Error)176		}177	} else {178		if err = host.Setup(target, r.CheckResult.Features, featureFlags, config.Executor); err != nil {179			log.Fatal(err)180		}181	}182	log.Logf(0, "syscalls: %v", len(r.CheckResult.EnabledCalls[sandbox]))183	for _, feat := range r.CheckResult.Features.Supported() {184		log.Logf(0, "%v: %v", feat.Name, feat.Reason)185	}186	if r.CheckResult.Features[host.FeatureExtraCoverage].Enabled {187		config.Flags |= ipc.FlagExtraCover188	}189	if r.CheckResult.Features[host.FeatureNetInjection].Enabled {190		config.Flags |= ipc.FlagEnableTun191	}192	if r.CheckResult.Features[host.FeatureNetDevices].Enabled {193		config.Flags |= ipc.FlagEnableNetDev194	}195	config.Flags |= ipc.FlagEnableNetReset196	config.Flags |= ipc.FlagEnableCgroups197	config.Flags |= ipc.FlagEnableCloseFds198	if r.CheckResult.Features[host.FeatureDevlinkPCI].Enabled {199		config.Flags |= ipc.FlagEnableDevlinkPCI200	}201	if *flagRunTest {202		runTest(target, manager, *flagName, config.Executor)203		return204	}205	needPoll := make(chan struct{}, 1)206	needPoll <- struct{}{}207	fuzzer := &Fuzzer{208		name:                     *flagName,209		outputType:               outputType,210		config:                   config,211		execOpts:                 execOpts,212		workQueue:                newWorkQueue(*flagProcs, needPoll),213		needPoll:                 needPoll,214		manager:                  manager,215		target:                   target,216		faultInjectionEnabled:    r.CheckResult.Features[host.FeatureFault].Enabled,217		comparisonTracingEnabled: r.CheckResult.Features[host.FeatureComparisons].Enabled,218		corpusHashes:             make(map[hash.Sig]struct{}),219	}220	gateCallback := fuzzer.useBugFrames(r, *flagProcs)221	fuzzer.gate = ipc.NewGate(2**flagProcs, gateCallback)222	for i := 0; fuzzer.poll(i == 0, nil); i++ {223	}224	calls := make(map[*prog.Syscall]bool)225	for _, id := range r.CheckResult.EnabledCalls[sandbox] {226		calls[target.Syscalls[id]] = true227	}228	fuzzer.choiceTable = target.BuildChoiceTable(fuzzer.corpus, calls)229	for pid := 0; pid < *flagProcs; pid++ {230		proc, err := newProc(fuzzer, pid)231		if err != nil {232			log.Fatalf("failed to create proc: %v", err)233		}234		fuzzer.procs = append(fuzzer.procs, proc)235		go proc.loop()236	}237	fuzzer.pollLoop()238}239// Returns gateCallback for leak checking if enabled.240func (fuzzer *Fuzzer) useBugFrames(r *rpctype.ConnectRes, flagProcs int) func() {241	var gateCallback func()242	if r.CheckResult.Features[host.FeatureLeak].Enabled {243		gateCallback = func() { fuzzer.gateCallback(r.MemoryLeakFrames) }244	}245	if r.CheckResult.Features[host.FeatureKCSAN].Enabled && len(r.DataRaceFrames) != 0 {246		fuzzer.filterDataRaceFrames(r.DataRaceFrames)247	}248	return gateCallback249}250func (fuzzer *Fuzzer) gateCallback(leakFrames []string) {251	// Leak checking is very slow so we don't do it while triaging the corpus252	// (otherwise it takes infinity). When we have presumably triaged the corpus253	// (triagedCandidates == 1), we run leak checking bug ignore the result254	// to flush any previous leaks. After that (triagedCandidates == 2)255	// we do actual leak checking and report leaks.256	triagedCandidates := atomic.LoadUint32(&fuzzer.triagedCandidates)257	if triagedCandidates == 0 {258		return259	}260	args := append([]string{"leak"}, leakFrames...)261	output, err := osutil.RunCmd(10*time.Minute, "", fuzzer.config.Executor, args...)262	if err != nil && triagedCandidates == 2 {263		// If we exit right away, dying executors will dump lots of garbage to console.264		os.Stdout.Write(output)265		fmt.Printf("BUG: leak checking failed")266		time.Sleep(time.Hour)267		os.Exit(1)268	}269	if triagedCandidates == 1 {270		atomic.StoreUint32(&fuzzer.triagedCandidates, 2)271	}272}273func (fuzzer *Fuzzer) filterDataRaceFrames(frames []string) {274	args := append([]string{"setup_kcsan_filterlist"}, frames...)275	output, err := osutil.RunCmd(10*time.Minute, "", fuzzer.config.Executor, args...)276	if err != nil {277		log.Fatalf("failed to set KCSAN filterlist: %v", err)278	}279	log.Logf(0, "%s", output)280}281func (fuzzer *Fuzzer) pollLoop() {282	var execTotal uint64283	var lastPoll time.Time284	var lastPrint time.Time285	ticker := time.NewTicker(3 * time.Second).C286	for {287		poll := false288		select {289		case <-ticker:290		case <-fuzzer.needPoll:291			poll = true292		}293		if fuzzer.outputType != OutputStdout && time.Since(lastPrint) > 10*time.Second {294			// Keep-alive for manager.295			log.Logf(0, "alive, executed %v", execTotal)296			lastPrint = time.Now()297		}298		if poll || time.Since(lastPoll) > 10*time.Second {299			needCandidates := fuzzer.workQueue.wantCandidates()300			if poll && !needCandidates {301				continue302			}303			stats := make(map[string]uint64)304			for _, proc := range fuzzer.procs {305				stats["exec total"] += atomic.SwapUint64(&proc.env.StatExecs, 0)306				stats["executor restarts"] += atomic.SwapUint64(&proc.env.StatRestarts, 0)307			}308			for stat := Stat(0); stat < StatCount; stat++ {309				v := atomic.SwapUint64(&fuzzer.stats[stat], 0)310				stats[statNames[stat]] = v311				execTotal += v312			}313			if !fuzzer.poll(needCandidates, stats) {314				lastPoll = time.Now()315			}316		}317	}318}319func (fuzzer *Fuzzer) poll(needCandidates bool, stats map[string]uint64) bool {320	a := &rpctype.PollArgs{321		Name:           fuzzer.name,322		NeedCandidates: needCandidates,323		MaxSignal:      fuzzer.grabNewSignal().Serialize(),324		Stats:          stats,325	}326	r := &rpctype.PollRes{}327	if err := fuzzer.manager.Call("Manager.Poll", a, r); err != nil {328		log.Fatalf("Manager.Poll call failed: %v", err)329	}330	maxSignal := r.MaxSignal.Deserialize()331	log.Logf(1, "poll: candidates=%v inputs=%v signal=%v",332		len(r.Candidates), len(r.NewInputs), maxSignal.Len())333	fuzzer.addMaxSignal(maxSignal)334	for _, inp := range r.NewInputs {335		fuzzer.addInputFromAnotherFuzzer(inp)336	}337	for _, candidate := range r.Candidates {338		fuzzer.addCandidateInput(candidate)339	}340	if needCandidates && len(r.Candidates) == 0 && atomic.LoadUint32(&fuzzer.triagedCandidates) == 0 {341		atomic.StoreUint32(&fuzzer.triagedCandidates, 1)342	}343	return len(r.NewInputs) != 0 || len(r.Candidates) != 0 || maxSignal.Len() != 0344}345func (fuzzer *Fuzzer) sendInputToManager(inp rpctype.RPCInput) {346	a := &rpctype.NewInputArgs{347		Name:     fuzzer.name,348		RPCInput: inp,349	}350	if err := fuzzer.manager.Call("Manager.NewInput", a, nil); err != nil {351		log.Fatalf("Manager.NewInput call failed: %v", err)352	}353}354func (fuzzer *Fuzzer) addInputFromAnotherFuzzer(inp rpctype.RPCInput) {355	p := fuzzer.deserializeInput(inp.Prog)356	if p == nil {357		return358	}359	sig := hash.Hash(inp.Prog)360	sign := inp.Signal.Deserialize()361	fuzzer.addInputToCorpus(p, sign, sig)362}363func (fuzzer *Fuzzer) addCandidateInput(candidate rpctype.RPCCandidate) {364	p := fuzzer.deserializeInput(candidate.Prog)365	if p == nil {366		return367	}368	flags := ProgCandidate369	if candidate.Minimized {370		flags |= ProgMinimized371	}372	if candidate.Smashed {373		flags |= ProgSmashed374	}375	fuzzer.workQueue.enqueue(&WorkCandidate{376		p:     p,377		flags: flags,378	})379}380func (fuzzer *Fuzzer) deserializeInput(inp []byte) *prog.Prog {381	p, err := fuzzer.target.Deserialize(inp, prog.NonStrict)382	if err != nil {383		log.Fatalf("failed to deserialize prog: %v\n%s", err, inp)384	}385	if len(p.Calls) > prog.MaxCalls {386		return nil387	}388	return p389}390func (fuzzer *FuzzerSnapshot) chooseProgram(r *rand.Rand) *prog.Prog {391	randVal := r.Int63n(fuzzer.sumPrios + 1)392	idx := sort.Search(len(fuzzer.corpusPrios), func(i int) bool {393		return fuzzer.corpusPrios[i] >= randVal394	})395	return fuzzer.corpus[idx]396}397func (fuzzer *Fuzzer) addInputToCorpus(p *prog.Prog, sign signal.Signal, sig hash.Sig) {398	fuzzer.corpusMu.Lock()399	if _, ok := fuzzer.corpusHashes[sig]; !ok {400		fuzzer.corpus = append(fuzzer.corpus, p)401		fuzzer.corpusHashes[sig] = struct{}{}402		prio := int64(len(sign))403		if sign.Empty() {404			prio = 1405		}406		fuzzer.sumPrios += prio407		fuzzer.corpusPrios = append(fuzzer.corpusPrios, fuzzer.sumPrios)408	}409	fuzzer.corpusMu.Unlock()410	if !sign.Empty() {411		fuzzer.signalMu.Lock()412		fuzzer.corpusSignal.Merge(sign)413		fuzzer.maxSignal.Merge(sign)414		fuzzer.signalMu.Unlock()415	}416}417func (fuzzer *Fuzzer) snapshot() FuzzerSnapshot {418	fuzzer.corpusMu.RLock()419	defer fuzzer.corpusMu.RUnlock()420	return FuzzerSnapshot{fuzzer.corpus, fuzzer.corpusPrios, fuzzer.sumPrios}421}422func (fuzzer *Fuzzer) addMaxSignal(sign signal.Signal) {423	if sign.Len() == 0 {424		return425	}426	fuzzer.signalMu.Lock()427	defer fuzzer.signalMu.Unlock()428	fuzzer.maxSignal.Merge(sign)429}430func (fuzzer *Fuzzer) grabNewSignal() signal.Signal {431	fuzzer.signalMu.Lock()432	defer fuzzer.signalMu.Unlock()433	sign := fuzzer.newSignal434	if sign.Empty() {435		return nil436	}437	fuzzer.newSignal = nil438	return sign439}440func (fuzzer *Fuzzer) corpusSignalDiff(sign signal.Signal) signal.Signal {441	fuzzer.signalMu.RLock()442	defer fuzzer.signalMu.RUnlock()443	return fuzzer.corpusSignal.Diff(sign)444}445func (fuzzer *Fuzzer) checkNewSignal(p *prog.Prog, info *ipc.ProgInfo) (calls []int, extra bool) {446	fuzzer.signalMu.RLock()447	defer fuzzer.signalMu.RUnlock()448	for i, inf := range info.Calls {449		if fuzzer.checkNewCallSignal(p, &inf, i) {450			calls = append(calls, i)451		}452	}453	extra = fuzzer.checkNewCallSignal(p, &info.Extra, -1)454	return455}456func (fuzzer *Fuzzer) checkNewCallSignal(p *prog.Prog, info *ipc.CallInfo, call int) bool {457	diff := fuzzer.maxSignal.DiffRaw(info.Signal, signalPrio(p, info, call))458	if diff.Empty() {459		return false460	}461	fuzzer.signalMu.RUnlock()462	fuzzer.signalMu.Lock()463	fuzzer.maxSignal.Merge(diff)464	fuzzer.newSignal.Merge(diff)465	fuzzer.signalMu.Unlock()466	fuzzer.signalMu.RLock()467	return true468}469func signalPrio(p *prog.Prog, info *ipc.CallInfo, call int) (prio uint8) {470	if call == -1 {471		return 0472	}473	if info.Errno == 0 {474		prio |= 1 << 1475	}476	if !p.Target.CallContainsAny(p.Calls[call]) {477		prio |= 1 << 0478	}479	return480}481func parseOutputType(str string) OutputType {482	switch str {483	case "none":484		return OutputNone485	case "stdout":486		return OutputStdout487	case "dmesg":488		return OutputDmesg489	case "file":490		return OutputFile491	default:492		log.Fatalf("-output flag must be one of none/stdout/dmesg/file")493		return OutputNone494	}495}...

main.go

Source:main.go

1package main2import (3	"fmt"4	"io/ioutil"5	"os"6	"path/filepath"7	"strings"8	"time"9	"gopkg.in/alecthomas/kingpin.v2"10	"github.com/ark-lang/ark/src/ast"11	"github.com/ark-lang/ark/src/codegen"12	"github.com/ark-lang/ark/src/codegen/LLVMCodegen"13	"github.com/ark-lang/ark/src/doc"14	"github.com/ark-lang/ark/src/lexer"15	"github.com/ark-lang/ark/src/parser"16	"github.com/ark-lang/ark/src/semantic"17	"github.com/ark-lang/ark/src/util"18	"github.com/ark-lang/ark/src/util/log"19)20const (21	VERSION = "0.0.2"22	AUTHOR  = "The Ark Authors"23)24var startTime time.Time25func main() {26	startTime = time.Now()27	command := kingpin.MustParse(app.Parse(os.Args[1:]))28	log.SetLevel(*logLevel)29	log.SetTags(*logTags)30	context := NewContext()31	switch command {32	case buildCom.FullCommand():33		if *buildInput == "" {34			setupErr("No input files passed.")35		}36		context.Searchpaths = *buildSearchpaths37		context.Input = *buildInput38		outputType, err := codegen.ParseOutputType(*buildOutputType)39		if err != nil {40			fmt.Println(err)41			os.Exit(1)42		}43		// build the files44		context.Build(*buildOutput, outputType, *buildCodegen, *buildOptLevel)45		printFinishedMessage(startTime, buildCom.FullCommand(), 1)46	case docgenCom.FullCommand():47		context.Searchpaths = *docgenSearchpaths48		context.Input = *docgenInput49		context.Docgen(*docgenDir)50		printFinishedMessage(startTime, docgenCom.FullCommand(), 1)51	}52}53func printFinishedMessage(startTime time.Time, command string, numFiles int) {54	dur := time.Since(startTime)55	log.Info("main", "%s (%d file(s), %.2fms)\n",56		util.TEXT_GREEN+util.TEXT_BOLD+fmt.Sprintf("Finished %s", command)+util.TEXT_RESET,57		numFiles, float32(dur.Nanoseconds())/1000000)58}59func setupErr(err string, stuff ...interface{}) {60	log.Error("main", util.TEXT_RED+util.TEXT_BOLD+"error:"+util.TEXT_RESET+" %s\n",61		fmt.Sprintf(err, stuff...))62	os.Exit(util.EXIT_FAILURE_SETUP)63}64type Context struct {65	Searchpaths []string66	Input string67	moduleLookup *ast.ModuleLookup68	depGraph     *ast.DependencyGraph69	modules      []*ast.Module70	modulesToRead []*ast.ModuleName71}72func NewContext() *Context {73	res := &Context{74		moduleLookup: ast.NewModuleLookup(""),75		depGraph:     ast.NewDependencyGraph(),76	}77	return res78}79func (v *Context) Build(output string, outputType codegen.OutputType, usedCodegen string, optLevel int) {80	// Start by loading the runtime81	runtimeModule := LoadRuntime()82	// Parse the passed files83	v.parseFiles()84	// resolve85	hasMainFunc := false86	log.Timed("resolve phase", "", func() {87		for _, module := range v.modules {88			ast.Resolve(module, v.moduleLookup)89			// Use module scope to check for main function90			mainIdent := module.ModScope.GetIdent(ast.UnresolvedName{Name: "main"})91			if mainIdent != nil && mainIdent.Type == ast.IDENT_FUNCTION && mainIdent.Public {92				hasMainFunc = true93			}94		}95	})96	// and here we check if we should97	// bother continuing any further...98	if !hasMainFunc {99		log.Error("main", util.Red("error: ")+"main function not found\n")100		os.Exit(1)101	}102	// type inference103	log.Timed("inference phase", "", func() {104		for _, module := range v.modules {105			for _, submod := range module.Parts {106				ast.Infer(submod)107				// Dump AST108				log.Debugln("main", "AST of submodule `%s/%s`:", module.Name, submod.File.Name)109				for _, node := range submod.Nodes {110					log.Debugln("main", "%s", node.String())111				}112				log.Debugln("main", "")113			}114		}115	})116	// semantic analysis117	log.Timed("semantic analysis phase", "", func() {118		for _, module := range v.modules {119			semantic.SemCheck(module, *ignoreUnused)120		}121	})122	// codegen123	if usedCodegen != "none" {124		var gen codegen.Codegen125		switch usedCodegen {126		case "llvm":127			gen = &LLVMCodegen.Codegen{128				OutputName: output,129				OutputType: outputType,130				OptLevel:   optLevel,131			}132		default:133			log.Error("main", util.Red("error: ")+"Invalid backend choice `"+usedCodegen+"`")134			os.Exit(1)135		}136		log.Timed("codegen phase", "", func() {137			mods := v.modules138			if runtimeModule != nil {139				mods = append(mods, runtimeModule)140			}141			gen.Generate(mods)142		})143	}144}145func (v *Context) Docgen(dir string) {146	v.parseFiles()147	gen := &doc.Docgen{148		Input: v.modules,149		Dir:   dir,150	}151	gen.Generate()152}153func (v *Context) parseFiles() {154	if strings.HasSuffix(v.Input, ".ark") {155		// Handle the special case of a single .ark file156		modname := &ast.ModuleName{Parts: []string{"__main"}}157		module := &ast.Module{158			Name:    modname,159			Dirpath: "",160		}161		v.moduleLookup.Create(modname).Module = module162		v.parseFile(v.Input, module)163		v.modules = append(v.modules, module)164	} else {165		if strings.ContainsAny(v.Input, `\/. `) {166			setupErr("Invalid module name: %s", v.Input)167		}168		modname := &ast.ModuleName{Parts: strings.Split(v.Input, "::")}169		v.modulesToRead = append(v.modulesToRead, modname)170	}171	log.Timed("read/lex/parse phase", "", func() {172		for i := 0; i < len(v.modulesToRead); i++ {173			modname := v.174				modulesToRead[i]175			// Skip already loaded modules176			if _, err := v.moduleLookup.Get(modname); err == nil {177				continue178			}179			fi, dirpath, err := v.findModuleDir(modname.ToPath())180			if err != nil {181				setupErr("Couldn't find module `%s`: %s", modname, err)182			}183			if !fi.IsDir() {184				setupErr("Expected path `%s` to be directory, was file.", dirpath)185			}186			module := &ast.Module{187				Name:    modname,188				Dirpath: dirpath,189			}190			v.moduleLookup.Create(modname).Module = module191			// Check module children192			childFiles, err := ioutil.ReadDir(dirpath)193			if err != nil {194				setupErr("%s", err.Error())195			}196			for _, childFile := range childFiles {197				if strings.HasPrefix(childFile.Name(), ".") || !strings.HasSuffix(childFile.Name(), ".ark") {198					continue199				}200				actualFile := filepath.Join(dirpath, childFile.Name())201				v.parseFile(actualFile, module)202			}203			v.modules = append(v.modules, module)204		}205	})206	// Check for cyclic dependencies (in modules)207	log.Timed("cyclic dependency check", "", func() {208		errs := v.depGraph.DetectCycles()209		if len(errs) > 0 {210			log.Error("main", "%s: Encountered cyclic dependency between: ", util.Bold(util.Red("error")))211			for _, cycle := range errs {212				log.Error("main", "%s", cycle)213			}214			log.Errorln("main", "")215			os.Exit(util.EXIT_FAILURE_SETUP)216		}217	})218	// construction219	log.Timed("construction phase", "", func() {220		for _, module := range v.modules {221			ast.Construct(module, v.moduleLookup)222		}223	})224}225func (v *Context) parseFile(path string, module *ast.Module) {226	// Read227	sourcefile, err := lexer.NewSourcefile(path)228	if err != nil {229		setupErr("%s", err.Error())230	}231	// Lex232	sourcefile.Tokens = lexer.Lex(sourcefile)233	// Parse234	parsedFile, deps := parser.Parse(sourcefile)235	module.Trees = append(module.Trees, parsedFile)236	// Add dependencies to parse array237	for _, dep := range deps {238		depname := ast.NewModuleName(dep)239		v.modulesToRead = append(v.modulesToRead, depname)240		v.depGraph.AddDependency(module.Name, depname)241		if _, _, err := v.findModuleDir(depname.ToPath()); err != nil {242			log.Errorln("main", "%s [%s:%d:%d] Couldn't find module `%s`", util.Red("error:"),243				dep.Where().Filename, dep.Where().StartLine, dep.Where().EndLine,244				depname.String())245			log.Errorln("main", "%s", sourcefile.MarkSpan(dep.Where()))246			os.Exit(1)247		}248	}249}250func (v *Context) findModuleDir(modulePath string) (fi os.FileInfo, path string, err error) {251	for _, searchPath := range v.Searchpaths {252		path := filepath.Join(searchPath, modulePath)253		fi, err := os.Stat(path)254		if err != nil {255			continue256		}257		return fi, path, nil258	}259	return nil, "", fmt.Errorf("ark: Unable to find module `%s`", path)260}...

parseOutputType

Using AI Code Generation

1import (2func main() {3    outputType, err = parseOutputType(os.Args[1])4    if err != nil {5        fmt.Println("Error: ", err)6    } else {7        fmt.Println("Output Type: ", outputType)8    }9}10import (11func parseOutputType(outputType string) (string, error) {12    if strings.ToLower(outputType) == "json" {13    } else if strings.ToLower(outputType) == "xml" {14    } else {15        return "", errors.New("Invalid Output Type")16    }17}

parseOutputType

Using AI Code Generation

1import (2func main() {3	fmt.Println(stringutil.Reverse("Hello, world"))4}5func Reverse(s string) string {6	r := []rune(s)7	for i, j := 0, len(r)-1; i < len(r)/2; i, j = i+1, j-1 {8	}9	return string(r)10}11import (12func main() {13	fmt.Println(stringutil2.Reverse("Hello, world"))14}15func Reverse(s string) string {16	r := []rune(s)17	for i, j := 0, len(r)-1; i < len(r)/2; i, j = i+1, j-1 {

parseOutputType

Using AI Code Generation

1import (2func main() {3	fmt.Println("input: ", input)4	fmt.Println("output: ", output)5	fmt.Println("outputType: ", outputType)6	outputTypeInt, err := strconv.Atoi(outputType)7	if err != nil {8		log.Fatal(err)9	}10	parseOutputType(outputTypeInt)11}12import (13func parseOutputType(outputType int) {14	fmt.Println("outputType: ", outputType)15}

parseOutputType

Using AI Code Generation

1import (2func main() {3    fmt.Println(strings.Contains(s, "Hello"))4    fmt.Println(strings.Contains(s, "World!"))5    fmt.Println(strings.Contains(s, "world"))6    fmt.Println(strings.Contains(s, "Hello, World!"))7    fmt.Println(strings.Contains(s, "Hello, World!"))8    fmt.Println(strings.Contains(s, "Hello, Gophers!"))9}

parseOutputType

Using AI Code Generation

1import "fmt"2func main() {3    fmt.Println(output)4}5import "fmt"6func parseOutputType(outputType string) string {7    if outputType == "json" {8    } else if outputType == "xml" {9    } else {10    }11}12The issue is that the 2.go file does not know about the parseOutputType function because it is defined in a different file. The solution is to import the package where the function is defined:13import "github.com/user/1"

parseOutputType

Using AI Code Generation

1public void parseOutputType(String[] args) {2    if(args.length == 1) {3        outputType = "txt";4    }5    else if(args.length == 2) {6        outputType = args[1];7    }8    else if(args.length == 3) {9        outputType = args[2];10    }11    else {12        System.out.println("Error: Too many command line arguments.");13    }14}15public void parseInputType(String[] args) {16    if(args.length == 1) {17        inputType = "txt";18    }19    else if(args.length == 2) {20        inputType = args[0];21    }22    else if(args.length == 3) {23        inputType = args[1];24    }25    else {26        System.out.println("Error: Too many command line arguments.");27    }28}29public void parseInputFileName(String[] args) {30    if(args.length == 1) {31        inputFileName = "input.txt";32    }33    else if(args.length == 2) {34        inputFileName = args[0];35    }

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.