Add benchmarks for fabtoken

Signed-off-by: Shashank <yshashank959@gmail.com>

Author: Rozerxshashank

token/core/fabtoken/v1/issue_test.go

@@ -12,6 +12,7 @@ import (
 
 	"github.com/hyperledger-labs/fabric-token-sdk/token/driver"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/driver/mock"
+	benchmark2 "github.com/hyperledger-labs/fabric-token-sdk/token/services/benchmark"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/token"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -187,3 +188,115 @@ func TestDeserializeIssueAction(t *testing.T) {
 		require.Error(t, err)
 	})
 }
+
+// BenchmarkIssueServiceIssue benchmarks the Issue method of the IssueService.
+func BenchmarkIssueServiceIssue(b *testing.B) {
+	_, _, cases, err := benchmark2.GenerateCasesWithDefaults()
+	require.NoError(b, err)
+
+	for _, tc := range cases {
+		b.Run(tc.Name, func(b *testing.B) {
+			env, err := newBenchmarkIssueEnv(b.N, tc.BenchmarkCase)
+			require.NoError(b, err)
+
+			b.ResetTimer()
+			i := 0
+			for b.Loop() {
+				e := env.Envs[i%len(env.Envs)]
+				action, _, err := e.is.Issue(
+					b.Context(),
+					e.issuer,
+					e.tokenType,
+					e.values,
+					e.owners,
+					nil,
+				)
+				require.NoError(b, err)
+				require.NotNil(b, action)
+				i++
+			}
+		})
+	}
+}
+
+// TestParallelBenchmarkIssueServiceIssue runs the issue benchmark in parallel.
+func TestParallelBenchmarkIssueServiceIssue(t *testing.T) {
+	_, _, cases, err := benchmark2.GenerateCasesWithDefaults()
+	require.NoError(t, err)
+
+	test := benchmark2.NewTest[*benchmarkIssueEnv](cases)
+	test.RunBenchmark(t,
+		func(c *benchmark2.Case) (*benchmarkIssueEnv, error) {
+			return newBenchmarkIssueEnv(1, c)
+		},
+		func(ctx context.Context, env *benchmarkIssueEnv) error {
+			action, _, err := env.Envs[0].is.Issue(
+				ctx,
+				env.Envs[0].issuer,
+				env.Envs[0].tokenType,
+				env.Envs[0].values,
+				env.Envs[0].owners,
+				nil,
+			)
+			if err != nil {
+				return err
+			}
+			_, err = action.Serialize()
+			return err
+		},
+	)
+}
+
+type issueEnv struct {
+	is        *IssueService
+	issuer    driver.Identity
+	tokenType token.Type
+	values    []uint64
+	owners    [][]byte
+}
+
+func newIssueEnv(benchmarkCase *benchmark2.Case) (*issueEnv, error) {
+	ppm := &mock.PublicParamsManager{}
+	pp := &mock.PublicParameters{}
+	pp.PrecisionReturns(64)
+	ppm.PublicParametersReturns(pp)
+
+	ws := &mock.WalletService{}
+	des := &mock.Deserializer{}
+	is := NewIssueService(ppm, ws, des)
+
+	issuer := driver.Identity("issuer")
+	tokenType := token.Type("ABC")
+	values := make([]uint64, benchmarkCase.NumOutputs)
+	owners := make([][]byte, benchmarkCase.NumOutputs)
+	for i := range values {
+		values[i] = uint64(i)*10 + 10
+		owners[i] = []byte("owner")
+	}
+
+	des.GetAuditInfoReturns([]byte("audit"), nil)
+
+	return &issueEnv{
+		is:        is,
+		issuer:    issuer,
+		tokenType: tokenType,
+		values:    values,
+		owners:    owners,
+	}, nil
+}
+
+type benchmarkIssueEnv struct {
+	Envs []*issueEnv
+}
+
+func newBenchmarkIssueEnv(n int, benchmarkCase *benchmark2.Case) (*benchmarkIssueEnv, error) {
+	envs := make([]*issueEnv, n)
+	for i := range n {
+		env, err := newIssueEnv(benchmarkCase)
+		if err != nil {
+			return nil, err
+		}
+		envs[i] = env
+	}
+	return &benchmarkIssueEnv{Envs: envs}, nil
+}

token/core/fabtoken/v1/transfer_test.go

@@ -8,6 +8,7 @@ package v1_test
 
 import (
 	"context"
+	"strconv"
 	"testing"
 
 	"github.com/hyperledger-labs/fabric-smart-client/pkg/utils/errors"
@@ -16,6 +17,7 @@ import (
 	"github.com/hyperledger-labs/fabric-token-sdk/token/core/fabtoken/v1/setup"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/driver"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/driver/mock"
+	benchmark2 "github.com/hyperledger-labs/fabric-token-sdk/token/services/benchmark"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/services/logging"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/services/ttx"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/token"
@@ -309,3 +311,130 @@ func TestTransferService(t *testing.T) {
 		require.Error(t, err)
 	})
 }
+
+// BenchmarkTransferServiceTransfer benchmarks the Transfer method of the TransferService.
+func BenchmarkTransferServiceTransfer(b *testing.B) {
+	_, _, cases, err := benchmark2.GenerateCasesWithDefaults()
+	require.NoError(b, err)
+
+	for _, tc := range cases {
+		b.Run(tc.Name, func(b *testing.B) {
+			env, err := newBenchmarkTransferEnv(b.N, tc.BenchmarkCase)
+			require.NoError(b, err)
+
+			b.ResetTimer()
+			i := 0
+			for b.Loop() {
+				e := env.Envs[i%len(env.Envs)]
+				action, _, err := e.ts.Transfer(
+					b.Context(),
+					"an_anchor",
+					nil,
+					e.ids,
+					e.outputs,
+					nil,
+				)
+				require.NoError(b, err)
+				require.NotNil(b, action)
+				i++
+			}
+		})
+	}
+}
+
+// TestParallelBenchmarkTransferServiceTransfer runs the transfer benchmark in parallel.
+func TestParallelBenchmarkTransferServiceTransfer(t *testing.T) {
+	_, _, cases, err := benchmark2.GenerateCasesWithDefaults()
+	require.NoError(t, err)
+
+	test := benchmark2.NewTest[*benchmarkTransferEnv](cases)
+	test.RunBenchmark(t,
+		func(c *benchmark2.Case) (*benchmarkTransferEnv, error) {
+			return newBenchmarkTransferEnv(1, c)
+		},
+		func(ctx context.Context, env *benchmarkTransferEnv) error {
+			action, _, err := env.Envs[0].ts.Transfer(
+				ctx,
+				"an_anchor",
+				nil,
+				env.Envs[0].ids,
+				env.Envs[0].outputs,
+				nil,
+			)
+			if err != nil {
+				return err
+			}
+			_, err = action.Serialize()
+			return err
+		},
+	)
+}
+
+type transferEnv struct {
+	ts      *v1.TransferService
+	outputs []*token.Token
+	ids     []*token.ID
+}
+
+func newTransferEnv(benchmarkCase *benchmark2.Case) (*transferEnv, error) {
+	logger := logging.MustGetLogger("test")
+	ppm := &mockPublicParamsManager{PublicParamsManager: &mock.PublicParamsManager{}}
+	pp, err := setup.Setup(64)
+	if err != nil {
+		return nil, err
+	}
+	ppm.PublicParametersReturns(pp)
+
+	ws := &mock.WalletService{}
+	tl := &MockTokenLoader{}
+	des := &mock.Deserializer{}
+	ts := v1.NewTransferService(logger, ppm, ws, tl, des)
+
+	outputs := make([]*token.Token, benchmarkCase.NumOutputs)
+	for i := range outputs {
+		outputs[i] = &token.Token{
+			Owner:    []byte("owner2"),
+			Type:     "ABC",
+			Quantity: token.NewQuantityFromUInt64(uint64(i)*10 + 10).Hex(),
+		}
+	}
+
+	ids := make([]*token.ID, benchmarkCase.NumInputs)
+	inputTokens := make([]*token.Token, benchmarkCase.NumInputs)
+	for i := range ids {
+		ids[i] = &token.ID{TxId: strconv.Itoa(i), Index: 0}
+		inputTokens[i] = &token.Token{
+			Owner:    []byte("owner1"),
+			Type:     "ABC",
+			Quantity: token.NewQuantityFromUInt64(uint64(i)*10 + 10).Hex(),
+		}
+	}
+
+	tl.GetTokensStub = func(ctx context.Context, ids []*token.ID) ([]*token.Token, error) {
+		return inputTokens, nil
+	}
+	des.GetAuditInfoReturns([]byte("audit"), nil)
+	des.RecipientsReturns([]driver.Identity{[]byte("owner2")}, nil)
+
+	return &transferEnv{
+		ts:      ts,
+		outputs: outputs,
+		ids:     ids,
+	}, nil
+}
+
+type benchmarkTransferEnv struct {
+	Envs []*transferEnv
+}
+
+func newBenchmarkTransferEnv(n int, benchmarkCase *benchmark2.Case) (*benchmarkTransferEnv, error) {
+	envs := make([]*transferEnv, n)
+	for i := range n {
+		env, err := newTransferEnv(benchmarkCase)
+		if err != nil {
+			return nil, err
+		}
+		envs[i] = env
+	}
+	return &benchmarkTransferEnv{Envs: envs}, nil
+}