You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: wrapped_hash_test.go
    path of file: ./repos/gnark/std/recursion
    
    the code of the file until where you have to start completion: package recursion_test

import (
	"crypto/rand"
	"fmt"
	"math/big"
	"testing"

	"github.com/consensys/gnark-crypto/ecc"
	bls12377 "github.com/consensys/gnark-crypto/ecc/bls12-377"
	fr_bls12377 "github.com/consensys/gnark-crypto/ecc/bls12-377/fr"
	bls24315 "github.com/consensys/gnark-crypto/ecc/bls24-315"
	fr_bls24315 "github.com/consensys/gnark-crypto/ecc/bls24-315/fr"
	bw6761 "github.com/consensys/gnark-crypto/ecc/bw6-761"
	fr_bw6761 "github.com/consensys/gnark-crypto/ecc/bw6-761/fr"
	cryptofs "github.com/consensys/gnark-crypto/fiat-shamir"
	"github.com/consensys/gnark/frontend"
	"github.com/consensys/gnark/std/algebra"
	"github.com/consensys/gnark/std/algebra/emulated/sw_bw6761"
	"github.com/consensys/gnark/std/algebra/native/sw_bls12377"
	"github.com/consensys/gnark/std/algebra/native/sw_bls24315"
	"github.com/consensys/gnark/std/math/emulated"
	"github.com/consensys/gnark/std/recursion"
	"github.com/consensys/gnark/test"
)

type shortHashCircuit struct {
	Input  []frontend.Variable
	Output frontend.Variable
	inner  ecc.ID
}

func (c *shortHashCircuit) Define(api frontend.API) error {
	hasher, err := recursion.NewHash(api, c.inner.ScalarField(), false)
	if err != nil {
		return err
	}
	for i := range c.Input {
		hasher.Write(c.Input[i])
	}
	res := hasher.Sum()
	api.AssertIsEqual(c.Output, res)
	return nil
}

func TestShortHash(t *testing.T) {
	outerCurves := []ecc.ID{
		ecc.BN254,
		ecc.BLS12_377,
		ecc.BW6_761,
	}
	innerCurves := []ecc.I
    
func TestTranscriptMarshal(t *testing.T) {
	assert := test.NewAssert(t)
	assert.Run(func(assert *test.Assert) {
		h, err := recursion.NewShort(ecc.BW6_761.ScalarField(), ecc.BLS12_377.ScalarField())
		assert.NoError(err)
		challenges := [3]string{"alfa", "beta", "gamma"}
		fs := cryptofs.NewTranscript(h, challenges[:]...)
		var points [3][3]sw_bls12377.G1Affine
		for i := range points {
			for j := range points[i] {
				var p bls12377.G1Affine
				r, err := rand.Int(rand.Reader, ecc.BLS12_377.ScalarField())
				assert.NoError(err)
				p.ScalarMultiplicationBase(r)
				points[i][j] = sw_bls12377.NewG1Affine(p)
				if err := fs.Bind(challenges[i], p.Marshal()); err != nil {
					t.Fatal("bind", err)
				}
			}
		}
		var expected [3]frontend.Variable
		for i := range expected {
			res, err := fs.ComputeChallenge(challenges[i])
			assert.NoError(err)
			expected[i] = res
		}
		circuit := &transcriptCircuit[sw_bls12377.ScalarField, sw_bls12377.G1Affine]{
			Challenges: challenges,
		}
		assignment := &transcriptCircuit[sw_bls12377.ScalarField, sw_bls12377.G1Affine]{
			Challenges: challenges,
			Points:     points,
			Expected:   expected,
		}
		assert.CheckCircuit(circuit, test.WithValidAssignment(assignment), test.WithCurves(ecc.BW6_761), test.NoFuzzing(), test.NoSerializationChecks(), test.NoProverChecks())
	}, "bw6_761")
	assert.Run(func(assert *test.Assert) {
		h, err := recursion.NewShort(ecc.BN254.ScalarField(), ecc.BW6_761.ScalarField())
		assert.NoError(err)
		challenges := [3]string{"alfa", "beta", "gamma"}
		fs := cryptofs.NewTranscript(h, challenges[:]...)
		var points [3][3]sw_bw6761.G1Affine
		for i := range points {
			for j := range points[i] {
				var p bw6761.G1Affine
				r, err := rand.Int(rand.Reader, ecc.BW6_761.ScalarField())
				assert.NoError(err)
				p.ScalarMultiplicationBase(r)
				points[i][j] = sw_bw6761.NewG1Affine(p)
				if err := fs.Bind(challenges[i], p.Marshal()); err != nil {
					t.Fatal("bind", err)
				}
			}
		}
		var expected [3]frontend.Variable
		for i := range expected {
			res, err := fs.ComputeChallenge(challenges[i])
			assert.NoError(err)
			expected[i] = res
		}
		circuit := &transcriptCircuit[sw_bw6761.ScalarField, sw_bw6761.G1Affine]{
			Challenges: challenges,
		}
		assignment := &transcriptCircuit[sw_bw6761.ScalarField, sw_bw6761.G1Affine]{
			Challenges: challenges,
			Points:     points,
			Expected:   expected,
		}
		assert.CheckCircuit(circuit, test.WithValidAssignment(assignment), test.WithCurves(ecc.BN254), test.NoFuzzing(), test.NoSerializationChecks(), test.NoProverChecks())
	}, "bn254")
}