Unlock 30% off on Manual Testing Annual Plans this Holiday Season.

Copied to Clipboard!

How to use TemplateName method of prog Package

Best Syzkaller code snippet using prog.TemplateName

check.go

Source:check.go

...196func checkImpl(structs map[string]*dwarf.StructType, structTypes []prog.Type,197	locs map[string]*ast.Struct) ([]Warn, error) {198	var warnings []Warn199	for _, typ := range structTypes {200		name := typ.TemplateName()201		astStruct := locs[name]202		if astStruct == nil {203			continue204		}205		warns, err := checkStruct(typ, astStruct, structs[name])206		if err != nil {207			return nil, err208		}209		warnings = append(warnings, warns...)210	}211	return warnings, nil212}213func checkStruct(typ prog.Type, astStruct *ast.Struct, str *dwarf.StructType) ([]Warn, error) {214	var warnings []Warn215	warn := func(pos ast.Pos, typ, msg string, args ...interface{}) {216		warnings = append(warnings, Warn{pos: pos, typ: typ, msg: fmt.Sprintf(msg, args...)})217	}218	name := typ.TemplateName()219	if str == nil {220		// Varlen structs are frequently not described in kernel (not possible in C).221		if !typ.Varlen() {222			warn(astStruct.Pos, WarnNoSuchStruct, "%v", name)223		}224		return warnings, nil225	}226	if !typ.Varlen() && typ.Size() != uint64(str.ByteSize) {227		warn(astStruct.Pos, WarnBadStructSize, "%v: syz=%v kernel=%v", name, typ.Size(), str.ByteSize)228	}229	// TODO: handle unions, currently we should report some false errors.230	if _, ok := typ.(*prog.UnionType); ok || str.Kind == "union" {231		return warnings, nil232	}233	// TODO: we could also check enums (elements match corresponding flags in syzkaller).234	// TODO: we could also check values of literal constants (dwarf should have that, right?).235	// TODO: handle nested structs/unions, e.g.:236	// struct foo {237	//	union {238	//		...239	//	} bar;240	// };241	// should be matched with:242	// foo_bar [243	//	...244	// ]245	// TODO: consider making guesses about semantic types of fields,246	// e.g. if a name contains filedes/uid/pid/gid that may be the corresponding resource.247	ai := 0248	offset := uint64(0)249	for _, field := range typ.(*prog.StructType).Fields {250		if field.Type.Varlen() {251			ai = len(str.Field)252			break253		}254		if prog.IsPad(field.Type) {255			offset += field.Type.Size()256			continue257		}258		if ai < len(str.Field) {259			fld := str.Field[ai]260			pos := astStruct.Fields[ai].Pos261			desc := fmt.Sprintf("%v.%v", name, field.Name)262			if field.Name != fld.Name {263				desc += "/" + fld.Name264			}265			if field.Type.UnitSize() != uint64(fld.Type.Size()) {266				warn(pos, WarnBadFieldSize, "%v: syz=%v kernel=%v",267					desc, field.Type.UnitSize(), fld.Type.Size())268			}269			byteOffset := offset - field.Type.UnitOffset()270			if byteOffset != uint64(fld.ByteOffset) {271				warn(pos, WarnBadFieldOffset, "%v: syz=%v kernel=%v",272					desc, byteOffset, fld.ByteOffset)273			}274			// How would you define bitfield offset?275			// Offset of the beginning of the field from the beginning of the memory location, right?276			// No, DWARF defines it as offset of the end of the field from the end of the memory location.277			bitOffset := fld.Type.Size()*8 - fld.BitOffset - fld.BitSize278			if fld.BitSize == 0 {279				// And to make things even more interesting this calculation280				// does not work for normal variables.281				bitOffset = 0282			}283			if field.Type.BitfieldLength() != uint64(fld.BitSize) ||284				field.Type.BitfieldOffset() != uint64(bitOffset) {285				warn(pos, WarnBadBitfield, "%v: size/offset: syz=%v/%v kernel=%v/%v",286					desc, field.Type.BitfieldLength(), field.Type.BitfieldOffset(),287					fld.BitSize, bitOffset)288			}289		}290		ai++291		offset += field.Size()292	}293	if ai != len(str.Field) {294		warn(astStruct.Pos, WarnBadFieldNumber, "%v: syz=%v kernel=%v", name, ai, len(str.Field))295	}296	return warnings, nil297}298func parseDescriptions(OS, arch string) ([]prog.Type, map[string]*ast.Struct, []Warn, error) {299	errorBuf := new(bytes.Buffer)300	var warnings []Warn301	eh := func(pos ast.Pos, msg string) {302		warnings = append(warnings, Warn{pos: pos, typ: WarnCompiler, msg: msg})303		fmt.Fprintf(errorBuf, "%v: %v\n", pos, msg)304	}305	top := ast.ParseGlob(filepath.Join("sys", OS, "*.txt"), eh)306	if top == nil {307		return nil, nil, nil, fmt.Errorf("failed to parse txt files:\n%s", errorBuf.Bytes())308	}309	consts := compiler.DeserializeConstsGlob(filepath.Join("sys", OS, "*_"+arch+".const"), eh)310	if consts == nil {311		return nil, nil, nil, fmt.Errorf("failed to parse const files:\n%s", errorBuf.Bytes())312	}313	prg := compiler.Compile(top, consts, targets.Get(OS, arch), eh)314	if prg == nil {315		return nil, nil, nil, fmt.Errorf("failed to compile descriptions:\n%s", errorBuf.Bytes())316	}317	prog.RestoreLinks(prg.Syscalls, prg.Resources, prg.Types)318	locs := make(map[string]*ast.Struct)319	for _, decl := range top.Nodes {320		switch n := decl.(type) {321		case *ast.Struct:322			locs[n.Name.Name] = n323		case *ast.TypeDef:324			if n.Struct != nil {325				locs[n.Name.Name] = n.Struct326			}327		}328	}329	var structs []prog.Type330	for _, typ := range prg.Types {331		switch typ.(type) {332		case *prog.StructType, *prog.UnionType:333			structs = append(structs, typ)334		}335	}336	return structs, locs, warnings, nil337}338// Overall idea of netlink checking.339// Currnetly we check netlink policies for common detectable mistakes.340// First, we detect what looks like a netlink policy in our descriptions341// (these are structs/unions only with nlattr/nlnext/nlnetw fields).342// Then we find corresponding symbols (offset/size) in vmlinux using nm.343// Then we read elf headers and locate where these symbols are in the rodata section.344// Then read in the symbol data, which is an array of nla_policy structs.345// These structs allow to easily figure out type/size of attributes.346// Finally we compare our descriptions with the kernel policy description.347func checkNetlink(OS, arch, obj string, structTypes []prog.Type,348	locs map[string]*ast.Struct) ([]Warn, error) {349	if arch != "amd64" {350		// Netlink policies are arch-independent (?),351		// so no need to check all arches.352		// Also our definition of nlaPolicy below is 64-bit specific.353		return nil, nil354	}355	ef, err := elf.Open(obj)356	if err != nil {357		return nil, err358	}359	rodata := ef.Section(".rodata")360	if rodata == nil {361		return nil, fmt.Errorf("object file %v does not contain .rodata section", obj)362	}363	symb := symbolizer.NewSymbolizer(targets.Get(OS, arch))364	symbols, err := symb.ReadRodataSymbols(obj)365	if err != nil {366		return nil, err367	}368	var warnings []Warn369	structMap := make(map[string]prog.Type)370	for _, typ := range structTypes {371		structMap[typ.Name()] = typ372	}373	checkedAttrs := make(map[string]*checkAttr)374	for _, typ := range structTypes {375		warnings1, err := checkNetlinkStruct(locs, symbols, rodata, structMap, checkedAttrs, typ)376		if err != nil {377			return nil, err378		}379		warnings = append(warnings, warnings1...)380	}381	warnings = append(warnings, checkMissingAttrs(checkedAttrs)...)382	return warnings, nil383}384func checkNetlinkStruct(locs map[string]*ast.Struct, symbols map[string][]symbolizer.Symbol, rodata *elf.Section,385	structMap map[string]prog.Type, checkedAttrs map[string]*checkAttr, typ prog.Type) ([]Warn, error) {386	name := typ.TemplateName()387	astStruct := locs[name]388	if astStruct == nil {389		return nil, nil390	}391	var fields []prog.Field392	switch t := typ.(type) {393	case *prog.StructType:394		fields = t.Fields395	case *prog.UnionType:396		fields = t.Fields397	}398	if !isNetlinkPolicy(fields) {399		return nil, nil400	}401	kernelName := name402	var ss []symbolizer.Symbol403	// In some cases we split a single policy into multiple ones404	// (more precise description), so try to match our foo_bar_baz405	// with kernel foo_bar and foo as well.406	for kernelName != "" {407		ss = symbols[kernelName]408		if len(ss) != 0 {409			break410		}411		underscore := strings.LastIndexByte(kernelName, '_')412		if underscore == -1 {413			break414		}415		kernelName = kernelName[:underscore]416	}417	if len(ss) == 0 {418		return []Warn{{pos: astStruct.Pos, typ: WarnNoNetlinkPolicy, msg: name}}, nil419	}420	var warnings []Warn421	var warnings1 *[]Warn422	var policy1 []nlaPolicy423	var attrs1 map[int]bool424	// We may have several symbols with the same name (they frequently have internal linking),425	// in such case we choose the one that produces fewer warnings.426	for _, symb := range ss {427		if symb.Size == 0 || symb.Size%int(unsafe.Sizeof(nlaPolicy{})) != 0 {428			warnings = append(warnings, Warn{pos: astStruct.Pos, typ: WarnNetlinkBadSize,429				msg: fmt.Sprintf("%v (%v), size %v", kernelName, name, ss[0].Size)})430			continue431		}432		binary := make([]byte, symb.Size)433		addr := symb.Addr - rodata.Addr434		if _, err := rodata.ReadAt(binary, int64(addr)); err != nil {435			return nil, fmt.Errorf("failed to read policy %v (%v) at %v: %v",436				kernelName, name, symb.Addr, err)437		}438		policy := (*[1e6]nlaPolicy)(unsafe.Pointer(&binary[0]))[:symb.Size/int(unsafe.Sizeof(nlaPolicy{}))]439		warnings2, attrs2, err := checkNetlinkPolicy(structMap, typ, fields, astStruct, policy)440		if err != nil {441			return nil, err442		}443		if warnings1 == nil || len(*warnings1) > len(warnings2) {444			warnings1 = &warnings2445			policy1 = policy446			attrs1 = attrs2447		}448	}449	if warnings1 != nil {450		warnings = append(warnings, *warnings1...)451		ca := checkedAttrs[kernelName]452		if ca == nil {453			ca = &checkAttr{454				pos:    astStruct.Pos,455				name:   name,456				policy: policy1,457				attrs:  make(map[int]bool),458			}459			checkedAttrs[kernelName] = ca460		}461		for attr := range attrs1 {462			ca.attrs[attr] = true463		}464	}465	return warnings, nil466}467type checkAttr struct {468	pos    ast.Pos469	name   string470	policy []nlaPolicy471	attrs  map[int]bool472}473func checkMissingAttrs(checkedAttrs map[string]*checkAttr) []Warn {474	// Missing attribute checking is a bit tricky because we may split a single475	// kernel policy into several policies for better precision.476	// They have different names, but map to the same kernel policy.477	// We want to report a missing attribute iff it's missing in all copies of the policy.478	var warnings []Warn479	for _, ca := range checkedAttrs {480		var missing []int481		for i, pol := range ca.policy {482			// Ignore attributes that are not described in the policy483			// (some of them are unused at all, however there are cases where484			// they are not described but used as inputs, and these are actually485			// the worst ones).486			if !ca.attrs[i] && (pol.typ != NLA_UNSPEC && pol.typ != NLA_REJECT || pol.len != 0) {487				missing = append(missing, i)488			}489		}490		// If we miss too many, there is probably something else going on.491		if len(missing) != 0 && len(missing) <= 5 {492			warnings = append(warnings, Warn{493				pos: ca.pos,494				typ: WarnNetlinkBadAttr,495				msg: fmt.Sprintf("%v: missing attributes: %v", ca.name, missing),496			})497		}498	}499	return warnings500}501func isNetlinkPolicy(fields []prog.Field) bool {502	haveAttr := false503	for _, fld := range fields {504		field := fld.Type505		if prog.IsPad(field) {506			continue507		}508		if isNlattr(field) {509			haveAttr = true510			continue511		}512		if arr, ok := field.(*prog.ArrayType); ok {513			field = arr.Elem514		}515		if field1, ok := field.(*prog.StructType); ok {516			if isNetlinkPolicy(field1.Fields) {517				continue518			}519		}520		if field1, ok := field.(*prog.UnionType); ok {521			if isNetlinkPolicy(field1.Fields) {522				continue523			}524		}525		return false526	}527	return haveAttr528}529const (530	nlattrT  = "nlattr_t"531	nlattrTT = "nlattr_tt"532)533func isNlattr(typ prog.Type) bool {534	name := typ.TemplateName()535	return name == nlattrT || name == nlattrTT536}537func checkNetlinkPolicy(structMap map[string]prog.Type, typ prog.Type, fields []prog.Field,538	astStruct *ast.Struct, policy []nlaPolicy) ([]Warn, map[int]bool, error) {539	var warnings []Warn540	warn := func(pos ast.Pos, typ, msg string, args ...interface{}) {541		warnings = append(warnings, Warn{pos: pos, typ: typ, msg: fmt.Sprintf(msg, args...)})542	}543	checked := make(map[int]bool)544	ai := 0545	for _, field := range fields {546		if prog.IsPad(field.Type) {547			continue548		}549		fld := astStruct.Fields[ai]550		ai++551		if !isNlattr(field.Type) {552			continue553		}554		ft := field.Type.(*prog.StructType)555		attr := int(ft.Fields[1].Type.(*prog.ConstType).Val)556		if attr >= len(policy) {557			warn(fld.Pos, WarnNetlinkBadAttrType, "%v.%v: type %v, kernel policy size %v",558				typ.TemplateName(), field.Name, attr, len(policy))559			continue560		}561		if checked[attr] {562			warn(fld.Pos, WarnNetlinkBadAttr, "%v.%v: duplicate attribute",563				typ.TemplateName(), field.Name)564		}565		checked[attr] = true566		w := checkNetlinkAttr(ft, policy[attr])567		if w != "" {568			warn(fld.Pos, WarnNetlinkBadAttr, "%v.%v: %v",569				typ.TemplateName(), field.Name, w)570		}571	}572	return warnings, checked, nil573}574func checkNetlinkAttr(typ *prog.StructType, policy nlaPolicy) string {575	payload := typ.Fields[2].Type576	if typ.TemplateName() == nlattrTT {577		payload = typ.Fields[4].Type578	}579	if warn := checkAttrType(typ, payload, policy); warn != "" {580		return warn581	}582	size, minSize, maxSize := attrSize(policy)583	payloadSize := minTypeSize(payload)584	if size != -1 && size != payloadSize {585		return fmt.Sprintf("bad size %v, expect %v", payloadSize, size)586	}587	if minSize != -1 && minSize > payloadSize {588		return fmt.Sprintf("bad size %v, expect min %v", payloadSize, minSize)589	}590	if maxSize != -1 && maxSize < payloadSize {591		return fmt.Sprintf("bad size %v, expect max %v", payloadSize, maxSize)592	}593	valMin, valMax, haveVal := typeMinMaxValue(payload)594	if haveVal {595		if policy.validation == NLA_VALIDATE_RANGE || policy.validation == NLA_VALIDATE_MIN {596			if int64(valMin) < int64(policy.minVal) {597				// This is a common case that occurs several times: limit on min value of 1.598				// Not worth fixing (at least not in initial batch), it just crosses out a599				// single value of 0, which we shuold test anyway.600				if !(policy.validation == NLA_VALIDATE_MIN && policy.minVal == 1) {601					return fmt.Sprintf("bad min value %v, expect %v",602						int64(valMin), policy.minVal)603				}604			}605		}606		if policy.validation == NLA_VALIDATE_RANGE || policy.validation == NLA_VALIDATE_MAX {607			if int64(valMax) > int64(policy.maxVal) {608				return fmt.Sprintf("bad max value %v, expect %v",609					int64(valMax), policy.maxVal)610			}611		}612	}613	return ""614}615func minTypeSize(typ prog.Type) int {616	if !typ.Varlen() {617		return int(typ.Size())618	}619	if str, ok := typ.(*prog.StructType); ok {620		// Some struct args has trailing arrays, but are only checked for min size.621		// Try to get some estimation for min size of this struct.622		size := 0623		for _, field := range str.Fields {624			if !field.Varlen() {625				size += int(field.Size())626			}627		}628		return size629	}630	if arr, ok := typ.(*prog.ArrayType); ok {631		if arr.Kind == prog.ArrayRangeLen && !arr.Elem.Varlen() {632			return int(arr.RangeBegin * arr.Elem.Size())633		}634	}635	return -1636}637func checkAttrType(typ *prog.StructType, payload prog.Type, policy nlaPolicy) string {638	switch policy.typ {639	case NLA_STRING, NLA_NUL_STRING:640		if _, ok := payload.(*prog.BufferType); !ok {641			return "expect string"642		}643	case NLA_NESTED:644		if typ.TemplateName() != nlattrTT || typ.Fields[3].Type.(*prog.ConstType).Val != 1 {645			return "should be nlnest"646		}647	case NLA_BITFIELD32:648		if typ.TemplateName() != nlattrT || payload.TemplateName() != "nla_bitfield32" {649			return "should be nlattr[nla_bitfield32]"650		}651	case NLA_NESTED_ARRAY, NLA_REJECT:652		return fmt.Sprintf("unhandled type %v", policy.typ)653	}654	return ""655}656func attrSize(policy nlaPolicy) (int, int, int) {657	switch policy.typ {658	case NLA_UNSPEC:659		if policy.len != 0 {660			return -1, int(policy.len), -1661		}662	case NLA_MIN_LEN:...

sss.go

Source:sss.go

...22	flagLen    = flag.Int("len", prog.RecommendedCalls, "number of calls in programs")23	flagEnable = flag.String("enable", "", "comma-separated list of enabled syscalls")24)25type Arginfo struct {26	TemplateName string27	Value        prog.Arg28}29// func replaceResultArg(arg, arg1 *prog.ResultArg) {30// 	// Remove link from `a.Res` to `arg`.31// 	if arg.Res != nil {32// 		delete(arg.Res.uses, arg)33// 	}34// 	// Copy all fields from `arg1` to `arg` except for the list of args that use `arg`.35// 	uses := arg.uses36// 	*arg = *arg137// 	arg.uses = uses38// 	// Make the link in `arg.Res` (which is now `Res` of `arg1`) to point to `arg` instead of `arg1`.39// 	if arg.Res != nil {40// 		resUses := arg.Res.uses41// 		delete(resUses, arg1)42// 		resUses[arg] = true43// 	}44// }45func replaceArg(arg, arg1 prog.Arg) {46	switch a := arg.(type) {47	case *prog.ConstArg:48		*a = *arg1.(*prog.ConstArg)49	case *prog.ResultArg:50		// replaceResultArg(a, arg1.(*prog.ResultArg))51	case *prog.PointerArg:52		*a = *arg1.(*prog.PointerArg)53	case *prog.UnionArg:54		*a = *arg1.(*prog.UnionArg)55	case *prog.DataArg:56		*a = *arg1.(*prog.DataArg)57	case *prog.GroupArg:58		a1 := arg1.(*prog.GroupArg)59		if len(a.Inner) != len(a1.Inner) {60			panic(fmt.Sprintf("replaceArg: group fields don't match: %v/%v",61				len(a.Inner), len(a1.Inner)))62		}63		a.ArgCommon = a1.ArgCommon64		for i := range a.Inner {65			replaceArg(a.Inner[i], a1.Inner[i])66		}67	default:68		panic(fmt.Sprintf("replaceArg: bad arg kind %#v", arg))69	}70}71func parseArg(p *prog.Prog) map[string][]prog.Arg {72	argMap := make(map[string][]prog.Arg)73	for _, c := range p.Calls {74		args := make([]prog.Arg, 0)75		prog.ForeachArg(c, func(arg prog.Arg, ctx *prog.ArgCtx) {76			switch arg.Type().(type) {77			case *prog.UnionType, *prog.ConstType, *prog.IntType,78				*prog.FlagsType, *prog.LenType, *prog.CsumType,79				*prog.VmaType, *prog.BufferType, *prog.ArrayType:80				fmt.Printf("adding %s\n", arg.Type().String())81				args = append(args, arg)82			}83		})84		argMap[c.Meta.Name] = args85	}86	return argMap87}88func logArgMap(argMap map[string][]prog.Arg) {89	for syscall, args := range argMap {90		fmt.Printf("in syscall %s\n", syscall)91		for _, arg := range args {92			fmt.Printf("arg Type %s, template: %s (%T)\n", arg.Type().String(), arg.Type().TemplateName(), arg)93		}94	}95}96func main() {97	flag.Parse()98	if *flagPoc == "" {99		fmt.Printf("please specify the poc by -poc\n")100		os.Exit(1)101	}102	target, err := prog.GetTarget(*flagOS, *flagArch)103	if err != nil {104		fmt.Fprintf(os.Stderr, "%v", err)105		os.Exit(1)106	}107	seed := time.Now().UnixNano()108	rs := rand.NewSource(seed)109	r := rand.New(rs)110	var syscalls map[*prog.Syscall]bool111	if *flagEnable != "" {112		enabled := strings.Split(*flagEnable, ",")113		syscallsIDs, err := mgrconfig.ParseEnabledSyscalls(target, enabled, nil)114		if err != nil {115			fmt.Fprintf(os.Stderr, "failed to parse enabled syscalls: %v", err)116			os.Exit(1)117		}118		syscalls = make(map[*prog.Syscall]bool)119		for _, id := range syscallsIDs {120			syscalls[target.Syscalls[id]] = true121		}122		var disabled map[*prog.Syscall]string123		syscalls, disabled = target.TransitivelyEnabledCalls(syscalls)124		for c, reason := range disabled {125			fmt.Fprintf(os.Stderr, "disabling %v: %v\n", c.Name, reason)126		}127	}128	data, err := ioutil.ReadFile(flag.Arg(0))129	if err != nil {130		fmt.Fprintf(os.Stderr, "failed to read prog file: %v\n", err)131		os.Exit(1)132	}133	poc, err := target.Deserialize(data, prog.NonStrict)134	if err != nil {135		fmt.Fprintf(os.Stderr, "failed to deserialize the program: %v\n", err)136		os.Exit(1)137	}138	argMaps := parseArg(poc)139	logArgMap(argMaps)140	var p *prog.Prog141	if flag.NArg() == 0 {142		fmt.Printf("please specify the input to be mutated\n")143		os.Exit(-1)144	} else {145		data, err := ioutil.ReadFile(flag.Arg(0))146		if err != nil {147			fmt.Fprintf(os.Stderr, "failed to read prog file: %v\n", err)148			os.Exit(1)149		}150		p, err = target.Deserialize(data, prog.NonStrict)151		if err != nil {152			fmt.Fprintf(os.Stderr, "failed to deserialize the program: %v\n", err)153			os.Exit(1)154		}155		fmt.Printf("Original input: %s\n", p.Serialize())156		for _, c := range p.Calls {157			args := argMaps[c.Meta.Name]158			if len(args) == 0 {159				fmt.Printf("skip %s\n", c.Meta.Name)160				continue161			}162			prog.ForeachArg(c, func(arg prog.Arg, ctx *prog.ArgCtx) {163				switch arg.(type) {164				// case *prog.UnionArg, *prog.GroupArg, *prog.StructArg:165				default:166					for _, pocArg := range args {167						if pocArg.Type().String() == arg.Type().String() &&168							pocArg.Type().TemplateName() == arg.Type().TemplateName() {169							fmt.Printf("Found %s != %s\n", pocArg.Type().String(), arg.Type().String())170							if r.Intn(8) > 1 {171								continue172							}173							replaceArg(arg, pocArg)174							fmt.Printf("after mutation: %s\n", p.Serialize())175							break176						} else {177							fmt.Printf("Skip %s != %s\n", pocArg.Type().String(), arg.Type().String())178						}179					}180				}181				// case *prog.PointerArg, *prog.UnionArg:182				// 	fmt.Printf("%s : %s\n", arg.Type().String(), arg.Type().Name())183				// 	fmt.Printf("Temple name: %s\n", arg.Type().TemplateName())184				// 	fmt.Printf("ARG: %T\n", arg)185				// 	fmt.Printf("Type2: %T\n\n", arg.Type())186				// case *prog.GroupArg:187				// 	fmt.Printf("%s : %s\n", arg.Type().String(), arg.Type().Name())188				// 	fmt.Printf("Temple name: %s\n", arg.Type().TemplateName())189				// 	fmt.Printf("ARG: %T\n", arg)190				// 	fmt.Printf("Type2: %T\n\n", arg.Type())191				// 	if typ, ok := a.Type().(*prog.StructType); ok {192				// 		fmt.Printf("Found struct: %s\n", typ.Name())193				// 		for i, fff := range typ.Fields {194				// 			fmt.Printf("Field %d: %s (%s, %T)\n", i, fff.Name, fff.Type.TemplateName(), fff.Type)195				// 		}196				// 		fmt.Printf("\n")197				// 	}198				// }199				// 1. arg.Type().String() are the same and arg.Type().TemplateName() are the same200				// fmt.Printf("%s : %s\n", arg.Type().String(), arg.Type().Name())201				// fmt.Printf("Temple name: %s\n", arg.Type().TemplateName())202				// fmt.Printf("ARG: %T\n", arg)203				// fmt.Printf("Type2: %T\n", arg.Type())204				// switch a := arg.Type().(type) {205				// case *prog.StructType:206				// 	for _, f := range a.Fields {207				// 		fmt.Printf("In structure: type: %T, name: %s, string: %s\n", f.Type, f.Type.Name(), f.Type.String())208				// 		switch a := f.Type.(type) {209				// 		case *prog.BufferType:210				// 			switch a.Kind {211				// 			case prog.BufferString:212				// 				fmt.Printf("Value: %v\n", a.Values)213				// 				// case prog.FlagsType:214				// 				// 	fmt.Printf("Value: %v\n", a.Values)215				// 			}...

TemplateName

Using AI Code Generation

1import (2type Prog struct {3}4func (p *Prog) TemplateName() string {5}6func main() {7    p := &Prog{name: "Golang"}8    fmt.Println(p.TemplateName())9}

TemplateName

Using AI Code Generation

1import (2func main() {3	fmt.Println(prog.TemplateName())4}5import (6func main() {7	fmt.Println(prog.TemplateName())8}9import (10func main() {11	fmt.Println(prog.TemplateName())12}13import (14func main() {15	fmt.Println(prog.TemplateName())16}17import (18func main() {19	fmt.Println(prog.TemplateName())20}21import (22func main() {23	fmt.Println(prog.TemplateName())24}25import (26func main() {27	fmt.Println(prog.TemplateName())28}29import (30func main() {31	fmt.Println(prog.TemplateName())32}33import (34func main() {35	fmt.Println(prog.TemplateName())36}37import (38func main() {39	fmt.Println(prog.TemplateName())40}41import (42func main() {43	fmt.Println(prog.TemplateName())44}45import (46func main() {47	fmt.Println(prog.TemplateName())48}

TemplateName

Using AI Code Generation

1import "fmt"2type prog struct {3}4func (p prog) TemplateName() string {5}6func main() {7p := prog{name: "Go"}8fmt.Println(p.TemplateName())9}10import "fmt"11type prog struct {12}13func (p prog) TemplateName() string {14}15func main() {16p := prog{name: "Go"}17fmt.Println(p.TemplateName())18}19import "fmt"20type prog struct {21}22func (p prog) TemplateName() string {23}24func main() {25p := prog{name: "Go"}26fmt.Println(p.TemplateName())27}

TemplateName

Using AI Code Generation

1func main() {2    p := prog.Prog{}3    p.TemplateName()4}5type Prog struct {6}7func (p *Prog) TemplateName() {8    println("Hello World")9}10./2.go:7: cannot use p (type prog.Prog) as type *prog.Prog in argument to p.TemplateName

TemplateName

Using AI Code Generation

1import (2func main() {3	p.SetName("Golang")4	p.SetVersion(1.0)5	fmt.Println(p.Name())6	fmt.Println(p.Version())7}8type Prog struct {9}10func (p *Prog) SetName(name string) {11}12func (p *Prog) Name() string {13}14func (p *Prog) SetVersion(version float64) {15}16func (p *Prog) Version() float64 {17}18import (19func main() {20	p.SetName("Golang")21	p.SetVersion(1.0)22	fmt.Println(p.Name())23	fmt.Println(p.Version())24}25import "fmt"26type Prog struct {27}28func (p Prog) SetName(name string) {29}30func (p Prog) Name() string {31}32func (p Prog) SetVersion(version float64) {33}34func (p Prog) Version() float64 {35}

TemplateName

Using AI Code Generation

1import (2func main() {3	fmt.Println("Name of the template is ", prog.TemplateName())4}5import (6func main() {7	fmt.Println("Name of the template is ", prog.TemplateName())8}9import (10func TemplateName() string {11}

TemplateName

Using AI Code Generation

1import (2func main() {3    p.SetName("Golang")4    fmt.Println(p.TemplateName())5}6type prog struct {7}8func (p *prog) SetName(name string) {9}10func (p *prog) TemplateName() string {11}12In my 2.go file, I have imported the prog package using the following line:13import "github.com/GoTraining/1"14    /usr/lib/go-1.6/src/github.com/GoTraining/1 (from $GOROOT)15    /home/username/go/src/github.com/GoTraining/1 (from $GOPATH)16Your name to display (optional):17Your name to display (optional):18The package name is prog, so you need to import it like this:19import "github.com/GoTraining/1/prog"20Your name to display (optional):21Your name to display (optional):22Your name to display (optional):23Your name to display (optional):24Your name to display (optional):25Your name to display (optional):26Your name to display (optional):27Your name to display (optional):

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.