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

Copied to Clipboard!

How to use SuperMapOf method of td Package

Best Go-testdeep code snippet using td.SuperMapOf

td_map_test.go

Source:td_map_test.go

...210	// With Lax â OK211	checkOK(t, MyMap{}, td.Lax(td.Map(map[string]int{}, nil)))212	checkOK(t, map[string]int{}, td.Lax(td.Map(MyMap{}, nil)))213	//214	// SuperMapOf215	checkOK(t, gotMap, td.SuperMapOf(map[string]int{"foo": 1}, nil))216	checkOK(t, gotMap,217		td.SuperMapOf(map[string]int{"foo": 1}, td.MapEntries{"bar": 2}))218	checkOK(t, gotMap,219		td.SuperMapOf(map[string]int{}, td.MapEntries{"foo": 1, "bar": 2}))220	checkError(t, gotMap,221		td.SuperMapOf(map[string]int{"foo": 1, "bar": 3}, nil),222		expectedError{223			Message:  mustBe("values differ"),224			Path:     mustBe(`DATA["bar"]`),225			Got:      mustBe("2"),226			Expected: mustBe("3"),227		})228	checkError(t, gotMap, td.SuperMapOf(map[string]int{"test": 2}, nil),229		expectedError{230			Message: mustBe("comparing hash keys of %%"),231			Path:    mustBe("DATA"),232			Summary: mustBe(`Missing key: ("test")`),233		})234	checkError(t, gotMap,235		td.SuperMapOf(map[string]int{}, td.MapEntries{"test": 2}),236		expectedError{237			Message: mustBe("comparing hash keys of %%"),238			Path:    mustBe("DATA"),239			Summary: mustBe(`Missing key: ("test")`),240		})241	checkOK(t, gotNilMap, td.SuperMapOf(map[string]int{}, nil))242	checkOK(t, gotNilTypedMap, td.SuperMapOf(MyMap{}, nil))243	checkOK(t, &gotNilTypedMap, td.SuperMapOf(&MyMap{}, nil))244	//245	// SubMapOf246	checkOK(t, gotMap,247		td.SubMapOf(map[string]int{"foo": 1, "bar": 2, "tst": 3}, nil))248	checkOK(t, gotMap,249		td.SubMapOf(map[string]int{"foo": 1, "tst": 3}, td.MapEntries{"bar": 2}))250	checkOK(t, gotMap,251		td.SubMapOf(map[string]int{}, td.MapEntries{"foo": 1, "bar": 2, "tst": 3}))252	checkError(t, gotMap,253		td.SubMapOf(map[string]int{"foo": 1, "bar": 3}, nil),254		expectedError{255			Message:  mustBe("values differ"),256			Path:     mustBe(`DATA["bar"]`),257			Got:      mustBe("2"),258			Expected: mustBe("3"),259		})260	checkError(t, gotMap, td.SubMapOf(map[string]int{"foo": 1}, nil),261		expectedError{262			Message: mustBe("comparing hash keys of %%"),263			Path:    mustBe("DATA"),264			Summary: mustBe(`Extra key: ("bar")`),265		})266	checkError(t, gotMap,267		td.SubMapOf(map[string]int{}, td.MapEntries{"foo": 1, "test": 2}),268		expectedError{269			Message: mustBe("comparing hash keys of %%"),270			Path:    mustBe("DATA"),271			Summary: mustBe(`Missing key: ("test")272  Extra key: ("bar")`),273		})274	checkOK(t, gotNilMap, td.SubMapOf(map[string]int{"foo": 1}, nil))275	checkOK(t, gotNilTypedMap, td.SubMapOf(MyMap{"foo": 1}, nil))276	checkOK(t, &gotNilTypedMap, td.SubMapOf(&MyMap{"foo": 1}, nil))277	//278	// Bad usage279	checkError(t, "never tested",280		td.Map("test", nil),281		expectedError{282			Message: mustBe("bad usage of Map operator"),283			Path:    mustBe("DATA"),284			Summary: mustContain("usage: Map("),285		})286	checkError(t, "never tested",287		td.SuperMapOf("test", nil),288		expectedError{289			Message: mustBe("bad usage of SuperMapOf operator"),290			Path:    mustBe("DATA"),291			Summary: mustContain("usage: SuperMapOf("),292		})293	checkError(t, "never tested",294		td.SubMapOf("test", nil),295		expectedError{296			Message: mustBe("bad usage of SubMapOf operator"),297			Path:    mustBe("DATA"),298			Summary: mustContain("usage: SubMapOf("),299		})300	num := 12301	checkError(t, "never tested",302		td.Map(&num, nil),303		expectedError{304			Message: mustBe("bad usage of Map operator"),305			Path:    mustBe("DATA"),306			Summary: mustContain("usage: Map("),307		})308	checkError(t, "never tested",309		td.SuperMapOf(&num, nil),310		expectedError{311			Message: mustBe("bad usage of SuperMapOf operator"),312			Path:    mustBe("DATA"),313			Summary: mustContain("usage: SuperMapOf("),314		})315	checkError(t, "never tested",316		td.SubMapOf(&num, nil),317		expectedError{318			Message: mustBe("bad usage of SubMapOf operator"),319			Path:    mustBe("DATA"),320			Summary: mustContain("usage: SubMapOf("),321		})322	checkError(t, "never tested",323		td.Map(&MyMap{}, td.MapEntries{1: 2}),324		expectedError{325			Message: mustBe("bad usage of Map operator"),326			Path:    mustBe("DATA"),327			Summary: mustBe("expected key 1 type mismatch: int != model key type (string)"),328		})329	checkError(t, "never tested",330		td.SuperMapOf(&MyMap{}, td.MapEntries{1: 2}),331		expectedError{332			Message: mustBe("bad usage of SuperMapOf operator"),333			Path:    mustBe("DATA"),334			Summary: mustBe("expected key 1 type mismatch: int != model key type (string)"),335		})336	checkError(t, "never tested",337		td.SubMapOf(&MyMap{}, td.MapEntries{1: 2}),338		expectedError{339			Message: mustBe("bad usage of SubMapOf operator"),340			Path:    mustBe("DATA"),341			Summary: mustBe("expected key 1 type mismatch: int != model key type (string)"),342		})343	checkError(t, "never tested",344		td.Map(&MyMap{}, td.MapEntries{"foo": nil}),345		expectedError{346			Message: mustBe("bad usage of Map operator"),347			Path:    mustBe("DATA"),348			Summary: mustBe(`expected key "foo" value cannot be nil as entries value type is int`),349		})350	checkError(t, "never tested",351		td.Map(&MyMap{}, td.MapEntries{"foo": uint16(2)}),352		expectedError{353			Message: mustBe("bad usage of Map operator"),354			Path:    mustBe("DATA"),355			Summary: mustBe(`expected key "foo" value type mismatch: uint16 != model key type (int)`),356		})357	checkError(t, "never tested",358		td.Map(&MyMap{"foo": 1}, td.MapEntries{"foo": 1}),359		expectedError{360			Message: mustBe("bad usage of Map operator"),361			Path:    mustBe("DATA"),362			Summary: mustBe(`"foo" entry exists in both model & expectedEntries`),363		})364	//365	// String366	test.EqualStr(t, td.Map(MyMap{}, nil).String(),367		"td_test.MyMap{}")368	test.EqualStr(t, td.Map(&MyMap{}, nil).String(),369		"*td_test.MyMap{}")370	test.EqualStr(t, td.Map(&MyMap{"foo": 2}, nil).String(),371		`*td_test.MyMap{372  "foo": 2,373}`)374	test.EqualStr(t, td.SubMapOf(MyMap{}, nil).String(),375		"SubMapOf(td_test.MyMap{})")376	test.EqualStr(t, td.SubMapOf(&MyMap{}, nil).String(),377		"SubMapOf(*td_test.MyMap{})")378	test.EqualStr(t, td.SubMapOf(&MyMap{"foo": 2}, nil).String(),379		`SubMapOf(*td_test.MyMap{380  "foo": 2,381})`)382	test.EqualStr(t, td.SuperMapOf(MyMap{}, nil).String(),383		"SuperMapOf(td_test.MyMap{})")384	test.EqualStr(t, td.SuperMapOf(&MyMap{}, nil).String(),385		"SuperMapOf(*td_test.MyMap{})")386	test.EqualStr(t, td.SuperMapOf(&MyMap{"foo": 2}, nil).String(),387		`SuperMapOf(*td_test.MyMap{388  "foo": 2,389})`)390	// Erroneous op391	test.EqualStr(t, td.Map(12, nil).String(), "Map(<ERROR>)")392	test.EqualStr(t, td.SubMapOf(12, nil).String(), "SubMapOf(<ERROR>)")393	test.EqualStr(t, td.SuperMapOf(12, nil).String(), "SuperMapOf(<ERROR>)")394}395func TestMapTypeBehind(t *testing.T) {396	type MyMap map[string]int397	// Map398	equalTypes(t, td.Map(map[string]int{}, nil), map[string]int{})399	equalTypes(t, td.Map(MyMap{}, nil), MyMap{})400	equalTypes(t, td.Map(&MyMap{}, nil), &MyMap{})401	// SubMap402	equalTypes(t, td.SubMapOf(map[string]int{}, nil), map[string]int{})403	equalTypes(t, td.SubMapOf(MyMap{}, nil), MyMap{})404	equalTypes(t, td.SubMapOf(&MyMap{}, nil), &MyMap{})405	// SuperMap406	equalTypes(t, td.SuperMapOf(map[string]int{}, nil), map[string]int{})407	equalTypes(t, td.SuperMapOf(MyMap{}, nil), MyMap{})408	equalTypes(t, td.SuperMapOf(&MyMap{}, nil), &MyMap{})409	// Erroneous op410	equalTypes(t, td.Map(12, nil), nil)411	equalTypes(t, td.SubMapOf(12, nil), nil)412	equalTypes(t, td.SuperMapOf(12, nil), nil)413}...

td_map.go

Source:td_map.go

...29	key      reflect.Value30	expected reflect.Value31}32// MapEntries allows to pass map entries to check in functions [Map],33// [SubMapOf] and [SuperMapOf]. It is a map whose each key is the34// expected entry key and the corresponding value the expected entry35// value (which can be a [TestDeep] operator as well as a zero value.)36type MapEntries map[any]any37func newMap(model any, entries MapEntries, kind mapKind) *tdMap {38	vmodel := reflect.ValueOf(model)39	m := tdMap{40		tdExpectedType: tdExpectedType{41			base: newBase(4),42		},43		kind: kind,44	}45	switch vmodel.Kind() {46	case reflect.Ptr:47		if vmodel.Type().Elem().Kind() != reflect.Map {48			break49		}50		m.isPtr = true51		if vmodel.IsNil() {52			m.expectedType = vmodel.Type().Elem()53			m.populateExpectedEntries(entries, reflect.Value{})54			return &m55		}56		vmodel = vmodel.Elem()57		fallthrough58	case reflect.Map:59		m.expectedType = vmodel.Type()60		m.populateExpectedEntries(entries, vmodel)61		return &m62	}63	m.err = ctxerr.OpBadUsage(64		m.GetLocation().Func, "(MAP|&MAP, EXPECTED_ENTRIES)",65		model, 1, true)66	return &m67}68func (m *tdMap) populateExpectedEntries(entries MapEntries, expectedModel reflect.Value) {69	var keysInModel int70	if expectedModel.IsValid() {71		keysInModel = expectedModel.Len()72	}73	m.expectedEntries = make([]mapEntryInfo, 0, keysInModel+len(entries))74	checkedEntries := make(map[any]bool, len(entries))75	keyType := m.expectedType.Key()76	valueType := m.expectedType.Elem()77	var entryInfo mapEntryInfo78	for key, expectedValue := range entries {79		vkey := reflect.ValueOf(key)80		if !vkey.Type().AssignableTo(keyType) {81			m.err = ctxerr.OpBad(82				m.GetLocation().Func,83				"expected key %s type mismatch: %s != model key type (%s)",84				util.ToString(key),85				vkey.Type(),86				keyType)87			return88		}89		if expectedValue == nil {90			switch valueType.Kind() {91			case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map,92				reflect.Ptr, reflect.Slice:93				entryInfo.expected = reflect.Zero(valueType) // change to a typed nil94			default:95				m.err = ctxerr.OpBad(96					m.GetLocation().Func,97					"expected key %s value cannot be nil as entries value type is %s",98					util.ToString(key),99					valueType)100				return101			}102		} else {103			entryInfo.expected = reflect.ValueOf(expectedValue)104			if _, ok := expectedValue.(TestDeep); !ok {105				if !entryInfo.expected.Type().AssignableTo(valueType) {106					m.err = ctxerr.OpBad(107						m.GetLocation().Func,108						"expected key %s value type mismatch: %s != model key type (%s)",109						util.ToString(key),110						entryInfo.expected.Type(),111						valueType)112					return113				}114			}115		}116		entryInfo.key = vkey117		m.expectedEntries = append(m.expectedEntries, entryInfo)118		checkedEntries[dark.MustGetInterface(vkey)] = true119	}120	// Check entries in model121	if keysInModel == 0 {122		return123	}124	tdutil.MapEach(expectedModel, func(k, v reflect.Value) bool {125		entryInfo.expected = v126		if checkedEntries[dark.MustGetInterface(k)] {127			m.err = ctxerr.OpBad(128				m.GetLocation().Func,129				"%s entry exists in both model & expectedEntries",130				util.ToString(k))131			return false132		}133		entryInfo.key = k134		m.expectedEntries = append(m.expectedEntries, entryInfo)135		return true136	})137}138// summary(Map): compares the contents of a map139// input(Map): map,ptr(ptr on map)140// Map operator compares the contents of a map against the non-zero141// values of model (if any) and the values of expectedEntries.142//143// model must be the same type as compared data.144//145// expectedEntries can be nil, if no zero entries are expected and146// no [TestDeep] operators are involved.147//148// During a match, all expected entries must be found and all data149// entries must be expected to succeed.150//151//	got := map[string]string{152//	  "foo": "test",153//	  "bar": "wizz",154//	  "zip": "buzz",155//	}156//	td.Cmp(t, got, td.Map(157//	  map[string]string{158//	    "foo": "test",159//	    "bar": "wizz",160//	  },161//	  td.MapEntries{162//	    "zip": td.HasSuffix("zz"),163//	  }),164//	) // succeeds165//166// TypeBehind method returns the [reflect.Type] of model.167//168// See also [SubMapOf] and [SuperMapOf].169func Map(model any, expectedEntries MapEntries) TestDeep {170	return newMap(model, expectedEntries, allMap)171}172// summary(SubMapOf): compares the contents of a map but with173// potentially some exclusions174// input(SubMapOf): map,ptr(ptr on map)175// SubMapOf operator compares the contents of a map against the non-zero176// values of model (if any) and the values of expectedEntries.177//178// model must be the same type as compared data.179//180// expectedEntries can be nil, if no zero entries are expected and181// no [TestDeep] operators are involved.182//183// During a match, each map entry should be matched by an expected184// entry to succeed. But some expected entries can be missing from the185// compared map.186//187//	got := map[string]string{188//	  "foo": "test",189//	  "zip": "buzz",190//	}191//	td.Cmp(t, got, td.SubMapOf(192//	  map[string]string{193//	    "foo": "test",194//	    "bar": "wizz",195//	  },196//	  td.MapEntries{197//	    "zip": td.HasSuffix("zz"),198//	  }),199//	) // succeeds200//201//	td.Cmp(t, got, td.SubMapOf(202//	  map[string]string{203//	    "bar": "wizz",204//	  },205//	  td.MapEntries{206//	    "zip": td.HasSuffix("zz"),207//	  }),208//	) // fails, extra {"foo": "test"} in got209//210// TypeBehind method returns the [reflect.Type] of model.211//212// See also [Map] and [SuperMapOf].213func SubMapOf(model any, expectedEntries MapEntries) TestDeep {214	return newMap(model, expectedEntries, subMap)215}216// summary(SuperMapOf): compares the contents of a map but with217// potentially some extra entries218// input(SuperMapOf): map,ptr(ptr on map)219// SuperMapOf operator compares the contents of a map against the non-zero220// values of model (if any) and the values of expectedEntries.221//222// model must be the same type as compared data.223//224// expectedEntries can be nil, if no zero entries are expected and225// no [TestDeep] operators are involved.226//227// During a match, each expected entry should match in the compared228// map. But some entries in the compared map may not be expected.229//230//	got := map[string]string{231//	  "foo": "test",232//	  "bar": "wizz",233//	  "zip": "buzz",234//	}235//	td.Cmp(t, got, td.SuperMapOf(236//	  map[string]string{237//	    "foo": "test",238//	  },239//	  td.MapEntries{240//	    "zip": td.HasSuffix("zz"),241//	  }),242//	) // succeeds243//244//	td.Cmp(t, got, td.SuperMapOf(245//	  map[string]string{246//	    "foo": "test",247//	  },248//	  td.MapEntries{249//	    "biz": td.HasSuffix("zz"),250//	  }),251//	) // fails, missing {"biz": â¦} in got252//253// TypeBehind method returns the [reflect.Type] of model.254//255// See also [SuperMapOf] and [SubMapOf].256func SuperMapOf(model any, expectedEntries MapEntries) TestDeep {257	return newMap(model, expectedEntries, superMap)258}259func (m *tdMap) Match(ctx ctxerr.Context, got reflect.Value) (err *ctxerr.Error) {260	if m.err != nil {261		return ctx.CollectError(m.err)262	}263	err = m.checkPtr(ctx, &got, true)264	if err != nil {265		return ctx.CollectError(err)266	}267	return m.match(ctx, got)268}269func (m *tdMap) match(ctx ctxerr.Context, got reflect.Value) (err *ctxerr.Error) {270	err = m.checkType(ctx, got)271	if err != nil {272		return ctx.CollectError(err)273	}274	var notFoundKeys []reflect.Value275	foundKeys := map[any]bool{}276	for _, entryInfo := range m.expectedEntries {277		gotValue := got.MapIndex(entryInfo.key)278		if !gotValue.IsValid() {279			notFoundKeys = append(notFoundKeys, entryInfo.key)280			continue281		}282		err = deepValueEqual(ctx.AddMapKey(entryInfo.key),283			got.MapIndex(entryInfo.key), entryInfo.expected)284		if err != nil {285			return err286		}287		foundKeys[dark.MustGetInterface(entryInfo.key)] = true288	}289	const errorMessage = "comparing hash keys of %%"290	// For SuperMapOf we don't care about extra keys291	if m.kind == superMap {292		if len(notFoundKeys) == 0 {293			return nil294		}295		if ctx.BooleanError {296			return ctxerr.BooleanError297		}298		return ctx.CollectError(&ctxerr.Error{299			Message: errorMessage,300			Summary: (tdSetResult{301				Kind:    keysSetResult,302				Missing: notFoundKeys,303				Sort:    true,304			}).Summary(),...

health_handler_test.go

Source:health_handler_test.go

...77			ta = ta.Get("/").78				CmpStatus(tt.wantStatus)79			if tt.wantBody != nil {80				ta.81					CmpHeader(td.SuperMapOf(http.Header{}, td.MapEntries{82						"Content-Type": []string{"application/json"},83					})).84					CmpJSONBody(tt.wantBody)85			}86		})87	}88}...

SuperMapOf

Using AI Code Generation

1import (2func main() {3	td.SuperMapOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, "hello", "world")4}5import (6func main() {7	fmt.Println(td.SuperMapOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, "hello", "world"))8}9import (10func main() {11	td.SuperMapOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, "hello", "world")12}13import (14func main() {

SuperMapOf

Using AI Code Generation

1import (2type td struct {3}4func (t td) SuperMapOf() map[int]int {5}6func main() {7	t := td{m: map[int]int{1: 1, 2: 2, 3: 3}}8	for k, v := range t.SuperMapOf() {9		fmt.Println(k, v)10	}11}12import (13type td struct {14}15func (t *td) SuperMapOf() map[int]int {16}17func main() {18	t := td{m: map[int]int{1: 1, 2: 2, 3: 3}}19	for k, v := range t.SuperMapOf() {20		fmt.Println(k, v)21	}22}23import (24type td struct {25}26func (t *td) SuperMapOf() map[int]int {27}28func main() {29	t := &td{m: map[int]int{1: 1, 2: 2, 3: 3}}30	for k, v := range t.SuperMapOf() {31		fmt.Println(k, v)32	}33}34import (35type td struct {36}37func (t td) SuperMapOf() map[int]int {38}39func main() {40	t := &td{m: map[int]int{1: 1, 2: 2, 3:

SuperMapOf

Using AI Code Generation

1import (2func main() {3	type Person struct {4	}5	type Employee struct {6	}7	m := map[string]Person{8		"Person1": Person{9		},10		"Person2": Person{11		},12	}13	m1 := map[string]Employee{14		"Employee1": Employee{15		},16		"Employee2": Employee{17		},18	}19	m2 := map[string]interface{}{}20	SuperMapOf(m, m2)21	SuperMapOf(m1, m2)22	fmt.Println(m2)23	fmt.Println(m)24	fmt.Println(m1)25}26func SuperMapOf(src, dest interface{}) {27	srcVal := reflect.ValueOf(src)28	destVal := reflect.ValueOf(dest)29	if srcVal.Kind() != reflect.Map || destVal.Kind() != reflect.Map {30	}31	srcKeys := srcVal.MapKeys()32	for _, key := range srcKeys {33		srcValOfKey := srcVal.MapIndex(key)34		if destVal.MapIndex(key).IsValid() {

SuperMapOf

Using AI Code Generation

1import (2func main() {3	mymap = td.SuperMapOf()4	mymap.Add("one", 1)5	mymap.Add("two", 2)6	mymap.Add("three", 3)7	mymap.Add("four", 4)8	mymap.Add("five", 5)9	fmt.Println(mymap)10}

SuperMapOf

Using AI Code Generation

1import (2func main() {3	fmt.Println("SuperMapOf method of td class")4	var m = make(map[string]int)5	fmt.Println(td.SuperMapOf(m))6}7import (8func main() {9	fmt.Println("SuperMapOf method of td class")10	var m = make(map[string]int)

SuperMapOf

Using AI Code Generation

1import "fmt"2func main() {3	td = td{1, 2, 3}4	fmt.Println(td.SuperMapOf(td, func(x int) int {5	}))6}7import "fmt"8func main() {9	td = td{1, 2, 3}10	fmt.Println(td.SuperMapOf([]int{1, 2, 3}, func(x int) int {11	}))12}13import "fmt"14func main() {15	td = td{1, 2, 3}16	fmt.Println(SuperMapOf(td, func(x int) int {17	}))18}19import "fmt"20func main() {21	td = td{1, 2, 3}22	fmt.Println(SuperMapOf([]int{1, 2, 3}, func(x int) int {23	}))24}25import "fmt"26func main() {27	td = td{1, 2, 3}28	fmt.Println(SuperMapOf(td, func(x int) int {29	}))30}

SuperMapOf

Using AI Code Generation

1import (2func main() {3	td = td{1, 2, 3, 4, 5}4	fmt.Println(td.SuperMapOf(func(x int) int { return x * x }))5}6import (7func main() {8	td = td{1, 2, 3, 4, 5}9	fmt.Println(td.SuperMapOf(func(x int) int { return x * x }))10}11import (12func main() {13	td = td{1, 2, 3, 4, 5}14	fmt.Println(td.SuperMapOf(func(x int) int { return x * x }))15}16import (17func main() {18	td = td{1, 2, 3, 4, 5}19	fmt.Println(td.SuperMapOf(func(x int) int { return x * x }))20}21import (22func main() {23	td = td{1, 2, 3, 4, 5}24	fmt.Println(td.SuperMapOf(func(x int) int { return x * x }))25}26import (27func main() {28	td = td{1, 2, 3, 4, 5}29	fmt.Println(td.SuperMapOf(func(x int) int { return x * x }))30}31import (32func main() {33	td = td{1, 2, 3, 4,

SuperMapOf

Using AI Code Generation

1import (2func main() {3	fmt.Println("Hello World!")4	x := td.SuperMapOf("hello", 1, "world", 2)5	fmt.Println(x)6}7import (8func main() {9	fmt.Println("Hello World!")10	x := td.SuperMapOf("hello", 1, "world", 2, "hi", 3)11	fmt.Println(x)12}13import (14func main() {15	fmt.Println("Hello World!")16	x := td.SuperMapOf("hello", 1, "world", 2, "hi", 3, "bye", 4)17	fmt.Println(x)18}19import (20func main() {21	fmt.Println("Hello World!")22	x := td.SuperMapOf("hello", 1, "world", 2, "hi", 3, "bye", 4, "goodbye", 5)23	fmt.Println(x)24}

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.