From 148a8f3e34ee4877503d39d49edf13a97bc94143 Mon Sep 17 00:00:00 2001 From: Tristan <122918260+TAdev0@users.noreply.github.com> Date: Tue, 6 Aug 2024 06:05:51 +0200 Subject: [PATCH] feat: `Sha256` utils tests + chore improvements (#622) * various improvements * fmt --- cmd/casm-inspect/disasm.go | 8 ++-- cmd/casm-inspect/inst_fields.go | 4 +- pkg/disasm/casm.go | 4 +- pkg/disasm/disasm.go | 4 +- pkg/disasm/disassembler.go | 6 +-- pkg/disasm/utils.go | 4 +- pkg/hintrunner/zero/zerohint_blake.go | 2 +- pkg/hintrunner/zero/zerohint_ec.go | 23 ++++++----- pkg/hintrunner/zero/zerohint_keccak.go | 15 +++++++ pkg/parsers/starknet/starknet.go | 10 ++--- pkg/parsers/zero/integration_test.go | 1 - pkg/runners/cairo/cairo.go | 1 + pkg/runners/cairo/cairo_test.go | 1 + pkg/runners/cairo/program.go | 1 + pkg/runners/cairo/program_test.go | 1 + pkg/runners/zero/program.go | 8 ++-- pkg/runners/zero/program_test.go | 11 +++--- pkg/utils/blake_test.go | 55 -------------------------- pkg/utils/math_test.go | 55 ++++++++++++++++++++++++++ pkg/utils/sha256_test.go | 38 ++++++++++++++++++ 20 files changed, 157 insertions(+), 95 deletions(-) delete mode 100644 pkg/parsers/zero/integration_test.go create mode 100644 pkg/runners/cairo/cairo.go create mode 100644 pkg/runners/cairo/cairo_test.go create mode 100644 pkg/runners/cairo/program.go create mode 100644 pkg/runners/cairo/program_test.go create mode 100644 pkg/utils/sha256_test.go diff --git a/cmd/casm-inspect/disasm.go b/cmd/casm-inspect/disasm.go index 21ee4534f..d4779a1a7 100644 --- a/cmd/casm-inspect/disasm.go +++ b/cmd/casm-inspect/disasm.go @@ -7,7 +7,7 @@ import ( "strings" "github.com/NethermindEth/cairo-vm-go/pkg/disasm" - f "github.com/consensys/gnark-crypto/ecc/stark-curve/fp" + "github.com/consensys/gnark-crypto/ecc/stark-curve/fp" "github.com/urfave/cli/v2" ) @@ -19,7 +19,7 @@ type disasmProgram struct { rawCasm map[string]any - bytecode []*f.Element + bytecode []*fp.Element disassembled *disasm.Program } @@ -78,13 +78,13 @@ func (p *disasmProgram) loadBytecodeStep() error { return fmt.Errorf("%q: expected a slice of strings", p.bytecodeKey) } - p.bytecode = make([]*f.Element, 0, len(slice)) + p.bytecode = make([]*fp.Element, 0, len(slice)) for i, s := range slice { s, ok := s.(string) if !ok { return fmt.Errorf("%q: expected a slice of strings, found %T", p.bytecodeKey, slice[i]) } - felt, err := new(f.Element).SetString(s) + felt, err := new(fp.Element).SetString(s) if err != nil { return fmt.Errorf("%q[%d]: parse %q: %w", p.bytecodeKey, i, s, err) } diff --git a/cmd/casm-inspect/inst_fields.go b/cmd/casm-inspect/inst_fields.go index 528693682..14c79b5fb 100644 --- a/cmd/casm-inspect/inst_fields.go +++ b/cmd/casm-inspect/inst_fields.go @@ -5,7 +5,7 @@ import ( "fmt" "strings" - f "github.com/consensys/gnark-crypto/ecc/stark-curve/fp" + "github.com/consensys/gnark-crypto/ecc/stark-curve/fp" "github.com/urfave/cli/v2" ) @@ -18,7 +18,7 @@ func (p *instFieldsProgram) Action(ctx *cli.Context) error { return errors.New("expected 1 non-empty positional argument") } - felt, err := new(f.Element).SetString(s) + felt, err := new(fp.Element).SetString(s) if err != nil { return fmt.Errorf("parsing %q argument: %w", s, err) } diff --git a/pkg/disasm/casm.go b/pkg/disasm/casm.go index 2840afbf7..0d26d5856 100644 --- a/pkg/disasm/casm.go +++ b/pkg/disasm/casm.go @@ -2,13 +2,13 @@ package disasm import ( "github.com/NethermindEth/cairo-vm-go/pkg/assembler" - f "github.com/consensys/gnark-crypto/ecc/stark-curve/fp" + "github.com/consensys/gnark-crypto/ecc/stark-curve/fp" ) type casmInstruction struct { *assembler.Instruction - arg *f.Element + arg *fp.Element bytecodeOffset int64 } diff --git a/pkg/disasm/disasm.go b/pkg/disasm/disasm.go index 74fef9dda..28df8e1c5 100644 --- a/pkg/disasm/disasm.go +++ b/pkg/disasm/disasm.go @@ -1,7 +1,7 @@ package disasm import ( - f "github.com/consensys/gnark-crypto/ecc/stark-curve/fp" + "github.com/consensys/gnark-crypto/ecc/stark-curve/fp" ) type Program struct { @@ -14,7 +14,7 @@ type Line struct { } type Config struct { - Bytecode []*f.Element + Bytecode []*fp.Element Indent int } diff --git a/pkg/disasm/disassembler.go b/pkg/disasm/disassembler.go index c0039778b..fb55302dd 100644 --- a/pkg/disasm/disassembler.go +++ b/pkg/disasm/disassembler.go @@ -5,11 +5,11 @@ import ( "strings" "github.com/NethermindEth/cairo-vm-go/pkg/assembler" - f "github.com/consensys/gnark-crypto/ecc/stark-curve/fp" + "github.com/consensys/gnark-crypto/ecc/stark-curve/fp" ) type disassembler struct { - bytecode []*f.Element + bytecode []*fp.Element config Config @@ -161,7 +161,7 @@ func (d *disassembler) collectInstComments(inst casmInstruction) ([]string, erro // > assert [fp+1] = [fp] * 2894802230932904970957858226476056084498485772265277359978473644908697616385 // div 5 imm := inst.arg if inst.Res == assembler.MulOperands && !imm.IsUint64() { - dividend := f.NewElement(0) + dividend := fp.NewElement(0) dividend.Inverse(imm) // If divident is a very large number, then we could got it wrong. if dividend.IsUint64() { diff --git a/pkg/disasm/utils.go b/pkg/disasm/utils.go index 6167abdbd..ed24b3f3b 100644 --- a/pkg/disasm/utils.go +++ b/pkg/disasm/utils.go @@ -3,10 +3,10 @@ package disasm import ( "strconv" - f "github.com/consensys/gnark-crypto/ecc/stark-curve/fp" + "github.com/consensys/gnark-crypto/ecc/stark-curve/fp" ) -func feltToInt64(felt *f.Element) int64 { +func feltToInt64(felt *fp.Element) int64 { // This would not be correct: int64(felt.Uint64) // since signed values will reside in more than one 64-bit word. // diff --git a/pkg/hintrunner/zero/zerohint_blake.go b/pkg/hintrunner/zero/zerohint_blake.go index c2c223b90..0c7e8b264 100644 --- a/pkg/hintrunner/zero/zerohint_blake.go +++ b/pkg/hintrunner/zero/zerohint_blake.go @@ -273,8 +273,8 @@ func newBlake2sFinalizeV3Hint(blake2sPtrEnd hinter.ResOperander) hinter.Hinter { return err } *blake2sPtrEnd = temp - } + return nil }, } diff --git a/pkg/hintrunner/zero/zerohint_ec.go b/pkg/hintrunner/zero/zerohint_ec.go index 070174c17..1c62afd51 100644 --- a/pkg/hintrunner/zero/zerohint_ec.go +++ b/pkg/hintrunner/zero/zerohint_ec.go @@ -13,13 +13,13 @@ import ( "github.com/holiman/uint256" ) -// getHighLen calculates the highest bit length of `scalar_u.d2` and `scalar_v.d2`, -// subtracts 1 from the result, and assigns it to `ids.len_hi`. +// GetHighLen hint calculates the highest bit length between `scalar_u.d2` and `scalar_v.d2`, +// subtracts 1 from the result, and assigns it to `ids.len_hi` // -// `newGetHighLenHint` takes three operanders as arguments: -// - `len_hi`: the variable that will store the result of the bit-length calculation. -// - `scalar_u.d2`: the first scalar value. -// - `scalar_v.d2`: the second scalar value. +// `newGetHighLenHint` takes 3 operanders as arguments: +// - `len_hi`: the variable that will store the result of the bit-length calculation +// - `scalar_u.d2`: the first scalar value +// - `scalar_v.d2`: the second scalar value func newGetHighLenHint(len_hi, scalar_u, scalar_v hinter.ResOperander) hinter.Hinter { return &GenericZeroHinter{ Name: "GetHighLen", @@ -47,10 +47,10 @@ func newGetHighLenHint(len_hi, scalar_u, scalar_v hinter.ResOperander) hinter.Hi } var scalarUD2 big.Int - scalarUD2 = *scalarUValues[2].BigInt(&scalarUD2) + _ = *scalarUValues[2].BigInt(&scalarUD2) var scalarVD2 big.Int - scalarVD2 = *scalarVValues[2].BigInt(&scalarVD2) + _ = *scalarVValues[2].BigInt(&scalarVD2) bitLenU := scalarUD2.BitLen() bitLenV := scalarVD2.BitLen() @@ -74,18 +74,21 @@ func createGetHighLenHinter(resolver hintReferenceResolver) (hinter.Hinter, erro if err != nil { return nil, err } + scalar_u, err := resolver.GetResOperander("scalar_u") if err != nil { return nil, err } + scalar_v, err := resolver.GetResOperander("scalar_v") if err != nil { return nil, err } + return newGetHighLenHint(len_hi, scalar_u, scalar_v), nil } -// BigIntToUint256 hint guesses the low part of the result uint256 variable +// BigIntToUint256 hint guesses the low part of the `x` uint256 variable // // `newBigIntToUint256Hint` takes 2 operanders as arguments // - `low` is the variable that will store the low part of the uint256 result @@ -221,6 +224,8 @@ func createEcNegateHinter(resolver hintReferenceResolver) (hinter.Hinter, error) // the multiplication of `res` and `b` subtracted by `a`, by `N`. It then adds 1 // to the final result to ensure safety and prevent division by zero errors. // +// `newDivModNSafeDivPlusOneHint` doens't take any operander as argument +// // `DivModeNSafeDivPlusOne` assigns the result as `value` in the current scope. func newDivModNSafeDivPlusOneHint() hinter.Hinter { return &GenericZeroHinter{ diff --git a/pkg/hintrunner/zero/zerohint_keccak.go b/pkg/hintrunner/zero/zerohint_keccak.go index a211690c8..3b01f5855 100644 --- a/pkg/hintrunner/zero/zerohint_keccak.go +++ b/pkg/hintrunner/zero/zerohint_keccak.go @@ -45,10 +45,12 @@ func newCairoKeccakFinalizeHint(keccakPtrEnd hinter.ResOperander) hinter.Hinter for i := uint64(0); i < blockSizeVal; i++ { result = append(result, padding...) } + keccakPtrEnd, err := hinter.ResolveAsAddress(vm, keccakPtrEnd) if err != nil { return err } + for i := 0; i < len(result); i++ { resultMV := memory.MemoryValueFromUint(result[i]) err = vm.Memory.WriteToAddress(keccakPtrEnd, &resultMV) @@ -61,6 +63,7 @@ func newCairoKeccakFinalizeHint(keccakPtrEnd hinter.ResOperander) hinter.Hinter } keccakPtrEnd = &keccakPtrEndIncremented } + return nil }, } @@ -71,6 +74,7 @@ func createCairoKeccakFinalizeHinter(resolver hintReferenceResolver) (hinter.Hin if err != nil { return nil, err } + return newCairoKeccakFinalizeHint(keccakPtrEnd), nil } @@ -149,6 +153,7 @@ func newUnsafeKeccakHint(data, length, high, low hinter.ResOperander) hinter.Hin return err } } + hash := sha3.NewLegacyKeccak256() hash.Write(keccakInput) //> hashed = keccak(keccak_input) @@ -160,15 +165,18 @@ func newUnsafeKeccakHint(data, length, high, low hinter.ResOperander) hinter.Hin return err } hashedHighMV := memory.MemoryValueFromFieldElement(hashedHigh) + //> ids.high = int.from_bytes(hashed[:16], 'big') err = vm.Memory.WriteToAddress(&highAddr, &hashedHighMV) if err != nil { return err } + lowAddr, err := low.GetAddress(vm) if err != nil { return err } + hashedLowMV := memory.MemoryValueFromFieldElement(hashedLow) //> ids.low = int.from_bytes(hashed[16:32], 'big') return vm.Memory.WriteToAddress(&lowAddr, &hashedLowMV) @@ -181,18 +189,22 @@ func createUnsafeKeccakHinter(resolver hintReferenceResolver) (hinter.Hinter, er if err != nil { return nil, err } + length, err := resolver.GetResOperander("length") if err != nil { return nil, err } + high, err := resolver.GetResOperander("high") if err != nil { return nil, err } + low, err := resolver.GetResOperander("low") if err != nil { return nil, err } + return newUnsafeKeccakHint(data, length, high, low), nil } @@ -302,14 +314,17 @@ func createUnsafeKeccakFinalizeHinter(resolver hintReferenceResolver) (hinter.Hi if err != nil { return nil, err } + high, err := resolver.GetResOperander("high") if err != nil { return nil, err } + low, err := resolver.GetResOperander("low") if err != nil { return nil, err } + return newUnsafeKeccakFinalizeHint(keccak_state, high, low), nil } diff --git a/pkg/parsers/starknet/starknet.go b/pkg/parsers/starknet/starknet.go index eab3caa71..2423effc8 100644 --- a/pkg/parsers/starknet/starknet.go +++ b/pkg/parsers/starknet/starknet.go @@ -6,7 +6,7 @@ import ( "os" "strconv" - f "github.com/consensys/gnark-crypto/ecc/stark-curve/fp" + "github.com/consensys/gnark-crypto/ecc/stark-curve/fp" ) type Builtin uint8 @@ -80,9 +80,9 @@ func (b *Builtin) UnmarshalJSON(data []byte) error { } type EntryPointInfo struct { - Selector f.Element `json:"selector"` - Offset f.Element `json:"offset"` - Builtins []Builtin `json:"builtins"` + Selector fp.Element `json:"selector"` + Offset fp.Element `json:"offset"` + Builtins []Builtin `json:"builtins"` } type EntryPointByType struct { @@ -133,7 +133,7 @@ func (hints *Hints) MarshalJSON() ([]byte, error) { type StarknetProgram struct { // Prime is fixed to be 0x800000000000011000000000000000000000000000000000000000000000001 and wont fit in a f.Felt - Bytecode []f.Element `json:"bytecode"` + Bytecode []fp.Element `json:"bytecode"` CompilerVersion string `json:"compiler_version"` EntryPoints EntryPointByType `json:"entry_points_by_type"` Hints []Hints `json:"hints" validate:"required"` diff --git a/pkg/parsers/zero/integration_test.go b/pkg/parsers/zero/integration_test.go deleted file mode 100644 index 8cdca9c1f..000000000 --- a/pkg/parsers/zero/integration_test.go +++ /dev/null @@ -1 +0,0 @@ -package zero diff --git a/pkg/runners/cairo/cairo.go b/pkg/runners/cairo/cairo.go new file mode 100644 index 000000000..fedf8a0ad --- /dev/null +++ b/pkg/runners/cairo/cairo.go @@ -0,0 +1 @@ +package cairo diff --git a/pkg/runners/cairo/cairo_test.go b/pkg/runners/cairo/cairo_test.go new file mode 100644 index 000000000..fedf8a0ad --- /dev/null +++ b/pkg/runners/cairo/cairo_test.go @@ -0,0 +1 @@ +package cairo diff --git a/pkg/runners/cairo/program.go b/pkg/runners/cairo/program.go new file mode 100644 index 000000000..fedf8a0ad --- /dev/null +++ b/pkg/runners/cairo/program.go @@ -0,0 +1 @@ +package cairo diff --git a/pkg/runners/cairo/program_test.go b/pkg/runners/cairo/program_test.go new file mode 100644 index 000000000..fedf8a0ad --- /dev/null +++ b/pkg/runners/cairo/program_test.go @@ -0,0 +1 @@ +package cairo diff --git a/pkg/runners/zero/program.go b/pkg/runners/zero/program.go index 3ca5ce40b..022186347 100644 --- a/pkg/runners/zero/program.go +++ b/pkg/runners/zero/program.go @@ -5,12 +5,12 @@ import ( sn "github.com/NethermindEth/cairo-vm-go/pkg/parsers/starknet" "github.com/NethermindEth/cairo-vm-go/pkg/parsers/zero" - f "github.com/consensys/gnark-crypto/ecc/stark-curve/fp" + "github.com/consensys/gnark-crypto/ecc/stark-curve/fp" ) type Program struct { // the bytecode in string format - Bytecode []*f.Element + Bytecode []*fp.Element // given a string it returns the pc for that function call Entrypoints map[string]uint64 // it stores the start and end label pcs @@ -21,9 +21,9 @@ type Program struct { func LoadCairoZeroProgram(cairoZeroJson *zero.ZeroProgram) (*Program, error) { // bytecode - bytecode := make([]*f.Element, len(cairoZeroJson.Data)) + bytecode := make([]*fp.Element, len(cairoZeroJson.Data)) for i := range cairoZeroJson.Data { - felt, err := new(f.Element).SetString(cairoZeroJson.Data[i]) + felt, err := new(fp.Element).SetString(cairoZeroJson.Data[i]) if err != nil { return nil, fmt.Errorf( "cannot read bytecode %s at position %d: %w", diff --git a/pkg/runners/zero/program_test.go b/pkg/runners/zero/program_test.go index 64a65f0c3..63f274e27 100644 --- a/pkg/runners/zero/program_test.go +++ b/pkg/runners/zero/program_test.go @@ -1,10 +1,11 @@ package zero import ( - f "github.com/consensys/gnark-crypto/ecc/stark-curve/fp" - "github.com/stretchr/testify/require" "testing" + "github.com/consensys/gnark-crypto/ecc/stark-curve/fp" + "github.com/stretchr/testify/require" + zero "github.com/NethermindEth/cairo-vm-go/pkg/parsers/zero" ) @@ -33,8 +34,8 @@ func TestLoadCairoZeroProgram(t *testing.T) { } `) - stringToFelt := func(bytecode string) *f.Element { - felt, err := new(f.Element).SetString(bytecode) + stringToFelt := func(bytecode string) *fp.Element { + felt, err := new(fp.Element).SetString(bytecode) if err != nil { panic(err) } @@ -50,7 +51,7 @@ func TestLoadCairoZeroProgram(t *testing.T) { require.NoError(t, err) require.Equal(t, &Program{ - Bytecode: []*f.Element{ + Bytecode: []*fp.Element{ stringToFelt("0x01"), stringToFelt("0x02"), stringToFelt("0x03"), diff --git a/pkg/utils/blake_test.go b/pkg/utils/blake_test.go index a374e82b1..dfe42615f 100644 --- a/pkg/utils/blake_test.go +++ b/pkg/utils/blake_test.go @@ -4,61 +4,6 @@ import ( "testing" ) -func TestRightRot(t *testing.T) { - testCases := []struct { - name string - value uint32 - n uint32 - expected uint32 - }{ - { - name: "Rotate 0 bits", - value: 0x12345678, - n: 0, - expected: 0x12345678, - }, - { - name: "Rotate 1 bit", - value: 0x12345678, - n: 1, - expected: 0x091A2B3C, - }, - { - name: "Rotate 4 bits", - value: 0x12345678, - n: 4, - expected: 0x81234567, - }, - { - name: "Rotate 8 bits", - value: 0x12345678, - n: 8, - expected: 0x78123456, - }, - { - name: "Rotate 16 bits", - value: 0x12345678, - n: 16, - expected: 0x56781234, - }, - { - name: "Rotate 31 bits", - value: 0x12345678, - n: 31, - expected: 0x2468ACF0, - }, - } - - for _, tc := range testCases { - t.Run(tc.name, func(t *testing.T) { - result := RightRot(tc.value, tc.n) - if result != tc.expected { - t.Errorf("Expected %08X, got %08X", tc.expected, result) - } - }) - } -} - // Result from CairoVM's blake2s implementation in Rust by Lambdaclass // https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=987596d755c09f8803a097d29594f92c diff --git a/pkg/utils/math_test.go b/pkg/utils/math_test.go index 5c1c1a3c1..62cd381eb 100644 --- a/pkg/utils/math_test.go +++ b/pkg/utils/math_test.go @@ -64,3 +64,58 @@ func TestFeltDivRem(t *testing.T) { } } } + +func TestRightRot(t *testing.T) { + testCases := []struct { + name string + value uint32 + n uint32 + expected uint32 + }{ + { + name: "Rotate 0 bits", + value: 0x12345678, + n: 0, + expected: 0x12345678, + }, + { + name: "Rotate 1 bit", + value: 0x12345678, + n: 1, + expected: 0x091A2B3C, + }, + { + name: "Rotate 4 bits", + value: 0x12345678, + n: 4, + expected: 0x81234567, + }, + { + name: "Rotate 8 bits", + value: 0x12345678, + n: 8, + expected: 0x78123456, + }, + { + name: "Rotate 16 bits", + value: 0x12345678, + n: 16, + expected: 0x56781234, + }, + { + name: "Rotate 31 bits", + value: 0x12345678, + n: 31, + expected: 0x2468ACF0, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + result := RightRot(tc.value, tc.n) + if result != tc.expected { + t.Errorf("Expected %08X, got %08X", tc.expected, result) + } + }) + } +} diff --git a/pkg/utils/sha256_test.go b/pkg/utils/sha256_test.go new file mode 100644 index 000000000..dad142a7c --- /dev/null +++ b/pkg/utils/sha256_test.go @@ -0,0 +1,38 @@ +package utils + +import ( + "testing" +) + +func TestComputeMessageSchedule(t *testing.T) { + input := []uint32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16} + + result, err := ComputeMessageSchedule(input) + if err != nil { + t.Errorf("ComputeMessageSchedule failed %d", err) + } + + expectedResult := []uint32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 67559435, 101367821, 3020350282, 1107812741, 3118632270, 451168464, 656601990, 3279804240, 1103585248, 461130233, 2653371037, 2175483678, 2971844087, 1030991300, 3974839675, 2477209260, 3279611694, 1561569730, 1603939653, 3189046280, 4224804089, 2646992545, 635753112, 4125081555, 1964552335, 2309306792, 2373507743, 259776332, 701344636, 482288624, 3399445588, 2053317424, 236667340, 3934934314, 1907271339, 4255195815, 3378026140, 502208176, 1352423260, 2851041892, 256006704, 1790616609, 1603953582, 1998049493, 4039401960, 3952946654, 3640193746, 113257106} + + for i := 0; i < len(result); i++ { + if result[i] != expectedResult[i] { + t.Errorf("Expected result = %d, got %d", result[i], expectedResult[i]) + } + } +} + +func TestSha256Compress(t *testing.T) { + w := []uint32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 67559435, 101367821, 3020350282, 1107812741, 3118632270, 451168464, 656601990, 3279804240, 1103585248, 461130233, 2653371037, 2175483678, 2971844087, 1030991300, 3974839675, 2477209260, 3279611694, 1561569730, 1603939653, 3189046280, 4224804089, 2646992545, 635753112, 4125081555, 1964552335, 2309306792, 2373507743, 259776332, 701344636, 482288624, 3399445588, 2053317424, 236667340, 3934934314, 1907271339, 4255195815, 3378026140, 502208176, 1352423260, 2851041892, 256006704, 1790616609, 1603953582, 1998049493, 4039401960, 3952946654, 3640193746, 113257106} + state := [8]uint32{1, 2, 3, 4, 5, 6, 7, 8} + + sha256Result := Sha256Compress(state, w) + + expectedResult := []uint32{1862536192, 526086805, 2067405084, 593147560, 726610467, 813867028, 4091010797, 3974542186} + + for i := 0; i < len(sha256Result); i++ { + if sha256Result[i] != expectedResult[i] { + t.Errorf("Expected result = %d, got %d", sha256Result[i], expectedResult[i]) + } + } + +}