How to use ResolveAnchor method of anchors Package

Best Go-testdeep code snippet using anchors.ResolveAnchor

equal.go

Source:equal.go

...97		}98	}99	return false, false100}101// resolveAnchor does the same as ctx.Anchors.ResolveAnchor but checks102// whether v is valid and not already a TestDeep operator first.103func resolveAnchor(ctx ctxerr.Context, v reflect.Value) (reflect.Value, bool) {104	if !v.IsValid() || v.Type().Implements(testDeeper) {105		return v, false106	}107	return ctx.Anchors.ResolveAnchor(v)108}109func deepValueEqual(ctx ctxerr.Context, got, expected reflect.Value) (err *ctxerr.Error) {110	// got must not implement testDeeper111	if got.IsValid() && got.Type().Implements(testDeeper) {112		panic(color.Bad("Found a TestDeep operator in got param, " +113			"can only use it in expected one!"))114	}115	// Try to see if a TestDeep operator is anchored in expected116	if op, ok := resolveAnchor(ctx, expected); ok {117		expected = op118	}119	if !got.IsValid() || !expected.IsValid() {120		if got.IsValid() == expected.IsValid() {121			return...

anchor.go

Source:anchor.go

...74	n = i.index75	i.index++76	return77}78// ResolveAnchor checks whether the passed value matches an anchored79// operator or not. If yes, this operator is returned with true. If80// no, the value is returned as is with false.81func (i *Info) ResolveAnchor(v reflect.Value) (reflect.Value, bool) {82	if i == nil || !v.CanInterface() {83		return v, false84	}85	// Shortcut86	i.Lock()87	la := len(i.anchors)88	i.Unlock()89	if la == 0 {90		return v, false91	}92	var key any93sw:94	switch v.Kind() {95	case reflect.Int,...

anchor_test.go

Source:anchor_test.go

...18	test.IsTrue(t, i.DoAnchorsPersist())19	i.SetAnchorsPersist(false)20	test.IsFalse(t, i.DoAnchorsPersist())21}22func TestBuildResolveAnchor(t *testing.T) {23	var i anchors.Info24	checkResolveAnchor := func(t *testing.T, val any, opName string) {25		t.Helper()26		v1, err := i.AddAnchor(reflect.TypeOf(val), reflect.ValueOf(opName+" (1)"))27		if !test.NoError(t, err, "first anchor") {28			return29		}30		v2, err := i.AddAnchor(reflect.TypeOf(val), reflect.ValueOf(opName+" (2)"))31		if !test.NoError(t, err, "second anchor") {32			return33		}34		op, found := i.ResolveAnchor(v1)35		test.IsTrue(t, found, "first anchor found")36		test.EqualStr(t, op.String(), opName+" (1)", "first anchor operator OK")37		op, found = i.ResolveAnchor(v2)38		test.IsTrue(t, found, "second anchor found")39		test.EqualStr(t, op.String(), opName+" (2)", "second anchor operator OK")40	}41	t.Run("AddAnchor basic types", func(t *testing.T) {42		checkResolveAnchor(t, 0, "int")43		checkResolveAnchor(t, int8(0), "int8")44		checkResolveAnchor(t, int16(0), "int16")45		checkResolveAnchor(t, int32(0), "int32")46		checkResolveAnchor(t, int64(0), "int64")47		checkResolveAnchor(t, uint(0), "uint")48		checkResolveAnchor(t, uint8(0), "uint8")49		checkResolveAnchor(t, uint16(0), "uint16")50		checkResolveAnchor(t, uint32(0), "uint32")51		checkResolveAnchor(t, uint64(0), "uint64")52		checkResolveAnchor(t, uintptr(0), "uintptr")53		checkResolveAnchor(t, float32(0), "float32")54		checkResolveAnchor(t, float64(0), "float64")55		checkResolveAnchor(t, complex(float32(0), 0), "complex64")56		checkResolveAnchor(t, complex(float64(0), 0), "complex128")57		checkResolveAnchor(t, "", "string")58		checkResolveAnchor(t, (chan int)(nil), "chan")59		checkResolveAnchor(t, (map[string]bool)(nil), "map")60		checkResolveAnchor(t, ([]int)(nil), "slice")61		checkResolveAnchor(t, (*time.Time)(nil), "pointer")62	})63	t.Run("AddAnchor", func(t *testing.T) {64		oldAnchorableTypes := anchors.AnchorableTypes65		defer func() { anchors.AnchorableTypes = oldAnchorableTypes }()66		type ok struct{ index int }67		// AddAnchor for ok type68		err := anchors.AddAnchorableStructType(func(nextAnchor int) ok {69			return ok{index: 1000 + nextAnchor}70		})71		if err != nil {72			t.Fatalf("AddAnchorableStructType failed: %s", err)73		}74		checkResolveAnchor(t, ok{}, "ok{}")75		// AddAnchor for ok convertible type76		type okConvert ok77		checkResolveAnchor(t, okConvert{}, "okConvert{}")78		// Replace ok type79		err = anchors.AddAnchorableStructType(func(nextAnchor int) ok {80			return ok{index: 2000 + nextAnchor}81		})82		if err != nil {83			t.Fatalf("AddAnchorableStructType failed: %s", err)84		}85		if len(anchors.AnchorableTypes) != 2 {86			t.Fatalf("Bad number of anchored type: got=%d expected=2",87				len(anchors.AnchorableTypes))88		}89		checkResolveAnchor(t, ok{}, "ok{}")90		// AddAnchor for builtin time.Time type91		checkResolveAnchor(t, time.Time{}, "time.Time{}")92		// AddAnchor for unknown type93		_, err = i.AddAnchor(reflect.TypeOf(func() {}), reflect.ValueOf(123))94		if test.Error(t, err) {95			test.EqualStr(t, err.Error(), "func kind is not supported as an anchor")96		}97		// AddAnchor for unknown struct type98		_, err = i.AddAnchor(reflect.TypeOf(struct{}{}), reflect.ValueOf(123))99		if test.Error(t, err) {100			test.EqualStr(t,101				err.Error(),102				"struct {} struct type is not supported as an anchor. Try AddAnchorableStructType")103		}104		// Struct not comparable105		type notComparable struct{ s []int }106		v := reflect.ValueOf(notComparable{s: []int{42}})107		op, found := i.ResolveAnchor(v)108		test.IsFalse(t, found)109		if !reflect.DeepEqual(v.Interface(), op.Interface()) {110			test.EqualErrorMessage(t, op.Interface(), v.Interface())111		}112		// Struct comparable but not anchored113		v = reflect.ValueOf(struct{}{})114		op, found = i.ResolveAnchor(v)115		test.IsFalse(t, found)116		if !reflect.DeepEqual(v.Interface(), op.Interface()) {117			test.EqualErrorMessage(t, op.Interface(), v.Interface())118		}119		// Struct anchored once, but not for this value120		v = reflect.ValueOf(ok{index: 42424242})121		op, found = i.ResolveAnchor(v)122		test.IsFalse(t, found)123		if !reflect.DeepEqual(v.Interface(), op.Interface()) {124			test.EqualErrorMessage(t, op.Interface(), v.Interface())125		}126		// Kind not supported127		v = reflect.ValueOf(true)128		op, found = i.ResolveAnchor(v)129		test.IsFalse(t, found)130		if !reflect.DeepEqual(v.Interface(), op.Interface()) {131			test.EqualErrorMessage(t, op.Interface(), v.Interface())132		}133	})134	t.Run("ResetAnchors", func(t *testing.T) {135		v, err := i.AddAnchor(reflect.TypeOf(12), reflect.ValueOf("zip"))136		if !test.NoError(t, err) {137			return138		}139		op, found := i.ResolveAnchor(v)140		test.IsTrue(t, found)141		test.EqualStr(t, op.String(), "zip")142		i.SetAnchorsPersist(true)143		i.ResetAnchors(false)144		op, found = i.ResolveAnchor(v)145		test.IsTrue(t, found)146		test.EqualStr(t, op.String(), "zip")147		i.ResetAnchors(true)148		_, found = i.ResolveAnchor(reflect.ValueOf(42))149		test.IsFalse(t, found)150		i.SetAnchorsPersist(false)151		v, err = i.AddAnchor(reflect.TypeOf(12), reflect.ValueOf("xxx"))152		if !test.NoError(t, err) {153			return154		}155		op, found = i.ResolveAnchor(v)156		test.IsTrue(t, found)157		test.EqualStr(t, op.String(), "xxx")158		i.ResetAnchors(false)159		_, found = i.ResolveAnchor(reflect.ValueOf(42))160		test.IsFalse(t, found)161	})162	t.Run("skip", func(t *testing.T) {163		var i *anchors.Info164		_, found := i.ResolveAnchor(reflect.ValueOf(42))165		test.IsFalse(t, found)166		i = &anchors.Info{}167		_, found = i.ResolveAnchor(reflect.ValueOf(42))168		test.IsFalse(t, found)169	})170}...

ResolveAnchor

Using AI Code Generation

1import (2func main() {3	sdk, err := fabsdk.New(config.FromFile("/home/ubuntu/go/src/github.com/hyperledger/fabric-sdk-go/test/fixtures/config/config_test.yaml"))4	if err != nil {5		fmt.Printf("Failed to create new SDK: %s6	}7	defer sdk.Close()8	args = append(args, "query")9	args = append(args, "b")10	channelProvider := sdk.ChannelContext("mychannel", fabsdk.WithUser("Admin"))11	client, err := channel.New(channelProvider)12	if err != nil {13		fmt.Printf("Failed to create new channel client: %s14	}15	response, err := client.Query(16		channel.Request{ChaincodeID: "mycc", Fcn: args[0], Args: [][]byte{[]byte(args[1])}},17		channel.WithRetry(retry.DefaultChannelOpts),18	if err != nil {19		fmt.Printf("Failed to query: %s20	}21	fmt.Printf("Response: %s22", string(response.Payload))23}24import (25func main() {26	sdk, err := fabsdk.New(config.FromFile("/home/ubuntu/go/src/github.com/hyperledger/fabric-sdk-go/test/fixtures/config/config_test.yaml"))27	if err != nil {28		fmt.Printf("Failed to create new SDK: %s29	}30	defer sdk.Close()

ResolveAnchor

Using AI Code Generation

1import (2type AnchorResolve struct {3}4func (t *AnchorResolve) Init(stub shim.ChaincodeStubInterface) peer.Response {5	return shim.Success(nil)6}7func (t *AnchorResolve) Invoke(stub shim.ChaincodeStubInterface) peer.Response {8	fn, args := stub.GetFunctionAndParameters()9	if fn == "resolveAnchor" {10		result, err = resolveAnchor(stub, args)11		if err != nil {12			return shim.Error(err.Error())13		}14	}15	return shim.Success([]byte(result))16}17func resolveAnchor(stub shim.ChaincodeStubInterface, args []string) (string, error) {18	anchor := entities.Anchor{}19	err := anchor.ResolveAnchor(stub, args[0])20	if err != nil {21		return "", fmt.Errorf("Unable to resolve anchor: %s", err.Error())22	}23	return anchor.GetID(), nil24}25func main() {26	err := shim.Start(new(AnchorResolve))27	if err != nil {28		fmt.Printf("Error starting AnchorResolve chaincode: %s", err)29	}30}31import (32type AnchorResolve struct {33}34func (t *AnchorResolve) Init(stub shim.ChaincodeStubInterface) peer.Response {35	return shim.Success(nil)36}37func (t *AnchorResolve) Invoke(stub shim.ChaincodeStubInterface) peer.Response {38	fn, args := stub.GetFunctionAndParameters()39	if fn == "resolveAnchor" {40		result, err = resolveAnchor(stub, args)41		if err != nil {42			return shim.Error(err.Error())

ResolveAnchor

Using AI Code Generation

1import (2func main() {3	c, err := util.ReadConfig("../../util/config.yml")4	if err != nil {5		fmt.Printf(err.Error())6	}7	conConf := &config.ConnectionConfig{8	}9	fmt.Println("Opening connection to database, configuration: ", c.ConnectionConfig)10	db, err := bcdb.Create(conConf)11	if err != nil {12		fmt.Printf("Database connection creating failed, reason: %s\n", err.Error())13	}14	fmt.Println("Opening data session")15	sessionConf := &config.SessionConfig{16	}17	session, err := db.Session(sessionConf)18	if err != nil {19		fmt.Printf("Data session creating failed, reason: %s\n", err.Error())20	}21	anchor, err := session.DataTx().Anchors().Create("anchor2", []byte("anchor2"))22	if err != nil {23		fmt.Printf("Anchor creation failed, reason: %s\n", err.Error())24	}25	anchorResolve, err := session.DataTx().Anchors().ResolveAnchor(anchor.AnchorID)26	if err != nil {27		fmt.Printf("Anchor resolving failed, reason: %s\n", err.Error())28	}29	fmt.Printf("Anchor resolved successfully. AnchorID: %s, AnchorValue: %s\n", anchorResolve.AnchorID, anchorResolve.AnchorValue)30}31Opening connection to database, configuration:  {Type:LevelDB ReplicaSet:map[localhost:50051:0xc0000c4b40] RootCAs:map[]}32import (

ResolveAnchor

Using AI Code Generation

1import (2func main() {3    err := shim.Start(new(Chaincode))4    if err != nil {5        fmt.Printf("Error starting chaincode: %s", err)6    }7}8type Chaincode struct {9}10func (t *Chaincode) Init(stub shim.ChaincodeStubInterface, function string, args []string) ([]byte, error) {11}12func (t *Chaincode) Invoke(stub shim.ChaincodeStubInterface, function string, args []string) ([]byte, error) {13    if function == "createAnchor" {14        return t.createAnchor(stub, args)15    } else if function == "resolveAnchor" {16        return t.resolveAnchor(stub, args)17    }18}19func (t *Chaincode) createAnchor(stub shim.ChaincodeStubInterface, args []string) ([]byte, error) {20    anchor := &shim.Anchor{21    }22    err := stub.CreateAnchor(anchor)23    if err != nil {24    }25}26func (t *Chaincode) resolveAnchor(stub shim.ChaincodeStubInterface, args []string) ([]byte, error) {27    anchor, err := stub.ResolveAnchor(args[0])28    if err != nil {29    }30    fmt.Printf("anchor value: %s", anchor.Value)31}

ResolveAnchor

Using AI Code Generation

1import (2func main() {3    stub := shim.NewMockStub("mockStub", nil)4    err := stub.MockTransactionStart("tx1")5    if err != nil {6        fmt.Println(err)7    }

ResolveAnchor

Using AI Code Generation

1import (2type Chaincode struct {3}4func (t *Chaincode) Init(stub shim.ChaincodeStubInterface) peer.Response {5	return shim.Success(nil)6}7func (t *Chaincode) Invoke(stub shim.ChaincodeStubInterface) peer.Response {8	function, args := stub.GetFunctionAndParameters()9	if function == "ResolveAnchor" {10		return t.ResolveAnchor(stub, args)11	}12	return shim.Error("Invalid invoke function name. Expecting \"ResolveAnchor\"")13}14func (t *Chaincode) ResolveAnchor(stub shim.ChaincodeStubInterface, args []string) peer.Response {15	if len(args) != 3 {16		return shim.Error("Incorrect number of arguments. Expecting 3")17	}18	anchor, err := stub.ResolveAnchor(anchorName, anchorNamespace, anchorVersion)19	if err != nil {20		return shim.Error(err.Error())21	}22	anchorBytes, err := anchor.ToBytes()23	if err != nil {24		return shim.Error(err.Error())25	}26	return shim.Success(anchorBytes)27}28func main() {29	err := shim.Start(new(Chaincode))30	if err != nil {31		fmt.Printf("Error starting Chaincode: %s", err)32	}33}34import (35type Chaincode struct {36}37func (t *Chaincode) Init(stub shim.ChaincodeStubInterface) peer.Response {38	return shim.Success(nil)39}40func (t *Chaincode) Invoke(stub shim.ChaincodeStubInterface) peer.Response {41	function, args := stub.GetFunctionAndParameters()42	if function == "ResolveAnchor" {43		return t.ResolveAnchor(stub, args)44	}45	return shim.Error("Invalid invoke function name. Expecting \"ResolveAnchor\"")46}47func (t *Chaincode) ResolveAnchor(stub shim.ChaincodeStubInterface, args []string) peer.Response {48	if len(args) != 3 {49		return shim.Error("Incorrect number of

ResolveAnchor

Using AI Code Generation

1import (2type Chaincode struct {3}4func (t *Chaincode) Init(stub shim.ChaincodeStubInterface, function string, args []string) ([]byte, error) {5}6func (t *Chaincode) Invoke(stub shim.ChaincodeStubInterface, function string, args []string) ([]byte, error) {7}8func (t *Chaincode) Query(stub shim.ChaincodeStubInterface, function string, args []string) ([]byte, error) {9}10func main() {11    err := shim.Start(new(Chaincode))12    if err != nil {13        fmt.Printf("Error starting Chaincode: %s", err)14    }15}16import (17type Chaincode struct {18}19func (t *Chaincode) Init(stub shim.ChaincodeStubInterface, function string, args []string) ([]byte, error) {20}21func (t *Chaincode) Invoke(stub shim.ChaincodeStubInterface, function string, args []string) ([]byte, error) {22}23func (t *Chaincode) Query(stub shim.ChaincodeStubInterface, function string, args []string) ([]byte, error) {24}25func main() {26    err := shim.Start(new(Chaincode))27    if err != nil {28        fmt.Printf("Error starting Chaincode: %s", err)29    }30}31import (32type Chaincode struct {33}34func (t *Chaincode) Init(stub shim.ChaincodeStubInterface, function string, args []string) ([]byte, error) {35}36func (t *Chaincode) Invoke(stub shim.ChaincodeStubInterface, function string, args []string) ([]byte, error) {37}

ResolveAnchor

Using AI Code Generation

1import (2func main() {3	stub := shim.NewMockStub("ex02", new(SimpleChaincode))4	stub.MockTransactionStart("tx1")5	defer stub.MockTransactionEnd("tx1")6	res := stub.MockInvoke("1", [][]byte{[]byte("invoke"), []byte("a"), []byte("b"), []byte("10")})7	fmt.Println("res", res)8	res = stub.MockInvoke("2", [][]byte{[]byte("invoke"), []byte("b"), []byte("c"), []byte("10")})9	fmt.Println("res", res)10	res = stub.MockInvoke("3", [][]byte{[]byte("invoke"), []byte("c"), []byte("d"), []byte("10")})11	fmt.Println("res", res)12	res = stub.MockInvoke("4", [][]byte{[]byte("invoke"), []byte("d"), []byte("e"), []byte("10")})13	fmt.Println("res", res)14	res = stub.MockInvoke("5", [][]byte{[]byte("invoke"), []byte("e"), []byte("f"), []byte("10")})15	fmt.Println("res", res)16	res = stub.MockInvoke("6", [][]byte{[]byte("invoke"), []byte("f"), []byte("g"), []byte("10")})17	fmt.Println("res", res)18	res = stub.MockInvoke("7", [][]byte{[]byte("invoke"), []byte("g"), []byte("h"), []byte("10")})19	fmt.Println("res", res)20	res = stub.MockInvoke("8", [][]byte{[]byte("invoke"), []byte("h"), []byte("i"), []byte("10")})21	fmt.Println("res", res)22	res = stub.MockInvoke("9", [][]byte{[]byte("invoke"), []byte("i"), []byte("j"), []byte("10")})23	fmt.Println("res", res)24	res = stub.MockInvoke("10", [][]byte{[]byte("invoke"), []byte("j"), []byte("k"), []byte("10")})25	fmt.Println("res", res)26	res = stub.MockInvoke("11", [][]byte{[]byte("invoke"), []byte("k"), []byte("l"), []byte

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.