Skip to content

Commit 3397964

Browse files
devopsbo3devopsbo3
authored
Revert "tests, trie: use slices package for sorting (ethereum#27496)"
This reverts commit ad4c892.
1 parent 998ce14 commit 3397964

File tree

5 files changed

+67
-52
lines changed

5 files changed

+67
-52
lines changed

‎tests/fuzzers/rangeproof/rangeproof-fuzzer.go‎

Lines changed: 9 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -21,19 +21,25 @@ import (
2121
"encoding/binary"
2222
"fmt"
2323
"io"
24+
"sort"
2425

2526
"github.com/ethereum/go-ethereum/common"
2627
"github.com/ethereum/go-ethereum/core/rawdb"
2728
"github.com/ethereum/go-ethereum/ethdb/memorydb"
2829
"github.com/ethereum/go-ethereum/trie"
29-
"golang.org/x/exp/slices"
3030
)
3131

3232
type kv struct {
3333
k, v []byte
3434
t bool
3535
}
3636

37+
type entrySlice []*kv
38+
39+
func (p entrySlice) Len() int { return len(p) }
40+
func (p entrySlice) Less(i, j int) bool { return bytes.Compare(p[i].k, p[j].k) < 0 }
41+
func (p entrySlice) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
42+
3743
type fuzzer struct {
3844
input io.Reader
3945
exhausted bool
@@ -91,16 +97,14 @@ func (f *fuzzer) fuzz() int {
9197
if f.exhausted {
9298
return 0 // input too short
9399
}
94-
var entries []*kv
100+
var entries entrySlice
95101
for _, kv := range vals {
96102
entries = append(entries, kv)
97103
}
98104
if len(entries) <= 1 {
99105
return 0
100106
}
101-
slices.SortFunc(entries, func(a, b *kv) bool {
102-
return bytes.Compare(a.k, b.k) < 0
103-
})
107+
sort.Sort(entries)
104108

105109
var ok = 0
106110
for {

‎tests/fuzzers/stacktrie/trie_fuzzer.go‎

Lines changed: 16 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -23,6 +23,7 @@ import (
2323
"fmt"
2424
"hash"
2525
"io"
26+
"sort"
2627

2728
"github.com/ethereum/go-ethereum/common"
2829
"github.com/ethereum/go-ethereum/core/rawdb"
@@ -32,7 +33,6 @@ import (
3233
"github.com/ethereum/go-ethereum/trie"
3334
"github.com/ethereum/go-ethereum/trie/trienode"
3435
"golang.org/x/crypto/sha3"
35-
"golang.org/x/exp/slices"
3636
)
3737

3838
type fuzzer struct {
@@ -104,6 +104,19 @@ func (b *spongeBatch) Replay(w ethdb.KeyValueWriter) error { return nil }
104104
type kv struct {
105105
k, v []byte
106106
}
107+
type kvs []kv
108+
109+
func (k kvs) Len() int {
110+
return len(k)
111+
}
112+
113+
func (k kvs) Less(i, j int) bool {
114+
return bytes.Compare(k[i].k, k[j].k) < 0
115+
}
116+
117+
func (k kvs) Swap(i, j int) {
118+
k[j], k[i] = k[i], k[j]
119+
}
107120

108121
// Fuzz is the fuzzing entry-point.
109122
// The function must return
@@ -143,7 +156,7 @@ func (f *fuzzer) fuzz() int {
143156
trieB = trie.NewStackTrie(func(owner common.Hash, path []byte, hash common.Hash, blob []byte) {
144157
rawdb.WriteTrieNode(spongeB, owner, path, hash, blob, dbB.Scheme())
145158
})
146-
vals []kv
159+
vals kvs
147160
useful bool
148161
maxElements = 10000
149162
// operate on unique keys only
@@ -179,9 +192,7 @@ func (f *fuzzer) fuzz() int {
179192
dbA.Commit(rootA, false)
180193

181194
// Stacktrie requires sorted insertion
182-
slices.SortFunc(vals, func(a, b kv) bool {
183-
return bytes.Compare(a.k, b.k) < 0
184-
})
195+
sort.Sort(vals)
185196
for _, kv := range vals {
186197
if f.debugging {
187198
fmt.Printf("{\"%#x\" , \"%#x\"} // stacktrie.Update\n", kv.k, kv.v)

‎trie/iterator_test.go‎

Lines changed: 0 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -84,10 +84,6 @@ type kv struct {
8484
t bool
8585
}
8686

87-
func (k *kv) less(other *kv) bool {
88-
return bytes.Compare(k.k, other.k) < 0
89-
}
90-
9187
func TestIteratorLargeData(t *testing.T) {
9288
trie := NewEmpty(NewDatabase(rawdb.NewMemoryDatabase()))
9389
vals := make(map[string]*kv)

‎trie/proof_test.go‎

Lines changed: 39 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -22,13 +22,13 @@ import (
2222
"encoding/binary"
2323
"fmt"
2424
mrand "math/rand"
25+
"sort"
2526
"testing"
2627

2728
"github.com/ethereum/go-ethereum/common"
2829
"github.com/ethereum/go-ethereum/core/rawdb"
2930
"github.com/ethereum/go-ethereum/crypto"
3031
"github.com/ethereum/go-ethereum/ethdb/memorydb"
31-
"golang.org/x/exp/slices"
3232
)
3333

3434
// Prng is a pseudo random number generator seeded by strong randomness.
@@ -165,15 +165,21 @@ func TestMissingKeyProof(t *testing.T) {
165165
}
166166
}
167167

168+
type entrySlice []*kv
169+
170+
func (p entrySlice) Len() int { return len(p) }
171+
func (p entrySlice) Less(i, j int) bool { return bytes.Compare(p[i].k, p[j].k) < 0 }
172+
func (p entrySlice) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
173+
168174
// TestRangeProof tests normal range proof with both edge proofs
169175
// as the existent proof. The test cases are generated randomly.
170176
func TestRangeProof(t *testing.T) {
171177
trie, vals := randomTrie(4096)
172-
var entries []*kv
178+
var entries entrySlice
173179
for _, kv := range vals {
174180
entries = append(entries, kv)
175181
}
176-
slices.SortFunc(entries, (*kv).less)
182+
sort.Sort(entries)
177183
for i := 0; i < 500; i++ {
178184
start := mrand.Intn(len(entries))
179185
end := mrand.Intn(len(entries)-start) + start + 1
@@ -202,11 +208,11 @@ func TestRangeProof(t *testing.T) {
202208
// The test cases are generated randomly.
203209
func TestRangeProofWithNonExistentProof(t *testing.T) {
204210
trie, vals := randomTrie(4096)
205-
var entries []*kv
211+
var entries entrySlice
206212
for _, kv := range vals {
207213
entries = append(entries, kv)
208214
}
209-
slices.SortFunc(entries, (*kv).less)
215+
sort.Sort(entries)
210216
for i := 0; i < 500; i++ {
211217
start := mrand.Intn(len(entries))
212218
end := mrand.Intn(len(entries)-start) + start + 1
@@ -274,11 +280,11 @@ func TestRangeProofWithNonExistentProof(t *testing.T) {
274280
// - There exists a gap between the last element and the right edge proof
275281
func TestRangeProofWithInvalidNonExistentProof(t *testing.T) {
276282
trie, vals := randomTrie(4096)
277-
var entries []*kv
283+
var entries entrySlice
278284
for _, kv := range vals {
279285
entries = append(entries, kv)
280286
}
281-
slices.SortFunc(entries, (*kv).less)
287+
sort.Sort(entries)
282288

283289
// Case 1
284290
start, end := 100, 200
@@ -331,11 +337,11 @@ func TestRangeProofWithInvalidNonExistentProof(t *testing.T) {
331337
// non-existent one.
332338
func TestOneElementRangeProof(t *testing.T) {
333339
trie, vals := randomTrie(4096)
334-
var entries []*kv
340+
var entries entrySlice
335341
for _, kv := range vals {
336342
entries = append(entries, kv)
337343
}
338-
slices.SortFunc(entries, (*kv).less)
344+
sort.Sort(entries)
339345

340346
// One element with existent edge proof, both edge proofs
341347
// point to the SAME key.
@@ -418,11 +424,11 @@ func TestOneElementRangeProof(t *testing.T) {
418424
// The edge proofs can be nil.
419425
func TestAllElementsProof(t *testing.T) {
420426
trie, vals := randomTrie(4096)
421-
var entries []*kv
427+
var entries entrySlice
422428
for _, kv := range vals {
423429
entries = append(entries, kv)
424430
}
425-
slices.SortFunc(entries, (*kv).less)
431+
sort.Sort(entries)
426432

427433
var k [][]byte
428434
var v [][]byte
@@ -468,13 +474,13 @@ func TestAllElementsProof(t *testing.T) {
468474
func TestSingleSideRangeProof(t *testing.T) {
469475
for i := 0; i < 64; i++ {
470476
trie := NewEmpty(NewDatabase(rawdb.NewMemoryDatabase()))
471-
var entries []*kv
477+
var entries entrySlice
472478
for i := 0; i < 4096; i++ {
473479
value := &kv{randBytes(32), randBytes(20), false}
474480
trie.MustUpdate(value.k, value.v)
475481
entries = append(entries, value)
476482
}
477-
slices.SortFunc(entries, (*kv).less)
483+
sort.Sort(entries)
478484

479485
var cases = []int{0, 1, 50, 100, 1000, 2000, len(entries) - 1}
480486
for _, pos := range cases {
@@ -503,13 +509,13 @@ func TestSingleSideRangeProof(t *testing.T) {
503509
func TestReverseSingleSideRangeProof(t *testing.T) {
504510
for i := 0; i < 64; i++ {
505511
trie := NewEmpty(NewDatabase(rawdb.NewMemoryDatabase()))
506-
var entries []*kv
512+
var entries entrySlice
507513
for i := 0; i < 4096; i++ {
508514
value := &kv{randBytes(32), randBytes(20), false}
509515
trie.MustUpdate(value.k, value.v)
510516
entries = append(entries, value)
511517
}
512-
slices.SortFunc(entries, (*kv).less)
518+
sort.Sort(entries)
513519

514520
var cases = []int{0, 1, 50, 100, 1000, 2000, len(entries) - 1}
515521
for _, pos := range cases {
@@ -539,11 +545,11 @@ func TestReverseSingleSideRangeProof(t *testing.T) {
539545
// The prover is expected to detect the error.
540546
func TestBadRangeProof(t *testing.T) {
541547
trie, vals := randomTrie(4096)
542-
var entries []*kv
548+
var entries entrySlice
543549
for _, kv := range vals {
544550
entries = append(entries, kv)
545551
}
546-
slices.SortFunc(entries, (*kv).less)
552+
sort.Sort(entries)
547553

548554
for i := 0; i < 500; i++ {
549555
start := mrand.Intn(len(entries))
@@ -642,11 +648,11 @@ func TestGappedRangeProof(t *testing.T) {
642648
// TestSameSideProofs tests the element is not in the range covered by proofs
643649
func TestSameSideProofs(t *testing.T) {
644650
trie, vals := randomTrie(4096)
645-
var entries []*kv
651+
var entries entrySlice
646652
for _, kv := range vals {
647653
entries = append(entries, kv)
648654
}
649-
slices.SortFunc(entries, (*kv).less)
655+
sort.Sort(entries)
650656

651657
pos := 1000
652658
first := decreaseKey(common.CopyBytes(entries[pos].k))
@@ -684,13 +690,13 @@ func TestSameSideProofs(t *testing.T) {
684690

685691
func TestHasRightElement(t *testing.T) {
686692
trie := NewEmpty(NewDatabase(rawdb.NewMemoryDatabase()))
687-
var entries []*kv
693+
var entries entrySlice
688694
for i := 0; i < 4096; i++ {
689695
value := &kv{randBytes(32), randBytes(20), false}
690696
trie.MustUpdate(value.k, value.v)
691697
entries = append(entries, value)
692698
}
693-
slices.SortFunc(entries, (*kv).less)
699+
sort.Sort(entries)
694700

695701
var cases = []struct {
696702
start int
@@ -758,11 +764,11 @@ func TestHasRightElement(t *testing.T) {
758764
// The first edge proof must be a non-existent proof.
759765
func TestEmptyRangeProof(t *testing.T) {
760766
trie, vals := randomTrie(4096)
761-
var entries []*kv
767+
var entries entrySlice
762768
for _, kv := range vals {
763769
entries = append(entries, kv)
764770
}
765-
slices.SortFunc(entries, (*kv).less)
771+
sort.Sort(entries)
766772

767773
var cases = []struct {
768774
pos int
@@ -793,11 +799,11 @@ func TestEmptyRangeProof(t *testing.T) {
793799
func TestBloatedProof(t *testing.T) {
794800
// Use a small trie
795801
trie, kvs := nonRandomTrie(100)
796-
var entries []*kv
802+
var entries entrySlice
797803
for _, kv := range kvs {
798804
entries = append(entries, kv)
799805
}
800-
slices.SortFunc(entries, (*kv).less)
806+
sort.Sort(entries)
801807
var keys [][]byte
802808
var vals [][]byte
803809

@@ -827,11 +833,11 @@ func TestBloatedProof(t *testing.T) {
827833
// noop technically, but practically should be rejected.
828834
func TestEmptyValueRangeProof(t *testing.T) {
829835
trie, values := randomTrie(512)
830-
var entries []*kv
836+
var entries entrySlice
831837
for _, kv := range values {
832838
entries = append(entries, kv)
833839
}
834-
slices.SortFunc(entries, (*kv).less)
840+
sort.Sort(entries)
835841

836842
// Create a new entry with a slightly modified key
837843
mid := len(entries) / 2
@@ -871,11 +877,11 @@ func TestEmptyValueRangeProof(t *testing.T) {
871877
// practically should be rejected.
872878
func TestAllElementsEmptyValueRangeProof(t *testing.T) {
873879
trie, values := randomTrie(512)
874-
var entries []*kv
880+
var entries entrySlice
875881
for _, kv := range values {
876882
entries = append(entries, kv)
877883
}
878-
slices.SortFunc(entries, (*kv).less)
884+
sort.Sort(entries)
879885

880886
// Create a new entry with a slightly modified key
881887
mid := len(entries) / 2
@@ -977,11 +983,11 @@ func BenchmarkVerifyRangeProof5000(b *testing.B) { benchmarkVerifyRangeProof(b,
977983

978984
func benchmarkVerifyRangeProof(b *testing.B, size int) {
979985
trie, vals := randomTrie(8192)
980-
var entries []*kv
986+
var entries entrySlice
981987
for _, kv := range vals {
982988
entries = append(entries, kv)
983989
}
984-
slices.SortFunc(entries, (*kv).less)
990+
sort.Sort(entries)
985991

986992
start := 2
987993
end := start + size
@@ -1014,11 +1020,11 @@ func BenchmarkVerifyRangeNoProof1000(b *testing.B) { benchmarkVerifyRangeNoProof
10141020

10151021
func benchmarkVerifyRangeNoProof(b *testing.B, size int) {
10161022
trie, vals := randomTrie(size)
1017-
var entries []*kv
1023+
var entries entrySlice
10181024
for _, kv := range vals {
10191025
entries = append(entries, kv)
10201026
}
1021-
slices.SortFunc(entries, (*kv).less)
1027+
sort.Sort(entries)
10221028

10231029
var keys [][]byte
10241030
var values [][]byte

‎trie/trienode/node.go‎

Lines changed: 3 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -18,10 +18,10 @@ package trienode
1818

1919
import (
2020
"fmt"
21+
"sort"
2122
"strings"
2223

2324
"github.com/ethereum/go-ethereum/common"
24-
"golang.org/x/exp/slices"
2525
)
2626

2727
// Node is a wrapper which contains the encoded blob of the trie node and its
@@ -100,14 +100,12 @@ func NewNodeSet(owner common.Hash) *NodeSet {
100100
// ForEachWithOrder iterates the nodes with the order from bottom to top,
101101
// right to left, nodes with the longest path will be iterated first.
102102
func (set *NodeSet) ForEachWithOrder(callback func(path string, n *Node)) {
103-
var paths []string
103+
var paths sort.StringSlice
104104
for path := range set.Nodes {
105105
paths = append(paths, path)
106106
}
107107
// Bottom-up, longest path first
108-
slices.SortFunc(paths, func(a, b string) bool {
109-
return a > b // Sort in reverse order
110-
})
108+
sort.Sort(sort.Reverse(paths))
111109
for _, path := range paths {
112110
callback(path, set.Nodes[path].Unwrap())
113111
}

0 commit comments

Comments
 (0)