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

Copied to Clipboard!

How to use TypeBehind method of td Package

Best Go-testdeep code snippet using td.TypeBehind

t_anchor.go

Source:t_anchor.go

...49// Anchor returns a typed value allowing to anchor the TestDeep50// operator operator in a go classic literal like a struct, slice,51// array or map value.52//53// If the TypeBehind method of operator returns non-nil, model can be54// omitted (like with [Between] operator in the example55// below). Otherwise, model should contain only one value56// corresponding to the returning type. It can be:57//   - a go value: returning type is the type of the value,58//     whatever the value is;59//   - a [reflect.Type].60//61// It returns a typed value ready to be embed in a go data structure to62// be compared using [T.Cmp] or [T.CmpLax]:63//64//	import (65//	  "testing"66//67//	  "github.com/maxatome/go-testdeep/td"68//	)69//70//	func TestFunc(tt *testing.T) {71//	  got := Func()72//73//	  t := td.NewT(tt)74//	  t.Cmp(got, &MyStruct{75//	    Name:    "Bob",76//	    Details: &MyDetails{77//	      Nick: t.Anchor(td.HasPrefix("Bobby"), "").(string),78//	      Age:  t.Anchor(td.Between(40, 50)).(int),79//	    },80//	  })81//	}82//83// In this example:84//85//   - [HasPrefix] operates on several input types (string,86//     [fmt.Stringer], error, â¦), so its TypeBehind method returns always87//     nil as it can not guess in advance on which type it operates. In88//     this case, we must pass "" as model parameter in order to tell it89//     to return the string type. Note that the .(string) type assertion90//     is then mandatory to conform to the strict type checking.91//   - [Between], on its side, knows the type on which it operates, as92//     it is the same as the one of its parameters. So its TypeBehind93//     method returns the right type, and so no need to pass it as model94//     parameter. Note that the .(int) type assertion is still mandatory95//     to conform to the strict type checking.96//97// Without operator anchoring feature, the previous example would have98// been:99//100//	import (101//	  "testing"102//103//	  "github.com/maxatome/go-testdeep/td"104//	)105//106//	func TestFunc(tt *testing.T) {107//	  got := Func()108//109//	  t := td.NewT(tt)110//	  t.Cmp(got, td.Struct(&MyStruct{Name: "Bob"},111//	    td.StructFields{112//	    "Details": td.Struct(&MyDetails{},113//	      td.StructFields{114//	        "Nick": td.HasPrefix("Bobby"),115//	        "Age":  td.Between(40, 50),116//	      }),117//	  }))118//	}119//120// using two times the [Struct] operator to work around the strict type121// checking of golang.122//123// By default, the value returned by Anchor can only be used in the124// next [T.Cmp] or [T.CmpLax] call. To make it persistent across calls,125// see [T.SetAnchorsPersist] and [T.AnchorsPersistTemporarily] methods.126//127// See [T.A] method for a shorter synonym of Anchor.128//129// See also [T.AnchorsPersistTemporarily], [T.DoAnchorsPersist],130// [T.ResetAnchors], [T.SetAnchorsPersist] and [AddAnchorableStructType].131func (t *T) Anchor(operator TestDeep, model ...any) any {132	if operator == nil {133		t.Helper()134		t.Fatal(color.Bad("Cannot anchor a nil TestDeep operator"))135	}136	var typ reflect.Type137	if len(model) > 0 {138		if len(model) != 1 {139			t.Helper()140			t.Fatal(color.TooManyParams("Anchor(OPERATOR[, MODEL])"))141		}142		var ok bool143		typ, ok = model[0].(reflect.Type)144		if !ok {145			typ = reflect.TypeOf(model[0])146			if typ == nil {147				t.Helper()148				t.Fatal(color.Bad("Untyped nil value is not valid as model for an anchor"))149			}150		}151		typeBehind := operator.TypeBehind()152		if typeBehind != nil && typeBehind != typ {153			t.Helper()154			t.Fatal(color.Bad("Operator %s TypeBehind() returned %s which differs from model type %s. Omit model or ensure its type is %[2]s",155				operator.GetLocation().Func, typeBehind, typ))156		}157	} else {158		typ = operator.TypeBehind()159		if typ == nil {160			t.Helper()161			t.Fatal(color.Bad("Cannot anchor operator %s as TypeBehind() returned nil. Use model parameter to specify the type to return",162				operator.GetLocation().Func))163		}164	}165	nvm, err := t.Config.anchors.AddAnchor(typ, reflect.ValueOf(operator))166	if err != nil {167		t.Helper()168		t.Fatal(color.Bad(err.Error()))169	}170	return nvm.Interface()171}172// A is a synonym for [T.Anchor].173//174//	import (175//	  "testing"...

td_ptr.go

Source:td_ptr.go

...28//29//	num := 330//	td.Cmp(t, &num, td.Ptr(td.Between(3, 4)))31//32// TypeBehind method returns the [reflect.Type] of a pointer on val,33// except if val is a [TestDeep] operator. In this case, it delegates34// TypeBehind() to the operator and returns the [reflect.Type] of a35// pointer on the returned value (if non-nil of course).36//37// See also [PPtr] and [Shallow].38func Ptr(val any) TestDeep {39	p := tdPtr{40		tdSmugglerBase: newSmugglerBase(val),41	}42	vval := reflect.ValueOf(val)43	if !vval.IsValid() {44		p.err = ctxerr.OpBadUsage("Ptr", "(NON_NIL_VALUE)", val, 1, true)45		return &p46	}47	if !p.isTestDeeper {48		p.expectedValue = reflect.New(vval.Type())49		p.expectedValue.Elem().Set(vval)50	}51	return &p52}53func (p *tdPtr) Match(ctx ctxerr.Context, got reflect.Value) *ctxerr.Error {54	if p.err != nil {55		return ctx.CollectError(p.err)56	}57	if got.Kind() != reflect.Ptr {58		if ctx.BooleanError {59			return ctxerr.BooleanError60		}61		return ctx.CollectError(&ctxerr.Error{62			Message:  "pointer type mismatch",63			Got:      types.RawString(got.Type().String()),64			Expected: types.RawString(p.String()),65		})66	}67	if p.isTestDeeper {68		return deepValueEqual(ctx.AddPtr(1), got.Elem(), p.expectedValue)69	}70	return deepValueEqual(ctx, got, p.expectedValue)71}72func (p *tdPtr) String() string {73	if p.err != nil {74		return p.stringError()75	}76	if p.isTestDeeper {77		return "*<something>"78	}79	return p.expectedValue.Type().String()80}81func (p *tdPtr) TypeBehind() reflect.Type {82	if p.err != nil {83		return nil84	}85	// If the expected value is a TestDeep operator, delegate TypeBehind to it86	if p.isTestDeeper {87		typ := p.expectedValue.Interface().(TestDeep).TypeBehind()88		if typ == nil {89			return nil90		}91		// Add a level of pointer92		return reflect.New(typ).Type()93	}94	return p.expectedValue.Type()95}96type tdPPtr struct {97	tdSmugglerBase98}99var _ TestDeep = &tdPPtr{}100// summary(PPtr): allows to easily test a pointer of pointer value101// input(PPtr): ptr102// PPtr is a smuggler operator. It takes the address of the address of103// data and compares it to val.104//105// val depends on data type. For example, if the compared data is an106// **int, one can have:107//108//	num := 12109//	pnum = &num110//	td.Cmp(t, &pnum, td.PPtr(12)) // succeeds111//112// as well as an other operator:113//114//	num := 3115//	pnum = &num116//	td.Cmp(t, &pnum, td.PPtr(td.Between(3, 4))) // succeeds117//118// It is more efficient and shorter to write than:119//120//	td.Cmp(t, &pnum, td.Ptr(td.Ptr(val))) // succeeds too121//122// TypeBehind method returns the [reflect.Type] of a pointer on a123// pointer on val, except if val is a [TestDeep] operator. In this124// case, it delegates TypeBehind() to the operator and returns the125// [reflect.Type] of a pointer on a pointer on the returned value (if126// non-nil of course).127//128// See also [Ptr].129func PPtr(val any) TestDeep {130	p := tdPPtr{131		tdSmugglerBase: newSmugglerBase(val),132	}133	vval := reflect.ValueOf(val)134	if !vval.IsValid() {135		p.err = ctxerr.OpBadUsage("PPtr", "(NON_NIL_VALUE)", val, 1, true)136		return &p137	}138	if !p.isTestDeeper {139		pVval := reflect.New(vval.Type())140		pVval.Elem().Set(vval)141		p.expectedValue = reflect.New(pVval.Type())142		p.expectedValue.Elem().Set(pVval)143	}144	return &p145}146func (p *tdPPtr) Match(ctx ctxerr.Context, got reflect.Value) *ctxerr.Error {147	if p.err != nil {148		return ctx.CollectError(p.err)149	}150	if got.Kind() != reflect.Ptr || got.Elem().Kind() != reflect.Ptr {151		if ctx.BooleanError {152			return ctxerr.BooleanError153		}154		return ctx.CollectError(&ctxerr.Error{155			Message:  "pointer type mismatch",156			Got:      types.RawString(got.Type().String()),157			Expected: types.RawString(p.String()),158		})159	}160	if p.isTestDeeper {161		return deepValueEqual(ctx.AddPtr(2), got.Elem().Elem(), p.expectedValue)162	}163	return deepValueEqual(ctx, got, p.expectedValue)164}165func (p *tdPPtr) String() string {166	if p.err != nil {167		return p.stringError()168	}169	if p.isTestDeeper {170		return "**<something>"171	}172	return p.expectedValue.Type().String()173}174func (p *tdPPtr) TypeBehind() reflect.Type {175	if p.err != nil {176		return nil177	}178	// If the expected value is a TestDeep operator, delegate TypeBehind to it179	if p.isTestDeeper {180		typ := p.expectedValue.Interface().(TestDeep).TypeBehind()181		if typ == nil {182			return nil183		}184		// Add 2 levels of pointer185		return reflect.New(reflect.New(typ).Type()).Type()186	}187	return p.expectedValue.Type()188}...

td_lax.go

Source:td_lax.go

...31// Note that in the latter case, [CmpLax] could be used as well:32//33//	td.CmpLax(t, floatValue, bw)34//35// TypeBehind method returns the greatest convertible or more common36// [reflect.Type] of expectedValue if it is a base type (bool, int*,37// uint*, float*, complex*, string), the [reflect.Type] of38// expectedValue otherwise, except if expectedValue is a [TestDeep]39// operator. In this case, it delegates TypeBehind() to the operator.40func Lax(expectedValue any) TestDeep {41	c := tdLax{42		tdSmugglerBase: newSmugglerBase(expectedValue),43	}44	if !c.isTestDeeper {45		c.expectedValue = reflect.ValueOf(expectedValue)46	}47	return &c48}49func (l *tdLax) Match(ctx ctxerr.Context, got reflect.Value) *ctxerr.Error {50	ctx.BeLax = true51	return deepValueEqual(ctx, got, l.expectedValue)52}53func (l *tdLax) HandleInvalid() bool {54	return true // Knows how to handle untyped nil values (aka invalid values)55}56func (l *tdLax) String() string {57	return "Lax(" + util.ToString(l.expectedValue) + ")"58}59func (l *tdLax) TypeBehind() reflect.Type {60	// If the expected value is a TestDeep operator, delegate TypeBehind to it61	if l.isTestDeeper {62		return l.expectedValue.Interface().(TestDeep).TypeBehind()63	}64	// For base types, returns the greatest convertible or more common one65	switch l.expectedValue.Kind() {66	case reflect.Invalid:67		return nil68	case reflect.Bool:69		return reflect.TypeOf(false)70	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:71		return reflect.TypeOf(int64(0))72	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:73		return reflect.TypeOf(uint64(0))74	case reflect.Float32, reflect.Float64:75		return reflect.TypeOf(float64(0))76	case reflect.Complex64, reflect.Complex128:...

TypeBehind

Using AI Code Generation

1import (2func main() {3	t := reflect.TypeOf(x)4	fmt.Println("Type of x is ", t)5	fmt.Println("Type of x is ", t.Kind())6	fmt.Println("Type of x is ", t.Name())7	fmt.Println("Type of x is ", t.String())8}9import (10func main() {11	t := reflect.TypeOf(x)12	fmt.Println("Type of x is ", t)13	fmt.Println("Type of x is ", t.Kind())14	fmt.Println("Type of x is ", t.Name())15	fmt.Println("Type of x is ", t.String())16	fmt.Println("Type of x is ", t.Kind().String())17}18import (19func main() {20	t := reflect.TypeOf(x)21	fmt.Println("Type of x is ", t)22	fmt.Println("Type of x is ", t.Kind())23	fmt.Println("Type of x is ", t.Name())24	fmt.Println("Type of x is ", t.String())25	fmt.Println("Type of x is ", t.Kind().String())26	fmt.Println("Type of x is ", t.Kind().String())27}28import (29func main() {30	t := reflect.TypeOf(x)31	fmt.Println("Type of x is ", t)32	fmt.Println("Type of x is ", t.Kind())33	fmt.Println("Type of x is ", t.Name())34	fmt.Println("Type of x is ", t.String())35	fmt.Println("Type of x is ", t.Kind().String())36	fmt.Println("Type

TypeBehind

Using AI Code Generation

1import (2func main() {3    td = NewTypeDescriptor(reflect.TypeOf(5))4    fmt.Println(td.TypeBehind())5    td = NewTypeDescriptor(reflect.TypeOf(5.6))6    fmt.Println(td.TypeBehind())7    td = NewTypeDescriptor(reflect.TypeOf("Hello"))8    fmt.Println(td.TypeBehind())9    td = NewTypeDescriptor(reflect.TypeOf([]int{1, 2, 3}))10    fmt.Println(td.TypeBehind())11    td = NewTypeDescriptor(reflect.TypeOf([]string{"Hello", "World"}))12    fmt.Println(td.TypeBehind())13    td = NewTypeDescriptor(reflect.TypeOf([]float64{1.1, 2.2, 3.3}))14    fmt.Println(td.TypeBehind())15    td = NewTypeDescriptor(reflect.TypeOf([]interface{}{1, 2.2, "Hello"}))16    fmt.Println(td.TypeBehind())17}18interface {}

TypeBehind

Using AI Code Generation

1import (2func main() {3 t = reflect.TypeOf(3)4 fmt.Println("type:", t)5 fmt.Println("type behind:", t.TypeBehind())6}

TypeBehind

Using AI Code Generation

1import "fmt"2type td struct {3}4func (t td) TypeBehind() string {5}6func main() {7    t := td{"John", 25}8    fmt.Println(t.TypeBehind())9}10import "fmt"11type td struct {12}13func (t td) TypeBehind() string {14}15func main() {16    t := td{"John", 25}17    fmt.Println(t.TypeBehind())18}19import "fmt"20type td struct {21}22func (t td) TypeBehind() string {23}24func main() {25    t := td{"John", 25}26    fmt.Println(t.TypeBehind())27}28import "fmt"29type td struct {30}31func (t td) TypeBehind() string {32}33func main() {34    t := td{"John", 25}35    fmt.Println(t.TypeBehind())36}37import "fmt"38type td struct {39}40func (t td) TypeBehind() string {41}42func main() {43    t := td{"John", 25}44    fmt.Println(t.TypeBehind())45}

TypeBehind

Using AI Code Generation

1import (2type TD struct {3}4func (t *TD) TypeBehind() reflect.Type {5	return reflect.TypeOf(t)6}7func main() {8	td := TD{}9	fmt.Println(td.TypeBehind().Name())10}

TypeBehind

Using AI Code Generation

1import (2type td struct {3}4func main() {5	fmt.Println(t.TypeBehind(i))6	fmt.Println(t.TypeBehind(s))7}8func (t td) TypeBehind(i interface{}) string {

TypeBehind

Using AI Code Generation

1import (2func main() {3    td := xlsx.NewTealeg()4    fmt.Println(td.TypeBehind("Employee"))5}6import (7func main() {8    td := xlsx.NewTealeg()9    fmt.Println(td.TypeBehind("Employee"))10}11import (12func main() {13    td := xlsx.NewTealeg()14    fmt.Println(td.TypeBehind("Employee"))15}16import (17func main() {18    td := xlsx.NewTealeg()19    fmt.Println(td.TypeBehind("Employee"))20}21import (22func main() {23    td := xlsx.NewTealeg()24    fmt.Println(td.TypeBehind("Employee"))25}26import (27func main() {28    td := xlsx.NewTealeg()29    fmt.Println(td.TypeBehind("Employee"))30}31import (32func main() {33    td := xlsx.NewTealeg()34    fmt.Println(td.TypeBehind("Employee"))35}36import (

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.