mirror
/
go-ethereum
mirror of https://github.com/ethereum/go-ethereum
2
0
Fork 1
Code Issues Releases Wiki Activity

all: gofmt -w -s

Browse Source
pull/3525/head
Felix Lange 8 years ago
parent e0fde02290
commit 35a7dcb162
64 changed files with 343 additions and 343 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 28
      accounts/abi/abi_test.go
  2. 2
      build/ci.go
  3. 6
      cmd/swarm/main.go
  4. 2
      common/bytes.go
  5. 36
      common/math/dist_test.go
  6. 2
      core/blockchain.go
  7. 2
      core/blockchain_test.go
  8. 2
      core/state/iterator_test.go
  9. 6
      core/state/managed_state_test.go
  10. 6
      core/state/statedb.go
  11. 4
      core/state/sync_test.go
  12. 2
      core/tx_list.go
  13. 2
      core/tx_pool.go
  14. 260
      core/vm/jump_table.go
  15. 12
      crypto/ecies/asn1.go
  16. 6
      crypto/ecies/ecies_test.go
  17. 2
      crypto/sha3/sha3_test.go
  18. 4
      eth/backend_test.go
  19. 4
      eth/downloader/peer.go
  20. 4
      eth/downloader/queue.go
  21. 2
      eth/filters/api.go
  22. 22
      eth/filters/filter_system_test.go
  23. 12
      eth/filters/filter_test.go
  24. 12
      eth/handler_test.go
  25. 2
      eth/protocol_test.go
  26. 2
      ethdb/memory_database.go
  27. 14
      ethstats/ethstats.go
  28. 4
      event/event_test.go
  29. 2
      event/filter/generic_filter.go
  30. 2
      les/fetcher.go
  31. 6
      les/flowcontrol/manager.go
  32. 14
      les/handler_test.go
  33. 2
      les/peer.go
  34. 2
      les/randselect_test.go
  35. 2
      les/serverpool.go
  36. 12
      les/sync.go
  37. 2
      les/txrelay.go
  38. 2
      light/lightchain.go
  39. 2
      light/txpool_test.go
  40. 2
      logger/glog/glog.go
  41. 2
      miner/worker.go
  42. 2
      mobile/p2p.go
  43. 12
      node/node_test.go
  44. 4
      p2p/discover/database_test.go
  45. 2
      p2p/discover/table.go
  46. 26
      p2p/discover/table_test.go
  47. 4
      p2p/discv5/database_test.go
  48. 26
      p2p/discv5/net_test.go
  49. 6
      p2p/discv5/sim_test.go
  50. 2
      p2p/discv5/ticket.go
  51. 2
      p2p/discv5/topic.go
  52. 2
      p2p/nat/natpmp.go
  53. 2
      p2p/peer_test.go
  54. 8
      rpc/json.go
  55. 4
      swarm/storage/dpa_test.go
  56. 2
      trie/encoding.go
  57. 2
      trie/iterator_test.go
  58. 4
      trie/sync_test.go
  59. 2
      whisper/whisperv2/filter.go
  60. 2
      whisper/whisperv2/peer.go
  61. 2
      whisper/whisperv2/peer_test.go
  62. 52
      whisper/whisperv2/topic_test.go
  63. 2
      whisper/whisperv5/peer.go
  64. 2
      whisper/whisperv5/whisper.go

28
accounts/abi/abi_test.go
Unescape View File

@ -67,10 +67,10 @@ func TestTypeCheck(t *testing.T) {
{"uint16[3]", [4]uint16{1, 2, 3}, "abi: cannot use [4]uint16 as type [3]uint16 as argument"}, {"uint16[3]", [4]uint16{1, 2, 3}, "abi: cannot use [4]uint16 as type [3]uint16 as argument"},
{"uint16[3]", []uint16{1, 2, 3}, ""}, {"uint16[3]", []uint16{1, 2, 3}, ""},
{"uint16[3]", []uint16{1, 2, 3, 4}, "abi: cannot use [4]uint16 as type [3]uint16 as argument"}, {"uint16[3]", []uint16{1, 2, 3, 4}, "abi: cannot use [4]uint16 as type [3]uint16 as argument"},
{"address[]", []common.Address{common.Address{1}}, ""}, {"address[]", []common.Address{{1}}, ""},
{"address[1]", []common.Address{common.Address{1}}, ""}, {"address[1]", []common.Address{{1}}, ""},
{"address[1]", [1]common.Address{common.Address{1}}, ""}, {"address[1]", [1]common.Address{{1}}, ""},
{"address[2]", [1]common.Address{common.Address{1}}, "abi: cannot use [1]array as type [2]array as argument"}, {"address[2]", [1]common.Address{{1}}, "abi: cannot use [1]array as type [2]array as argument"},
{"bytes32", [32]byte{}, ""}, {"bytes32", [32]byte{}, ""},
{"bytes32", [33]byte{}, "abi: cannot use [33]uint8 as type [32]uint8 as argument"}, {"bytes32", [33]byte{}, "abi: cannot use [33]uint8 as type [32]uint8 as argument"},
{"bytes32", common.Hash{1}, ""}, {"bytes32", common.Hash{1}, ""},
@ -80,7 +80,7 @@ func TestTypeCheck(t *testing.T) {
{"bytes", [2]byte{0, 1}, ""}, {"bytes", [2]byte{0, 1}, ""},
{"bytes", common.Hash{1}, ""}, {"bytes", common.Hash{1}, ""},
{"string", "hello world", ""}, {"string", "hello world", ""},
{"bytes32[]", [][32]byte{[32]byte{}}, ""}, {"bytes32[]", [][32]byte{{}}, ""},
{"function", [24]byte{}, ""}, {"function", [24]byte{}, ""},
} { } {
typ, err := NewType(test.typ) typ, err := NewType(test.typ)
@ -343,8 +343,8 @@ func TestPack(t *testing.T) {
{"uint16[]", []uint16{1, 2}, formatSliceOutput([]byte{1}, []byte{2})}, {"uint16[]", []uint16{1, 2}, formatSliceOutput([]byte{1}, []byte{2})},
{"bytes20", [20]byte{1}, pad([]byte{1}, 32, false)}, {"bytes20", [20]byte{1}, pad([]byte{1}, 32, false)},
{"uint256[]", []*big.Int{big.NewInt(1), big.NewInt(2)}, formatSliceOutput([]byte{1}, []byte{2})}, {"uint256[]", []*big.Int{big.NewInt(1), big.NewInt(2)}, formatSliceOutput([]byte{1}, []byte{2})},
{"address[]", []common.Address{common.Address{1}, common.Address{2}}, formatSliceOutput(pad([]byte{1}, 20, false), pad([]byte{2}, 20, false))}, {"address[]", []common.Address{{1}, {2}}, formatSliceOutput(pad([]byte{1}, 20, false), pad([]byte{2}, 20, false))},
{"bytes32[]", []common.Hash{common.Hash{1}, common.Hash{2}}, formatSliceOutput(pad([]byte{1}, 32, false), pad([]byte{2}, 32, false))}, {"bytes32[]", []common.Hash{{1}, {2}}, formatSliceOutput(pad([]byte{1}, 32, false), pad([]byte{2}, 32, false))},
{"function", [24]byte{1}, pad([]byte{1}, 32, false)}, {"function", [24]byte{1}, pad([]byte{1}, 32, false)},
} { } {
typ, err := NewType(test.typ) typ, err := NewType(test.typ)
@ -458,12 +458,12 @@ func TestReader(t *testing.T) {
Uint256, _ := NewType("uint256") Uint256, _ := NewType("uint256")
exp := ABI{ exp := ABI{
Methods: map[string]Method{ Methods: map[string]Method{
"balance": Method{ "balance": {
"balance", true, nil, nil, "balance", true, nil, nil,
}, },
"send": Method{ "send": {
"send", false, []Argument{ "send", false, []Argument{
Argument{"amount", Uint256, false}, {"amount", Uint256, false},
}, nil, }, nil,
}, },
}, },
@ -562,7 +562,7 @@ func TestTestSlice(t *testing.T) {
func TestMethodSignature(t *testing.T) { func TestMethodSignature(t *testing.T) {
String, _ := NewType("string") String, _ := NewType("string")
m := Method{"foo", false, []Argument{Argument{"bar", String, false}, Argument{"baz", String, false}}, nil} m := Method{"foo", false, []Argument{{"bar", String, false}, {"baz", String, false}}, nil}
exp := "foo(string,string)" exp := "foo(string,string)"
if m.Sig() != exp { if m.Sig() != exp {
t.Error("signature mismatch", exp, "!=", m.Sig()) t.Error("signature mismatch", exp, "!=", m.Sig())
@ -574,7 +574,7 @@ func TestMethodSignature(t *testing.T) {
} }
uintt, _ := NewType("uint") uintt, _ := NewType("uint")
m = Method{"foo", false, []Argument{Argument{"bar", uintt, false}}, nil} m = Method{"foo", false, []Argument{{"bar", uintt, false}}, nil}
exp = "foo(uint256)" exp = "foo(uint256)"
if m.Sig() != exp { if m.Sig() != exp {
t.Error("signature mismatch", exp, "!=", m.Sig()) t.Error("signature mismatch", exp, "!=", m.Sig())
@ -779,8 +779,8 @@ func TestBareEvents(t *testing.T) {
"balance": {false, nil}, "balance": {false, nil},
"anon": {true, nil}, "anon": {true, nil},
"args": {false, []Argument{ "args": {false, []Argument{
Argument{Name: "arg0", Type: arg0, Indexed: false}, {Name: "arg0", Type: arg0, Indexed: false},
Argument{Name: "arg1", Type: arg1, Indexed: true}, {Name: "arg1", Type: arg1, Indexed: true},
}}, }},
} }

2
build/ci.go
Unescape View File

@ -195,7 +195,7 @@ func doInstall(cmdline []string) {
if err != nil { if err != nil {
log.Fatal(err) log.Fatal(err)
} }
for name, _ := range pkgs { for name := range pkgs {
if name == "main" { if name == "main" {
gobuild := goToolArch(*arch, "build", buildFlags(env)...) gobuild := goToolArch(*arch, "build", buildFlags(env)...)
gobuild.Args = append(gobuild.Args, "-v") gobuild.Args = append(gobuild.Args, "-v")

6
cmd/swarm/main.go
Unescape View File

@ -129,7 +129,7 @@ func init() {
app.HideVersion = true // we have a command to print the version app.HideVersion = true // we have a command to print the version
app.Copyright = "Copyright 2013-2016 The go-ethereum Authors" app.Copyright = "Copyright 2013-2016 The go-ethereum Authors"
app.Commands = []cli.Command{ app.Commands = []cli.Command{
cli.Command{ {
Action: version, Action: version,
Name: "version", Name: "version",
Usage: "Print version numbers", Usage: "Print version numbers",
@ -138,7 +138,7 @@ func init() {
The output of this command is supposed to be machine-readable. The output of this command is supposed to be machine-readable.
`, `,
}, },
cli.Command{ {
Action: upload, Action: upload,
Name: "up", Name: "up",
Usage: "upload a file or directory to swarm using the HTTP API", Usage: "upload a file or directory to swarm using the HTTP API",
@ -147,7 +147,7 @@ The output of this command is supposed to be machine-readable.
"upload a file or directory to swarm using the HTTP API and prints the root hash", "upload a file or directory to swarm using the HTTP API and prints the root hash",
`, `,
}, },
cli.Command{ {
Action: hash, Action: hash,
Name: "hash", Name: "hash",
Usage: "print the swarm hash of a file or directory", Usage: "print the swarm hash of a file or directory",

2
common/bytes.go
Unescape View File

@ -143,7 +143,7 @@ func Hex2BytesFixed(str string, flen int) []byte {
return h return h
} else { } else {
if len(h) > flen { if len(h) > flen {
return h[len(h)-flen : len(h)] return h[len(h)-flen:]
} else { } else {
hh := make([]byte, flen) hh := make([]byte, flen)
copy(hh[flen-len(h):flen], h[:]) copy(hh[flen-len(h):flen], h[:])

36
common/math/dist_test.go
Unescape View File

@ -41,24 +41,24 @@ func TestSum(t *testing.T) {
func TestDist(t *testing.T) { func TestDist(t *testing.T) {
var vectors = []Vector{ var vectors = []Vector{
Vector{big.NewInt(1000), big.NewInt(1234)}, {big.NewInt(1000), big.NewInt(1234)},
Vector{big.NewInt(500), big.NewInt(10023)}, {big.NewInt(500), big.NewInt(10023)},
Vector{big.NewInt(1034), big.NewInt(1987)}, {big.NewInt(1034), big.NewInt(1987)},
Vector{big.NewInt(1034), big.NewInt(1987)}, {big.NewInt(1034), big.NewInt(1987)},
Vector{big.NewInt(8983), big.NewInt(1977)}, {big.NewInt(8983), big.NewInt(1977)},
Vector{big.NewInt(98382), big.NewInt(1887)}, {big.NewInt(98382), big.NewInt(1887)},
Vector{big.NewInt(12398), big.NewInt(1287)}, {big.NewInt(12398), big.NewInt(1287)},
Vector{big.NewInt(12398), big.NewInt(1487)}, {big.NewInt(12398), big.NewInt(1487)},
Vector{big.NewInt(12398), big.NewInt(1987)}, {big.NewInt(12398), big.NewInt(1987)},
Vector{big.NewInt(12398), big.NewInt(128)}, {big.NewInt(12398), big.NewInt(128)},
Vector{big.NewInt(12398), big.NewInt(1987)}, {big.NewInt(12398), big.NewInt(1987)},
Vector{big.NewInt(1398), big.NewInt(187)}, {big.NewInt(1398), big.NewInt(187)},
Vector{big.NewInt(12328), big.NewInt(1927)}, {big.NewInt(12328), big.NewInt(1927)},
Vector{big.NewInt(12398), big.NewInt(1987)}, {big.NewInt(12398), big.NewInt(1987)},
Vector{big.NewInt(22398), big.NewInt(1287)}, {big.NewInt(22398), big.NewInt(1287)},
Vector{big.NewInt(1370), big.NewInt(1981)}, {big.NewInt(1370), big.NewInt(1981)},
Vector{big.NewInt(12398), big.NewInt(1957)}, {big.NewInt(12398), big.NewInt(1957)},
Vector{big.NewInt(42198), big.NewInt(1987)}, {big.NewInt(42198), big.NewInt(1987)},
} }
VectorsBy(GasSort).Sort(vectors) VectorsBy(GasSort).Sort(vectors)

2
core/blockchain.go
Unescape View File

@ -150,7 +150,7 @@ func NewBlockChain(chainDb ethdb.Database, config *params.ChainConfig, pow pow.P
return nil, err return nil, err
} }
// Check the current state of the block hashes and make sure that we do not have any of the bad blocks in our chain // Check the current state of the block hashes and make sure that we do not have any of the bad blocks in our chain
for hash, _ := range BadHashes { for hash := range BadHashes {
if header := bc.GetHeaderByHash(hash); header != nil { if header := bc.GetHeaderByHash(hash); header != nil {
// get the canonical block corresponding to the offending header's number // get the canonical block corresponding to the offending header's number
headerByNumber := bc.GetHeaderByNumber(header.Number.Uint64()) headerByNumber := bc.GetHeaderByNumber(header.Number.Uint64())

2
core/blockchain_test.go
Unescape View File

@ -1107,7 +1107,7 @@ func TestCanonicalBlockRetrieval(t *testing.T) {
chain, _ := GenerateChain(params.TestChainConfig, genesis, db, 10, func(i int, gen *BlockGen) {}) chain, _ := GenerateChain(params.TestChainConfig, genesis, db, 10, func(i int, gen *BlockGen) {})
for i, _ := range chain { for i := range chain {
go func(block *types.Block) { go func(block *types.Block) {
// try to retrieve a block by its canonical hash and see if the block data can be retrieved. // try to retrieve a block by its canonical hash and see if the block data can be retrieved.
for { for {

2
core/state/iterator_test.go
Unescape View File

@ -41,7 +41,7 @@ func TestNodeIteratorCoverage(t *testing.T) {
} }
} }
// Cross check the hashes and the database itself // Cross check the hashes and the database itself
for hash, _ := range hashes { for hash := range hashes {
if _, err := db.Get(hash.Bytes()); err != nil { if _, err := db.Get(hash.Bytes()); err != nil {
t.Errorf("failed to retrieve reported node %x: %v", hash, err) t.Errorf("failed to retrieve reported node %x: %v", hash, err)
} }

6
core/state/managed_state_test.go
Unescape View File

@ -52,7 +52,7 @@ func TestRemove(t *testing.T) {
ms, account := create() ms, account := create()
nn := make([]bool, 10) nn := make([]bool, 10)
for i, _ := range nn { for i := range nn {
nn[i] = true nn[i] = true
} }
account.nonces = append(account.nonces, nn...) account.nonces = append(account.nonces, nn...)
@ -68,7 +68,7 @@ func TestReuse(t *testing.T) {
ms, account := create() ms, account := create()
nn := make([]bool, 10) nn := make([]bool, 10)
for i, _ := range nn { for i := range nn {
nn[i] = true nn[i] = true
} }
account.nonces = append(account.nonces, nn...) account.nonces = append(account.nonces, nn...)
@ -84,7 +84,7 @@ func TestReuse(t *testing.T) {
func TestRemoteNonceChange(t *testing.T) { func TestRemoteNonceChange(t *testing.T) {
ms, account := create() ms, account := create()
nn := make([]bool, 10) nn := make([]bool, 10)
for i, _ := range nn { for i := range nn {
nn[i] = true nn[i] = true
} }
account.nonces = append(account.nonces, nn...) account.nonces = append(account.nonces, nn...)

6
core/state/statedb.go
Unescape View File

@ -479,7 +479,7 @@ func (self *StateDB) Copy() *StateDB {
logSize: self.logSize, logSize: self.logSize,
} }
// Copy the dirty states and logs // Copy the dirty states and logs
for addr, _ := range self.stateObjectsDirty { for addr := range self.stateObjectsDirty {
state.stateObjects[addr] = self.stateObjects[addr].deepCopy(state, state.MarkStateObjectDirty) state.stateObjects[addr] = self.stateObjects[addr].deepCopy(state, state.MarkStateObjectDirty)
state.stateObjectsDirty[addr] = struct{}{} state.stateObjectsDirty[addr] = struct{}{}
} }
@ -530,7 +530,7 @@ func (self *StateDB) GetRefund() *big.Int {
// It is called in between transactions to get the root hash that // It is called in between transactions to get the root hash that
// goes into transaction receipts. // goes into transaction receipts.
func (s *StateDB) IntermediateRoot(deleteEmptyObjects bool) common.Hash { func (s *StateDB) IntermediateRoot(deleteEmptyObjects bool) common.Hash {
for addr, _ := range s.stateObjectsDirty { for addr := range s.stateObjectsDirty {
stateObject := s.stateObjects[addr] stateObject := s.stateObjects[addr]
if stateObject.suicided || (deleteEmptyObjects && stateObject.empty()) { if stateObject.suicided || (deleteEmptyObjects && stateObject.empty()) {
s.deleteStateObject(stateObject) s.deleteStateObject(stateObject)
@ -553,7 +553,7 @@ func (s *StateDB) DeleteSuicides() {
// Reset refund so that any used-gas calculations can use this method. // Reset refund so that any used-gas calculations can use this method.
s.clearJournalAndRefund() s.clearJournalAndRefund()
for addr, _ := range s.stateObjectsDirty { for addr := range s.stateObjectsDirty {
stateObject := s.stateObjects[addr] stateObject := s.stateObjects[addr]
// If the object has been removed by a suicide // If the object has been removed by a suicide

4
core/state/sync_test.go
Unescape View File

@ -198,7 +198,7 @@ func testIterativeRandomStateSync(t *testing.T, batch int) {
for len(queue) > 0 { for len(queue) > 0 {
// Fetch all the queued nodes in a random order // Fetch all the queued nodes in a random order
results := make([]trie.SyncResult, 0, len(queue)) results := make([]trie.SyncResult, 0, len(queue))
for hash, _ := range queue { for hash := range queue {
data, err := srcDb.Get(hash.Bytes()) data, err := srcDb.Get(hash.Bytes())
if err != nil { if err != nil {
t.Fatalf("failed to retrieve node data for %x: %v", hash, err) t.Fatalf("failed to retrieve node data for %x: %v", hash, err)
@ -235,7 +235,7 @@ func TestIterativeRandomDelayedStateSync(t *testing.T) {
for len(queue) > 0 { for len(queue) > 0 {
// Sync only half of the scheduled nodes, even those in random order // Sync only half of the scheduled nodes, even those in random order
results := make([]trie.SyncResult, 0, len(queue)/2+1) results := make([]trie.SyncResult, 0, len(queue)/2+1)
for hash, _ := range queue { for hash := range queue {
delete(queue, hash) delete(queue, hash)
data, err := srcDb.Get(hash.Bytes()) data, err := srcDb.Get(hash.Bytes())

2
core/tx_list.go
Unescape View File

@ -110,7 +110,7 @@ func (m *txSortedMap) Filter(filter func(*types.Transaction) bool) types.Transac
// If transactions were removed, the heap and cache are ruined // If transactions were removed, the heap and cache are ruined
if len(removed) > 0 { if len(removed) > 0 {
*m.index = make([]uint64, 0, len(m.items)) *m.index = make([]uint64, 0, len(m.items))
for nonce, _ := range m.items { for nonce := range m.items {
*m.index = append(*m.index, nonce) *m.index = append(*m.index, nonce)
} }
heap.Init(m.index) heap.Init(m.index)

2
core/tx_pool.go
Unescape View File

@ -609,7 +609,7 @@ func (pool *TxPool) promoteExecutables(state *state.StateDB) {
if queued > maxQueuedInTotal { if queued > maxQueuedInTotal {
// Sort all accounts with queued transactions by heartbeat // Sort all accounts with queued transactions by heartbeat
addresses := make(addresssByHeartbeat, 0, len(pool.queue)) addresses := make(addresssByHeartbeat, 0, len(pool.queue))
for addr, _ := range pool.queue { for addr := range pool.queue {
addresses = append(addresses, addressByHeartbeat{addr, pool.beats[addr]}) addresses = append(addresses, addressByHeartbeat{addr, pool.beats[addr]})
} }
sort.Sort(addresses) sort.Sort(addresses)

260
core/vm/jump_table.go
Unescape View File

@ -52,283 +52,283 @@ var defaultJumpTable = NewJumpTable()
func NewJumpTable() [256]operation { func NewJumpTable() [256]operation {
return [256]operation{ return [256]operation{
ADD: operation{ ADD: {
execute: opAdd, execute: opAdd,
gasCost: constGasFunc(GasFastestStep), gasCost: constGasFunc(GasFastestStep),
validateStack: makeStackFunc(2, 1), validateStack: makeStackFunc(2, 1),
valid: true, valid: true,
}, },
SUB: operation{ SUB: {
execute: opSub, execute: opSub,
gasCost: constGasFunc(GasFastestStep), gasCost: constGasFunc(GasFastestStep),
validateStack: makeStackFunc(2, 1), validateStack: makeStackFunc(2, 1),
valid: true, valid: true,
}, },
MUL: operation{ MUL: {
execute: opMul, execute: opMul,
gasCost: constGasFunc(GasFastStep), gasCost: constGasFunc(GasFastStep),
validateStack: makeStackFunc(2, 1), validateStack: makeStackFunc(2, 1),
valid: true, valid: true,
}, },
DIV: operation{ DIV: {
execute: opDiv, execute: opDiv,
gasCost: constGasFunc(GasFastStep), gasCost: constGasFunc(GasFastStep),
validateStack: makeStackFunc(2, 1), validateStack: makeStackFunc(2, 1),
valid: true, valid: true,
}, },
SDIV: operation{ SDIV: {
execute: opSdiv, execute: opSdiv,
gasCost: constGasFunc(GasFastStep), gasCost: constGasFunc(GasFastStep),
validateStack: makeStackFunc(2, 1), validateStack: makeStackFunc(2, 1),
valid: true, valid: true,
}, },
MOD: operation{ MOD: {
execute: opMod, execute: opMod,
gasCost: constGasFunc(GasFastStep), gasCost: constGasFunc(GasFastStep),
validateStack: makeStackFunc(2, 1), validateStack: makeStackFunc(2, 1),
valid: true, valid: true,
}, },
SMOD: operation{ SMOD: {
execute: opSmod, execute: opSmod,
gasCost: constGasFunc(GasFastStep), gasCost: constGasFunc(GasFastStep),
validateStack: makeStackFunc(2, 1), validateStack: makeStackFunc(2, 1),
valid: true, valid: true,
}, },
EXP: operation{ EXP: {
execute: opExp, execute: opExp,
gasCost: gasExp, gasCost: gasExp,
validateStack: makeStackFunc(2, 1), validateStack: makeStackFunc(2, 1),
valid: true, valid: true,
}, },
SIGNEXTEND: operation{ SIGNEXTEND: {
execute: opSignExtend, execute: opSignExtend,
gasCost: constGasFunc(GasFastStep), gasCost: constGasFunc(GasFastStep),
validateStack: makeStackFunc(2, 1), validateStack: makeStackFunc(2, 1),
valid: true, valid: true,
}, },
NOT: operation{ NOT: {
execute: opNot, execute: opNot,
gasCost: constGasFunc(GasFastestStep), gasCost: constGasFunc(GasFastestStep),
validateStack: makeStackFunc(1, 1), validateStack: makeStackFunc(1, 1),
valid: true, valid: true,
}, },
LT: operation{ LT: {
execute: opLt, execute: opLt,
gasCost: constGasFunc(GasFastestStep), gasCost: constGasFunc(GasFastestStep),
validateStack: makeStackFunc(2, 1), validateStack: makeStackFunc(2, 1),
valid: true, valid: true,
}, },
GT: operation{ GT: {
execute: opGt, execute: opGt,
gasCost: constGasFunc(GasFastestStep), gasCost: constGasFunc(GasFastestStep),
validateStack: makeStackFunc(2, 1), validateStack: makeStackFunc(2, 1),
valid: true, valid: true,
}, },
SLT: operation{ SLT: {
execute: opSlt, execute: opSlt,
gasCost: constGasFunc(GasFastestStep), gasCost: constGasFunc(GasFastestStep),
validateStack: makeStackFunc(2, 1), validateStack: makeStackFunc(2, 1),
valid: true, valid: true,
}, },
SGT: operation{ SGT: {
execute: opSgt, execute: opSgt,
gasCost: constGasFunc(GasFastestStep), gasCost: constGasFunc(GasFastestStep),
validateStack: makeStackFunc(2, 1), validateStack: makeStackFunc(2, 1),
valid: true, valid: true,
}, },
EQ: operation{ EQ: {
execute: opEq, execute: opEq,
gasCost: constGasFunc(GasFastestStep), gasCost: constGasFunc(GasFastestStep),
validateStack: makeStackFunc(2, 1), validateStack: makeStackFunc(2, 1),
valid: true, valid: true,
}, },
ISZERO: operation{ ISZERO: {
execute: opIszero, execute: opIszero,
gasCost: constGasFunc(GasFastestStep), gasCost: constGasFunc(GasFastestStep),
validateStack: makeStackFunc(1, 1), validateStack: makeStackFunc(1, 1),
valid: true, valid: true,
}, },
AND: operation{ AND: {
execute: opAnd, execute: opAnd,
gasCost: constGasFunc(GasFastestStep), gasCost: constGasFunc(GasFastestStep),
validateStack: makeStackFunc(2, 1), validateStack: makeStackFunc(2, 1),
valid: true, valid: true,
}, },
OR: operation{ OR: {
execute: opOr, execute: opOr,
gasCost: constGasFunc(GasFastestStep), gasCost: constGasFunc(GasFastestStep),
validateStack: makeStackFunc(2, 1), validateStack: makeStackFunc(2, 1),
valid: true, valid: true,
}, },
XOR: operation{ XOR: {
execute: opXor, execute: opXor,
gasCost: constGasFunc(GasFastestStep), gasCost: constGasFunc(GasFastestStep),
validateStack: makeStackFunc(2, 1), validateStack: makeStackFunc(2, 1),
valid: true, valid: true,
}, },
BYTE: operation{ BYTE: {
execute: opByte, execute: opByte,
gasCost: constGasFunc(GasFastestStep), gasCost: constGasFunc(GasFastestStep),
validateStack: makeStackFunc(2, 1), validateStack: makeStackFunc(2, 1),
valid: true, valid: true,
}, },
ADDMOD: operation{ ADDMOD: {
execute: opAddmod, execute: opAddmod,
gasCost: constGasFunc(GasMidStep), gasCost: constGasFunc(GasMidStep),
validateStack: makeStackFunc(3, 1), validateStack: makeStackFunc(3, 1),
valid: true, valid: true,
}, },
MULMOD: operation{ MULMOD: {
execute: opMulmod, execute: opMulmod,
gasCost: constGasFunc(GasMidStep), gasCost: constGasFunc(GasMidStep),
validateStack: makeStackFunc(3, 1), validateStack: makeStackFunc(3, 1),
valid: true, valid: true,
}, },
SHA3: operation{ SHA3: {
execute: opSha3, execute: opSha3,
gasCost: gasSha3, gasCost: gasSha3,
validateStack: makeStackFunc(2, 1), validateStack: makeStackFunc(2, 1),
memorySize: memorySha3, memorySize: memorySha3,
valid: true, valid: true,
}, },
ADDRESS: operation{ ADDRESS: {
execute: opAddress, execute: opAddress,
gasCost: constGasFunc(GasQuickStep), gasCost: constGasFunc(GasQuickStep),
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
BALANCE: operation{ BALANCE: {
execute: opBalance, execute: opBalance,
gasCost: gasBalance, gasCost: gasBalance,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
ORIGIN: operation{ ORIGIN: {
execute: opOrigin, execute: opOrigin,
gasCost: constGasFunc(GasQuickStep), gasCost: constGasFunc(GasQuickStep),
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
CALLER: operation{ CALLER: {
execute: opCaller, execute: opCaller,
gasCost: constGasFunc(GasQuickStep), gasCost: constGasFunc(GasQuickStep),
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
CALLVALUE: operation{ CALLVALUE: {
execute: opCallValue, execute: opCallValue,
gasCost: constGasFunc(GasQuickStep), gasCost: constGasFunc(GasQuickStep),
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
CALLDATALOAD: operation{ CALLDATALOAD: {
execute: opCalldataLoad, execute: opCalldataLoad,
gasCost: constGasFunc(GasFastestStep), gasCost: constGasFunc(GasFastestStep),
validateStack: makeStackFunc(1, 1), validateStack: makeStackFunc(1, 1),
valid: true, valid: true,
}, },
CALLDATASIZE: operation{ CALLDATASIZE: {
execute: opCalldataSize, execute: opCalldataSize,
gasCost: constGasFunc(GasQuickStep), gasCost: constGasFunc(GasQuickStep),
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
CALLDATACOPY: operation{ CALLDATACOPY: {
execute: opCalldataCopy, execute: opCalldataCopy,
gasCost: gasCalldataCopy, gasCost: gasCalldataCopy,
validateStack: makeStackFunc(3, 1), validateStack: makeStackFunc(3, 1),
memorySize: memoryCalldataCopy, memorySize: memoryCalldataCopy,
valid: true, valid: true,
}, },
CODESIZE: operation{ CODESIZE: {
execute: opCodeSize, execute: opCodeSize,
gasCost: constGasFunc(GasQuickStep), gasCost: constGasFunc(GasQuickStep),
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
EXTCODESIZE: operation{ EXTCODESIZE: {
execute: opExtCodeSize, execute: opExtCodeSize,
gasCost: gasExtCodeSize, gasCost: gasExtCodeSize,
validateStack: makeStackFunc(1, 1), validateStack: makeStackFunc(1, 1),
valid: true, valid: true,
}, },
CODECOPY: operation{ CODECOPY: {
execute: opCodeCopy, execute: opCodeCopy,
gasCost: gasCodeCopy, gasCost: gasCodeCopy,
validateStack: makeStackFunc(3, 0), validateStack: makeStackFunc(3, 0),
memorySize: memoryCodeCopy, memorySize: memoryCodeCopy,
valid: true, valid: true,
}, },
EXTCODECOPY: operation{ EXTCODECOPY: {
execute: opExtCodeCopy, execute: opExtCodeCopy,
gasCost: gasExtCodeCopy, gasCost: gasExtCodeCopy,
validateStack: makeStackFunc(4, 0), validateStack: makeStackFunc(4, 0),
memorySize: memoryExtCodeCopy, memorySize: memoryExtCodeCopy,
valid: true, valid: true,
}, },
GASPRICE: operation{ GASPRICE: {
execute: opGasprice, execute: opGasprice,
gasCost: constGasFunc(GasQuickStep), gasCost: constGasFunc(GasQuickStep),
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
BLOCKHASH: operation{ BLOCKHASH: {
execute: opBlockhash, execute: opBlockhash,
gasCost: constGasFunc(GasExtStep), gasCost: constGasFunc(GasExtStep),
validateStack: makeStackFunc(1, 1), validateStack: makeStackFunc(1, 1),
valid: true, valid: true,
}, },
COINBASE: operation{ COINBASE: {
execute: opCoinbase, execute: opCoinbase,
gasCost: constGasFunc(GasQuickStep), gasCost: constGasFunc(GasQuickStep),
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
TIMESTAMP: operation{ TIMESTAMP: {
execute: opTimestamp, execute: opTimestamp,
gasCost: constGasFunc(GasQuickStep), gasCost: constGasFunc(GasQuickStep),
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
NUMBER: operation{ NUMBER: {
execute: opNumber, execute: opNumber,
gasCost: constGasFunc(GasQuickStep), gasCost: constGasFunc(GasQuickStep),
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
DIFFICULTY: operation{ DIFFICULTY: {
execute: opDifficulty, execute: opDifficulty,
gasCost: constGasFunc(GasQuickStep), gasCost: constGasFunc(GasQuickStep),
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
GASLIMIT: operation{ GASLIMIT: {
execute: opGasLimit, execute: opGasLimit,
gasCost: constGasFunc(GasQuickStep), gasCost: constGasFunc(GasQuickStep),
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
POP: operation{ POP: {
execute: opPop, execute: opPop,
gasCost: constGasFunc(GasQuickStep), gasCost: constGasFunc(GasQuickStep),
validateStack: makeStackFunc(1, 0), validateStack: makeStackFunc(1, 0),
valid: true, valid: true,
}, },
MLOAD: operation{ MLOAD: {
execute: opMload, execute: opMload,
gasCost: gasMLoad, gasCost: gasMLoad,
validateStack: makeStackFunc(1, 1), validateStack: makeStackFunc(1, 1),
memorySize: memoryMLoad, memorySize: memoryMLoad,
valid: true, valid: true,
}, },
MSTORE: operation{ MSTORE: {
execute: opMstore, execute: opMstore,
gasCost: gasMStore, gasCost: gasMStore,
validateStack: makeStackFunc(2, 0), validateStack: makeStackFunc(2, 0),
memorySize: memoryMStore, memorySize: memoryMStore,
valid: true, valid: true,
}, },
MSTORE8: operation{ MSTORE8: {
execute: opMstore8, execute: opMstore8,
gasCost: gasMStore8, gasCost: gasMStore8,
memorySize: memoryMStore8, memorySize: memoryMStore8,
@ -336,71 +336,71 @@ func NewJumpTable() [256]operation {
valid: true, valid: true,
}, },
SLOAD: operation{ SLOAD: {
execute: opSload, execute: opSload,
gasCost: gasSLoad, gasCost: gasSLoad,
validateStack: makeStackFunc(1, 1), validateStack: makeStackFunc(1, 1),
valid: true, valid: true,
}, },
SSTORE: operation{ SSTORE: {
execute: opSstore, execute: opSstore,
gasCost: gasSStore, gasCost: gasSStore,
validateStack: makeStackFunc(2, 0), validateStack: makeStackFunc(2, 0),
valid: true, valid: true,
}, },
JUMPDEST: operation{ JUMPDEST: {
execute: opJumpdest, execute: opJumpdest,
gasCost: constGasFunc(params.JumpdestGas), gasCost: constGasFunc(params.JumpdestGas),
validateStack: makeStackFunc(0, 0), validateStack: makeStackFunc(0, 0),
valid: true, valid: true,
}, },
PC: operation{ PC: {
execute: opPc, execute: opPc,
gasCost: constGasFunc(GasQuickStep), gasCost: constGasFunc(GasQuickStep),
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
MSIZE: operation{ MSIZE: {
execute: opMsize, execute: opMsize,
gasCost: constGasFunc(GasQuickStep), gasCost: constGasFunc(GasQuickStep),
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
GAS: operation{ GAS: {
execute: opGas, execute: opGas,
gasCost: constGasFunc(GasQuickStep), gasCost: constGasFunc(GasQuickStep),
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
CREATE: operation{ CREATE: {
execute: opCreate, execute: opCreate,
gasCost: gasCreate, gasCost: gasCreate,
validateStack: makeStackFunc(3, 1), validateStack: makeStackFunc(3, 1),
memorySize: memoryCreate, memorySize: memoryCreate,
valid: true, valid: true,
}, },
CALL: operation{ CALL: {
execute: opCall, execute: opCall,
gasCost: gasCall, gasCost: gasCall,
validateStack: makeStackFunc(7, 1), validateStack: makeStackFunc(7, 1),
memorySize: memoryCall, memorySize: memoryCall,
valid: true, valid: true,
}, },
CALLCODE: operation{ CALLCODE: {
execute: opCallCode, execute: opCallCode,
gasCost: gasCallCode, gasCost: gasCallCode,
validateStack: makeStackFunc(7, 1), validateStack: makeStackFunc(7, 1),
memorySize: memoryCall, memorySize: memoryCall,
valid: true, valid: true,
}, },
DELEGATECALL: operation{ DELEGATECALL: {
execute: opDelegateCall, execute: opDelegateCall,
gasCost: gasDelegateCall, gasCost: gasDelegateCall,
validateStack: makeStackFunc(6, 1), validateStack: makeStackFunc(6, 1),
memorySize: memoryDelegateCall, memorySize: memoryDelegateCall,
valid: true, valid: true,
}, },
RETURN: operation{ RETURN: {
execute: opReturn, execute: opReturn,
gasCost: gasReturn, gasCost: gasReturn,
validateStack: makeStackFunc(2, 0), validateStack: makeStackFunc(2, 0),
@ -408,448 +408,448 @@ func NewJumpTable() [256]operation {
halts: true, halts: true,
valid: true, valid: true,
}, },
SUICIDE: operation{ SUICIDE: {
execute: opSuicide, execute: opSuicide,
gasCost: gasSuicide, gasCost: gasSuicide,
validateStack: makeStackFunc(1, 0), validateStack: makeStackFunc(1, 0),
halts: true, halts: true,
valid: true, valid: true,
}, },
JUMP: operation{ JUMP: {
execute: opJump, execute: opJump,
gasCost: constGasFunc(GasMidStep), gasCost: constGasFunc(GasMidStep),
validateStack: makeStackFunc(1, 0), validateStack: makeStackFunc(1, 0),
jumps: true, jumps: true,
valid: true, valid: true,
}, },
JUMPI: operation{ JUMPI: {
execute: opJumpi, execute: opJumpi,
gasCost: constGasFunc(GasSlowStep), gasCost: constGasFunc(GasSlowStep),
validateStack: makeStackFunc(2, 0), validateStack: makeStackFunc(2, 0),
jumps: true, jumps: true,
valid: true, valid: true,
}, },
STOP: operation{ STOP: {
execute: opStop, execute: opStop,
gasCost: constGasFunc(Zero), gasCost: constGasFunc(Zero),
validateStack: makeStackFunc(0, 0), validateStack: makeStackFunc(0, 0),
halts: true, halts: true,
valid: true, valid: true,
}, },
LOG0: operation{ LOG0: {
execute: makeLog(0), execute: makeLog(0),
gasCost: makeGasLog(0), gasCost: makeGasLog(0),
validateStack: makeStackFunc(2, 0), validateStack: makeStackFunc(2, 0),
memorySize: memoryLog, memorySize: memoryLog,
valid: true, valid: true,
}, },
LOG1: operation{ LOG1: {
execute: makeLog(1), execute: makeLog(1),
gasCost: makeGasLog(1), gasCost: makeGasLog(1),
validateStack: makeStackFunc(3, 0), validateStack: makeStackFunc(3, 0),
memorySize: memoryLog, memorySize: memoryLog,
valid: true, valid: true,
}, },
LOG2: operation{ LOG2: {
execute: makeLog(2), execute: makeLog(2),
gasCost: makeGasLog(2), gasCost: makeGasLog(2),
validateStack: makeStackFunc(4, 0), validateStack: makeStackFunc(4, 0),
memorySize: memoryLog, memorySize: memoryLog,
valid: true, valid: true,
}, },
LOG3: operation{ LOG3: {
execute: makeLog(3), execute: makeLog(3),
gasCost: makeGasLog(3), gasCost: makeGasLog(3),
validateStack: makeStackFunc(5, 0), validateStack: makeStackFunc(5, 0),
memorySize: memoryLog, memorySize: memoryLog,
valid: true, valid: true,
}, },
LOG4: operation{ LOG4: {
execute: makeLog(4), execute: makeLog(4),
gasCost: makeGasLog(4), gasCost: makeGasLog(4),
validateStack: makeStackFunc(6, 0), validateStack: makeStackFunc(6, 0),
memorySize: memoryLog, memorySize: memoryLog,
valid: true, valid: true,
}, },
SWAP1: operation{ SWAP1: {
execute: makeSwap(1), execute: makeSwap(1),
gasCost: gasSwap, gasCost: gasSwap,
validateStack: makeStackFunc(2, 0), validateStack: makeStackFunc(2, 0),
valid: true, valid: true,
}, },
SWAP2: operation{ SWAP2: {
execute: makeSwap(2), execute: makeSwap(2),
gasCost: gasSwap, gasCost: gasSwap,
validateStack: makeStackFunc(3, 0), validateStack: makeStackFunc(3, 0),
valid: true, valid: true,
}, },
SWAP3: operation{ SWAP3: {
execute: makeSwap(3), execute: makeSwap(3),
gasCost: gasSwap, gasCost: gasSwap,
validateStack: makeStackFunc(4, 0), validateStack: makeStackFunc(4, 0),
valid: true, valid: true,
}, },
SWAP4: operation{ SWAP4: {
execute: makeSwap(4), execute: makeSwap(4),
gasCost: gasSwap, gasCost: gasSwap,
validateStack: makeStackFunc(5, 0), validateStack: makeStackFunc(5, 0),
valid: true, valid: true,
}, },
SWAP5: operation{ SWAP5: {
execute: makeSwap(5), execute: makeSwap(5),
gasCost: gasSwap, gasCost: gasSwap,
validateStack: makeStackFunc(6, 0), validateStack: makeStackFunc(6, 0),
valid: true, valid: true,
}, },
SWAP6: operation{ SWAP6: {
execute: makeSwap(6), execute: makeSwap(6),
gasCost: gasSwap, gasCost: gasSwap,
validateStack: makeStackFunc(7, 0), validateStack: makeStackFunc(7, 0),
valid: true, valid: true,
}, },
SWAP7: operation{ SWAP7: {
execute: makeSwap(7), execute: makeSwap(7),
gasCost: gasSwap, gasCost: gasSwap,
validateStack: makeStackFunc(8, 0), validateStack: makeStackFunc(8, 0),
valid: true, valid: true,
}, },
SWAP8: operation{ SWAP8: {
execute: makeSwap(8), execute: makeSwap(8),
gasCost: gasSwap, gasCost: gasSwap,
validateStack: makeStackFunc(9, 0), validateStack: makeStackFunc(9, 0),
valid: true, valid: true,
}, },
SWAP9: operation{ SWAP9: {
execute: makeSwap(9), execute: makeSwap(9),
gasCost: gasSwap, gasCost: gasSwap,
validateStack: makeStackFunc(10, 0), validateStack: makeStackFunc(10, 0),
valid: true, valid: true,
}, },
SWAP10: operation{ SWAP10: {
execute: makeSwap(10), execute: makeSwap(10),
gasCost: gasSwap, gasCost: gasSwap,
validateStack: makeStackFunc(11, 0), validateStack: makeStackFunc(11, 0),
valid: true, valid: true,
}, },
SWAP11: operation{ SWAP11: {
execute: makeSwap(11), execute: makeSwap(11),
gasCost: gasSwap, gasCost: gasSwap,
validateStack: makeStackFunc(12, 0), validateStack: makeStackFunc(12, 0),
valid: true, valid: true,
}, },
SWAP12: operation{ SWAP12: {
execute: makeSwap(12), execute: makeSwap(12),
gasCost: gasSwap, gasCost: gasSwap,
validateStack: makeStackFunc(13, 0), validateStack: makeStackFunc(13, 0),
valid: true, valid: true,
}, },
SWAP13: operation{ SWAP13: {
execute: makeSwap(13), execute: makeSwap(13),
gasCost: gasSwap, gasCost: gasSwap,
validateStack: makeStackFunc(14, 0), validateStack: makeStackFunc(14, 0),
valid: true, valid: true,
}, },
SWAP14: operation{ SWAP14: {
execute: makeSwap(14), execute: makeSwap(14),
gasCost: gasSwap, gasCost: gasSwap,
validateStack: makeStackFunc(15, 0), validateStack: makeStackFunc(15, 0),
valid: true, valid: true,
}, },
SWAP15: operation{ SWAP15: {
execute: makeSwap(15), execute: makeSwap(15),
gasCost: gasSwap, gasCost: gasSwap,
validateStack: makeStackFunc(16, 0), validateStack: makeStackFunc(16, 0),
valid: true, valid: true,
}, },
SWAP16: operation{ SWAP16: {
execute: makeSwap(16), execute: makeSwap(16),
gasCost: gasSwap, gasCost: gasSwap,
validateStack: makeStackFunc(17, 0), validateStack: makeStackFunc(17, 0),
valid: true, valid: true,
}, },
PUSH1: operation{ PUSH1: {
execute: makePush(1, big.NewInt(1)), execute: makePush(1, big.NewInt(1)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH2: operation{ PUSH2: {
execute: makePush(2, big.NewInt(2)), execute: makePush(2, big.NewInt(2)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH3: operation{ PUSH3: {
execute: makePush(3, big.NewInt(3)), execute: makePush(3, big.NewInt(3)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH4: operation{ PUSH4: {
execute: makePush(4, big.NewInt(4)), execute: makePush(4, big.NewInt(4)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH5: operation{ PUSH5: {
execute: makePush(5, big.NewInt(5)), execute: makePush(5, big.NewInt(5)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH6: operation{ PUSH6: {
execute: makePush(6, big.NewInt(6)), execute: makePush(6, big.NewInt(6)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH7: operation{ PUSH7: {
execute: makePush(7, big.NewInt(7)), execute: makePush(7, big.NewInt(7)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH8: operation{ PUSH8: {
execute: makePush(8, big.NewInt(8)), execute: makePush(8, big.NewInt(8)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH9: operation{ PUSH9: {
execute: makePush(9, big.NewInt(9)), execute: makePush(9, big.NewInt(9)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH10: operation{ PUSH10: {
execute: makePush(10, big.NewInt(10)), execute: makePush(10, big.NewInt(10)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH11: operation{ PUSH11: {
execute: makePush(11, big.NewInt(11)), execute: makePush(11, big.NewInt(11)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH12: operation{ PUSH12: {
execute: makePush(12, big.NewInt(12)), execute: makePush(12, big.NewInt(12)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH13: operation{ PUSH13: {
execute: makePush(13, big.NewInt(13)), execute: makePush(13, big.NewInt(13)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH14: operation{ PUSH14: {
execute: makePush(14, big.NewInt(14)), execute: makePush(14, big.NewInt(14)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH15: operation{ PUSH15: {
execute: makePush(15, big.NewInt(15)), execute: makePush(15, big.NewInt(15)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH16: operation{ PUSH16: {
execute: makePush(16, big.NewInt(16)), execute: makePush(16, big.NewInt(16)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH17: operation{ PUSH17: {
execute: makePush(17, big.NewInt(17)), execute: makePush(17, big.NewInt(17)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH18: operation{ PUSH18: {
execute: makePush(18, big.NewInt(18)), execute: makePush(18, big.NewInt(18)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH19: operation{ PUSH19: {
execute: makePush(19, big.NewInt(19)), execute: makePush(19, big.NewInt(19)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH20: operation{ PUSH20: {
execute: makePush(20, big.NewInt(20)), execute: makePush(20, big.NewInt(20)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH21: operation{ PUSH21: {
execute: makePush(21, big.NewInt(21)), execute: makePush(21, big.NewInt(21)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH22: operation{ PUSH22: {
execute: makePush(22, big.NewInt(22)), execute: makePush(22, big.NewInt(22)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH23: operation{ PUSH23: {
execute: makePush(23, big.NewInt(23)), execute: makePush(23, big.NewInt(23)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH24: operation{ PUSH24: {
execute: makePush(24, big.NewInt(24)), execute: makePush(24, big.NewInt(24)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH25: operation{ PUSH25: {
execute: makePush(25, big.NewInt(25)), execute: makePush(25, big.NewInt(25)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH26: operation{ PUSH26: {
execute: makePush(26, big.NewInt(26)), execute: makePush(26, big.NewInt(26)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH27: operation{ PUSH27: {
execute: makePush(27, big.NewInt(27)), execute: makePush(27, big.NewInt(27)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH28: operation{ PUSH28: {
execute: makePush(28, big.NewInt(28)), execute: makePush(28, big.NewInt(28)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH29: operation{ PUSH29: {
execute: makePush(29, big.NewInt(29)), execute: makePush(29, big.NewInt(29)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH30: operation{ PUSH30: {
execute: makePush(30, big.NewInt(30)), execute: makePush(30, big.NewInt(30)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH31: operation{ PUSH31: {
execute: makePush(31, big.NewInt(31)), execute: makePush(31, big.NewInt(31)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH32: operation{ PUSH32: {
execute: makePush(32, big.NewInt(32)), execute: makePush(32, big.NewInt(32)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
DUP1: operation{ DUP1: {
execute: makeDup(1), execute: makeDup(1),
gasCost: gasDup, gasCost: gasDup,
validateStack: makeStackFunc(1, 1), validateStack: makeStackFunc(1, 1),
valid: true, valid: true,
}, },
DUP2: operation{ DUP2: {
execute: makeDup(2), execute: makeDup(2),
gasCost: gasDup, gasCost: gasDup,
validateStack: makeStackFunc(2, 1), validateStack: makeStackFunc(2, 1),
valid: true, valid: true,
}, },
DUP3: operation{ DUP3: {
execute: makeDup(3), execute: makeDup(3),
gasCost: gasDup, gasCost: gasDup,
validateStack: makeStackFunc(3, 1), validateStack: makeStackFunc(3, 1),
valid: true, valid: true,
}, },
DUP4: operation{ DUP4: {
execute: makeDup(4), execute: makeDup(4),
gasCost: gasDup, gasCost: gasDup,
validateStack: makeStackFunc(4, 1), validateStack: makeStackFunc(4, 1),
valid: true, valid: true,
}, },
DUP5: operation{ DUP5: {
execute: makeDup(5), execute: makeDup(5),
gasCost: gasDup, gasCost: gasDup,
validateStack: makeStackFunc(5, 1), validateStack: makeStackFunc(5, 1),
valid: true, valid: true,
}, },
DUP6: operation{ DUP6: {
execute: makeDup(6), execute: makeDup(6),
gasCost: gasDup, gasCost: gasDup,
validateStack: makeStackFunc(6, 1), validateStack: makeStackFunc(6, 1),
valid: true, valid: true,
}, },
DUP7: operation{ DUP7: {
execute: makeDup(7), execute: makeDup(7),
gasCost: gasDup, gasCost: gasDup,
validateStack: makeStackFunc(7, 1), validateStack: makeStackFunc(7, 1),
valid: true, valid: true,
}, },
DUP8: operation{ DUP8: {
execute: makeDup(8), execute: makeDup(8),
gasCost: gasDup, gasCost: gasDup,
validateStack: makeStackFunc(8, 1), validateStack: makeStackFunc(8, 1),
valid: true, valid: true,
}, },
DUP9: operation{ DUP9: {
execute: makeDup(9), execute: makeDup(9),
gasCost: gasDup, gasCost: gasDup,
validateStack: makeStackFunc(9, 1), validateStack: makeStackFunc(9, 1),
valid: true, valid: true,
}, },
DUP10: operation{ DUP10: {
execute: makeDup(10), execute: makeDup(10),
gasCost: gasDup, gasCost: gasDup,
validateStack: makeStackFunc(10, 1), validateStack: makeStackFunc(10, 1),
valid: true, valid: true,
}, },
DUP11: operation{ DUP11: {
execute: makeDup(11), execute: makeDup(11),
gasCost: gasDup, gasCost: gasDup,
validateStack: makeStackFunc(11, 1), validateStack: makeStackFunc(11, 1),
valid: true, valid: true,
}, },
DUP12: operation{ DUP12: {
execute: makeDup(12), execute: makeDup(12),
gasCost: gasDup, gasCost: gasDup,
validateStack: makeStackFunc(12, 1), validateStack: makeStackFunc(12, 1),
valid: true, valid: true,
}, },
DUP13: operation{ DUP13: {
execute: makeDup(13), execute: makeDup(13),
gasCost: gasDup, gasCost: gasDup,
validateStack: makeStackFunc(13, 1), validateStack: makeStackFunc(13, 1),
valid: true, valid: true,
}, },
DUP14: operation{ DUP14: {
execute: makeDup(14), execute: makeDup(14),
gasCost: gasDup, gasCost: gasDup,
validateStack: makeStackFunc(14, 1), validateStack: makeStackFunc(14, 1),
valid: true, valid: true,
}, },
DUP15: operation{ DUP15: {
execute: makeDup(15), execute: makeDup(15),
gasCost: gasDup, gasCost: gasDup,
validateStack: makeStackFunc(15, 1), validateStack: makeStackFunc(15, 1),
valid: true, valid: true,
}, },
DUP16: operation{ DUP16: {
execute: makeDup(16), execute: makeDup(16),
gasCost: gasDup, gasCost: gasDup,
validateStack: makeStackFunc(16, 1), validateStack: makeStackFunc(16, 1),

12
crypto/ecies/asn1.go
Unescape View File

@ -109,7 +109,7 @@ func (curve secgNamedCurve) Equal(curve2 secgNamedCurve) bool {
if len(curve) != len(curve2) { if len(curve) != len(curve2) {
return false return false
} }
for i, _ := range curve { for i := range curve {
if curve[i] != curve2[i] { if curve[i] != curve2[i] {
return false return false
} }
@ -157,7 +157,7 @@ func (a asnAlgorithmIdentifier) Cmp(b asnAlgorithmIdentifier) bool {
if len(a.Algorithm) != len(b.Algorithm) { if len(a.Algorithm) != len(b.Algorithm) {
return false return false
} }
for i, _ := range a.Algorithm { for i := range a.Algorithm {
if a.Algorithm[i] != b.Algorithm[i] { if a.Algorithm[i] != b.Algorithm[i] {
return false return false
} }
@ -306,7 +306,7 @@ func (a asnECDHAlgorithm) Cmp(b asnECDHAlgorithm) bool {
if len(a.Algorithm) != len(b.Algorithm) { if len(a.Algorithm) != len(b.Algorithm) {
return false return false
} }
for i, _ := range a.Algorithm { for i := range a.Algorithm {
if a.Algorithm[i] != b.Algorithm[i] { if a.Algorithm[i] != b.Algorithm[i] {
return false return false
} }
@ -325,7 +325,7 @@ func (a asnKeyDerivationFunction) Cmp(b asnKeyDerivationFunction) bool {
if len(a.Algorithm) != len(b.Algorithm) { if len(a.Algorithm) != len(b.Algorithm) {
return false return false
} }
for i, _ := range a.Algorithm { for i := range a.Algorithm {
if a.Algorithm[i] != b.Algorithm[i] { if a.Algorithm[i] != b.Algorithm[i] {
return false return false
} }
@ -360,7 +360,7 @@ func (a asnSymmetricEncryption) Cmp(b asnSymmetricEncryption) bool {
if len(a.Algorithm) != len(b.Algorithm) { if len(a.Algorithm) != len(b.Algorithm) {
return false return false
} }
for i, _ := range a.Algorithm { for i := range a.Algorithm {
if a.Algorithm[i] != b.Algorithm[i] { if a.Algorithm[i] != b.Algorithm[i] {
return false return false
} }
@ -380,7 +380,7 @@ func (a asnMessageAuthenticationCode) Cmp(b asnMessageAuthenticationCode) bool {
if len(a.Algorithm) != len(b.Algorithm) { if len(a.Algorithm) != len(b.Algorithm) {
return false return false
} }
for i, _ := range a.Algorithm { for i := range a.Algorithm {
if a.Algorithm[i] != b.Algorithm[i] { if a.Algorithm[i] != b.Algorithm[i] {
return false return false
} }

6
crypto/ecies/ecies_test.go
Unescape View File

@ -492,17 +492,17 @@ type testCase struct {
} }
var testCases = []testCase{ var testCases = []testCase{
testCase{ {
Curve: elliptic.P256(), Curve: elliptic.P256(),
Name: "P256", Name: "P256",
Expected: true, Expected: true,
}, },
testCase{ {
Curve: elliptic.P384(), Curve: elliptic.P384(),
Name: "P384", Name: "P384",
Expected: true, Expected: true,
}, },
testCase{ {
Curve: elliptic.P521(), Curve: elliptic.P521(),
Name: "P521", Name: "P521",
Expected: true, Expected: true,

2
crypto/sha3/sha3_test.go
Unescape View File

@ -201,7 +201,7 @@ func TestSqueezing(t *testing.T) {
d1 := newShakeHash() d1 := newShakeHash()
d1.Write([]byte(testString)) d1.Write([]byte(testString))
var multiple []byte var multiple []byte
for _ = range ref { for range ref {
one := make([]byte, 1) one := make([]byte, 1)
d1.Read(one) d1.Read(one)
multiple = append(multiple, one...) multiple = append(multiple, one...)

4
eth/backend_test.go
Unescape View File

@ -37,12 +37,12 @@ func TestMipmapUpgrade(t *testing.T) {
switch i { switch i {
case 1: case 1:
receipt := types.NewReceipt(nil, new(big.Int)) receipt := types.NewReceipt(nil, new(big.Int))
receipt.Logs = []*types.Log{&types.Log{Address: addr}} receipt.Logs = []*types.Log{{Address: addr}}
gen.AddUncheckedReceipt(receipt) gen.AddUncheckedReceipt(receipt)
receipts = types.Receipts{receipt} receipts = types.Receipts{receipt}
case 2: case 2:
receipt := types.NewReceipt(nil, new(big.Int)) receipt := types.NewReceipt(nil, new(big.Int))
receipt.Logs = []*types.Log{&types.Log{Address: addr}} receipt.Logs = []*types.Log{{Address: addr}}
gen.AddUncheckedReceipt(receipt) gen.AddUncheckedReceipt(receipt)
receipts = types.Receipts{receipt} receipts = types.Receipts{receipt}
} }

4
eth/downloader/peer.go
Unescape View File

@ -205,7 +205,7 @@ func (p *peer) FetchNodeData(request *fetchRequest) error {
// Convert the hash set to a retrievable slice // Convert the hash set to a retrievable slice
hashes := make([]common.Hash, 0, len(request.Hashes)) hashes := make([]common.Hash, 0, len(request.Hashes))
for hash, _ := range request.Hashes { for hash := range request.Hashes {
hashes = append(hashes, hash) hashes = append(hashes, hash)
} }
go p.getNodeData(hashes) go p.getNodeData(hashes)
@ -314,7 +314,7 @@ func (p *peer) MarkLacking(hash common.Hash) {
defer p.lock.Unlock() defer p.lock.Unlock()
for len(p.lacking) >= maxLackingHashes { for len(p.lacking) >= maxLackingHashes {
for drop, _ := range p.lacking { for drop := range p.lacking {
delete(p.lacking, drop) delete(p.lacking, drop)
break break
} }

4
eth/downloader/queue.go
Unescape View File

@ -844,7 +844,7 @@ func (q *queue) expire(timeout time.Duration, pendPool map[string]*fetchRequest,
} }
} }
// Remove the expired requests from the pending pool // Remove the expired requests from the pending pool
for id, _ := range expiries { for id := range expiries {
delete(pendPool, id) delete(pendPool, id)
} }
return expiries return expiries
@ -1063,7 +1063,7 @@ func (q *queue) DeliverNodeData(id string, data [][]byte, callback func(int, boo
// If no data was retrieved, mark their hashes as unavailable for the origin peer // If no data was retrieved, mark their hashes as unavailable for the origin peer
if len(data) == 0 { if len(data) == 0 {
for hash, _ := range request.Hashes { for hash := range request.Hashes {
request.Peer.MarkLacking(hash) request.Peer.MarkLacking(hash)
} }
} }

2
eth/filters/api.go
Unescape View File

@ -505,7 +505,7 @@ func (args *FilterCriteria) UnmarshalJSON(data []byte) error {
switch topic := t.(type) { switch topic := t.(type) {
case nil: case nil:
// ignore topic when matching logs // ignore topic when matching logs
args.Topics[i] = []common.Hash{common.Hash{}} args.Topics[i] = []common.Hash{{}}
case string: case string:
// match specific topic // match specific topic

22
eth/filters/filter_system_test.go
Unescape View File

@ -281,15 +281,15 @@ func TestLogFilter(t *testing.T) {
// match all // match all
0: {FilterCriteria{}, allLogs, ""}, 0: {FilterCriteria{}, allLogs, ""},
// match none due to no matching addresses // match none due to no matching addresses
1: {FilterCriteria{Addresses: []common.Address{common.Address{}, notUsedAddress}, Topics: [][]common.Hash{allLogs[0].Topics}}, []*types.Log{}, ""}, 1: {FilterCriteria{Addresses: []common.Address{{}, notUsedAddress}, Topics: [][]common.Hash{allLogs[0].Topics}}, []*types.Log{}, ""},
// match logs based on addresses, ignore topics // match logs based on addresses, ignore topics
2: {FilterCriteria{Addresses: []common.Address{firstAddr}}, allLogs[:2], ""}, 2: {FilterCriteria{Addresses: []common.Address{firstAddr}}, allLogs[:2], ""},
// match none due to no matching topics (match with address) // match none due to no matching topics (match with address)
3: {FilterCriteria{Addresses: []common.Address{secondAddr}, Topics: [][]common.Hash{[]common.Hash{notUsedTopic}}}, []*types.Log{}, ""}, 3: {FilterCriteria{Addresses: []common.Address{secondAddr}, Topics: [][]common.Hash{{notUsedTopic}}}, []*types.Log{}, ""},
// match logs based on addresses and topics // match logs based on addresses and topics
4: {FilterCriteria{Addresses: []common.Address{thirdAddress}, Topics: [][]common.Hash{[]common.Hash{firstTopic, secondTopic}}}, allLogs[3:5], ""}, 4: {FilterCriteria{Addresses: []common.Address{thirdAddress}, Topics: [][]common.Hash{{firstTopic, secondTopic}}}, allLogs[3:5], ""},
// match logs based on multiple addresses and "or" topics // match logs based on multiple addresses and "or" topics
5: {FilterCriteria{Addresses: []common.Address{secondAddr, thirdAddress}, Topics: [][]common.Hash{[]common.Hash{firstTopic, secondTopic}}}, allLogs[2:5], ""}, 5: {FilterCriteria{Addresses: []common.Address{secondAddr, thirdAddress}, Topics: [][]common.Hash{{firstTopic, secondTopic}}}, allLogs[2:5], ""},
// logs in the pending block // logs in the pending block
6: {FilterCriteria{Addresses: []common.Address{firstAddr}, FromBlock: big.NewInt(rpc.PendingBlockNumber.Int64()), ToBlock: big.NewInt(rpc.PendingBlockNumber.Int64())}, allLogs[:2], ""}, 6: {FilterCriteria{Addresses: []common.Address{firstAddr}, FromBlock: big.NewInt(rpc.PendingBlockNumber.Int64()), ToBlock: big.NewInt(rpc.PendingBlockNumber.Int64())}, allLogs[:2], ""},
// mined logs with block num >= 2 or pending logs // mined logs with block num >= 2 or pending logs
@ -299,9 +299,9 @@ func TestLogFilter(t *testing.T) {
// all "mined" logs // all "mined" logs
9: {FilterCriteria{ToBlock: big.NewInt(rpc.LatestBlockNumber.Int64())}, allLogs, ""}, 9: {FilterCriteria{ToBlock: big.NewInt(rpc.LatestBlockNumber.Int64())}, allLogs, ""},
// all "mined" logs with 1>= block num <=2 and topic secondTopic // all "mined" logs with 1>= block num <=2 and topic secondTopic
10: {FilterCriteria{FromBlock: big.NewInt(1), ToBlock: big.NewInt(2), Topics: [][]common.Hash{[]common.Hash{secondTopic}}}, allLogs[3:4], ""}, 10: {FilterCriteria{FromBlock: big.NewInt(1), ToBlock: big.NewInt(2), Topics: [][]common.Hash{{secondTopic}}}, allLogs[3:4], ""},
// all "mined" and pending logs with topic firstTopic // all "mined" and pending logs with topic firstTopic
11: {FilterCriteria{FromBlock: big.NewInt(rpc.LatestBlockNumber.Int64()), ToBlock: big.NewInt(rpc.PendingBlockNumber.Int64()), Topics: [][]common.Hash{[]common.Hash{firstTopic}}}, expectedCase11, ""}, 11: {FilterCriteria{FromBlock: big.NewInt(rpc.LatestBlockNumber.Int64()), ToBlock: big.NewInt(rpc.PendingBlockNumber.Int64()), Topics: [][]common.Hash{{firstTopic}}}, expectedCase11, ""},
} }
) )
@ -402,19 +402,19 @@ func TestPendingLogsSubscription(t *testing.T) {
// match all // match all
{FilterCriteria{}, convertLogs(allLogs), nil, nil}, {FilterCriteria{}, convertLogs(allLogs), nil, nil},
// match none due to no matching addresses // match none due to no matching addresses
{FilterCriteria{Addresses: []common.Address{common.Address{}, notUsedAddress}, Topics: [][]common.Hash{[]common.Hash{}}}, []*types.Log{}, nil, nil}, {FilterCriteria{Addresses: []common.Address{{}, notUsedAddress}, Topics: [][]common.Hash{{}}}, []*types.Log{}, nil, nil},
// match logs based on addresses, ignore topics // match logs based on addresses, ignore topics
{FilterCriteria{Addresses: []common.Address{firstAddr}}, append(convertLogs(allLogs[:2]), allLogs[5].Logs[3]), nil, nil}, {FilterCriteria{Addresses: []common.Address{firstAddr}}, append(convertLogs(allLogs[:2]), allLogs[5].Logs[3]), nil, nil},
// match none due to no matching topics (match with address) // match none due to no matching topics (match with address)
{FilterCriteria{Addresses: []common.Address{secondAddr}, Topics: [][]common.Hash{[]common.Hash{notUsedTopic}}}, []*types.Log{}, nil, nil}, {FilterCriteria{Addresses: []common.Address{secondAddr}, Topics: [][]common.Hash{{notUsedTopic}}}, []*types.Log{}, nil, nil},
// match logs based on addresses and topics // match logs based on addresses and topics
{FilterCriteria{Addresses: []common.Address{thirdAddress}, Topics: [][]common.Hash{[]common.Hash{firstTopic, secondTopic}}}, append(convertLogs(allLogs[3:5]), allLogs[5].Logs[0]), nil, nil}, {FilterCriteria{Addresses: []common.Address{thirdAddress}, Topics: [][]common.Hash{{firstTopic, secondTopic}}}, append(convertLogs(allLogs[3:5]), allLogs[5].Logs[0]), nil, nil},
// match logs based on multiple addresses and "or" topics // match logs based on multiple addresses and "or" topics
{FilterCriteria{Addresses: []common.Address{secondAddr, thirdAddress}, Topics: [][]common.Hash{[]common.Hash{firstTopic, secondTopic}}}, append(convertLogs(allLogs[2:5]), allLogs[5].Logs[0]), nil, nil}, {FilterCriteria{Addresses: []common.Address{secondAddr, thirdAddress}, Topics: [][]common.Hash{{firstTopic, secondTopic}}}, append(convertLogs(allLogs[2:5]), allLogs[5].Logs[0]), nil, nil},
// block numbers are ignored for filters created with New***Filter, these return all logs that match the given criterias when the state changes // block numbers are ignored for filters created with New***Filter, these return all logs that match the given criterias when the state changes
{FilterCriteria{Addresses: []common.Address{firstAddr}, FromBlock: big.NewInt(2), ToBlock: big.NewInt(3)}, append(convertLogs(allLogs[:2]), allLogs[5].Logs[3]), nil, nil}, {FilterCriteria{Addresses: []common.Address{firstAddr}, FromBlock: big.NewInt(2), ToBlock: big.NewInt(3)}, append(convertLogs(allLogs[:2]), allLogs[5].Logs[3]), nil, nil},
// multiple pending logs, should match only 2 topics from the logs in block 5 // multiple pending logs, should match only 2 topics from the logs in block 5
{FilterCriteria{Addresses: []common.Address{thirdAddress}, Topics: [][]common.Hash{[]common.Hash{firstTopic, forthTopic}}}, []*types.Log{allLogs[5].Logs[0], allLogs[5].Logs[2]}, nil, nil}, {FilterCriteria{Addresses: []common.Address{thirdAddress}, Topics: [][]common.Hash{{firstTopic, forthTopic}}}, []*types.Log{allLogs[5].Logs[0], allLogs[5].Logs[2]}, nil, nil},
} }
) )

12
eth/filters/filter_test.go
Unescape View File

@ -210,7 +210,7 @@ func TestFilters(t *testing.T) {
filter := New(backend, true) filter := New(backend, true)
filter.SetAddresses([]common.Address{addr}) filter.SetAddresses([]common.Address{addr})
filter.SetTopics([][]common.Hash{[]common.Hash{hash1, hash2, hash3, hash4}}) filter.SetTopics([][]common.Hash{{hash1, hash2, hash3, hash4}})
filter.SetBeginBlock(0) filter.SetBeginBlock(0)
filter.SetEndBlock(-1) filter.SetEndBlock(-1)
@ -221,7 +221,7 @@ func TestFilters(t *testing.T) {
filter = New(backend, true) filter = New(backend, true)
filter.SetAddresses([]common.Address{addr}) filter.SetAddresses([]common.Address{addr})
filter.SetTopics([][]common.Hash{[]common.Hash{hash3}}) filter.SetTopics([][]common.Hash{{hash3}})
filter.SetBeginBlock(900) filter.SetBeginBlock(900)
filter.SetEndBlock(999) filter.SetEndBlock(999)
logs, _ = filter.Find(context.Background()) logs, _ = filter.Find(context.Background())
@ -234,7 +234,7 @@ func TestFilters(t *testing.T) {
filter = New(backend, true) filter = New(backend, true)
filter.SetAddresses([]common.Address{addr}) filter.SetAddresses([]common.Address{addr})
filter.SetTopics([][]common.Hash{[]common.Hash{hash3}}) filter.SetTopics([][]common.Hash{{hash3}})
filter.SetBeginBlock(990) filter.SetBeginBlock(990)
filter.SetEndBlock(-1) filter.SetEndBlock(-1)
logs, _ = filter.Find(context.Background()) logs, _ = filter.Find(context.Background())
@ -246,7 +246,7 @@ func TestFilters(t *testing.T) {
} }
filter = New(backend, true) filter = New(backend, true)
filter.SetTopics([][]common.Hash{[]common.Hash{hash1, hash2}}) filter.SetTopics([][]common.Hash{{hash1, hash2}})
filter.SetBeginBlock(1) filter.SetBeginBlock(1)
filter.SetEndBlock(10) filter.SetEndBlock(10)
@ -257,7 +257,7 @@ func TestFilters(t *testing.T) {
failHash := common.BytesToHash([]byte("fail")) failHash := common.BytesToHash([]byte("fail"))
filter = New(backend, true) filter = New(backend, true)
filter.SetTopics([][]common.Hash{[]common.Hash{failHash}}) filter.SetTopics([][]common.Hash{{failHash}})
filter.SetBeginBlock(0) filter.SetBeginBlock(0)
filter.SetEndBlock(-1) filter.SetEndBlock(-1)
@ -278,7 +278,7 @@ func TestFilters(t *testing.T) {
} }
filter = New(backend, true) filter = New(backend, true)
filter.SetTopics([][]common.Hash{[]common.Hash{failHash}, []common.Hash{hash1}}) filter.SetTopics([][]common.Hash{{failHash}, {hash1}})
filter.SetBeginBlock(0) filter.SetBeginBlock(0)
filter.SetEndBlock(-1) filter.SetEndBlock(-1)

12
eth/handler_test.go
Unescape View File

@ -75,7 +75,7 @@ func testGetBlockHeaders(t *testing.T, protocol int) {
// Create a "random" unknown hash for testing // Create a "random" unknown hash for testing
var unknown common.Hash var unknown common.Hash
for i, _ := range unknown { for i := range unknown {
unknown[i] = byte(i) unknown[i] = byte(i)
} }
// Create a batch of tests for various scenarios // Create a batch of tests for various scenarios
@ -246,17 +246,17 @@ func testGetBlockBodies(t *testing.T, protocol int) {
{limit + 1, nil, nil, limit}, // No more than the possible block count should be returned {limit + 1, nil, nil, limit}, // No more than the possible block count should be returned
{0, []common.Hash{pm.blockchain.Genesis().Hash()}, []bool{true}, 1}, // The genesis block should be retrievable {0, []common.Hash{pm.blockchain.Genesis().Hash()}, []bool{true}, 1}, // The genesis block should be retrievable
{0, []common.Hash{pm.blockchain.CurrentBlock().Hash()}, []bool{true}, 1}, // The chains head block should be retrievable {0, []common.Hash{pm.blockchain.CurrentBlock().Hash()}, []bool{true}, 1}, // The chains head block should be retrievable
{0, []common.Hash{common.Hash{}}, []bool{false}, 0}, // A non existent block should not be returned {0, []common.Hash{{}}, []bool{false}, 0}, // A non existent block should not be returned
// Existing and non-existing blocks interleaved should not cause problems // Existing and non-existing blocks interleaved should not cause problems
{0, []common.Hash{ {0, []common.Hash{
common.Hash{}, {},
pm.blockchain.GetBlockByNumber(1).Hash(), pm.blockchain.GetBlockByNumber(1).Hash(),
common.Hash{}, {},
pm.blockchain.GetBlockByNumber(10).Hash(), pm.blockchain.GetBlockByNumber(10).Hash(),
common.Hash{}, {},
pm.blockchain.GetBlockByNumber(100).Hash(), pm.blockchain.GetBlockByNumber(100).Hash(),
common.Hash{}, {},
}, []bool{false, true, false, true, false, true, false}, 3}, }, []bool{false, true, false, true, false, true, false}, 3},
} }
// Run each of the tests and verify the results against the chain // Run each of the tests and verify the results against the chain

2
eth/protocol_test.go
Unescape View File

@ -178,7 +178,7 @@ func testSendTransactions(t *testing.T, protocol int) {
func TestGetBlockHeadersDataEncodeDecode(t *testing.T) { func TestGetBlockHeadersDataEncodeDecode(t *testing.T) {
// Create a "random" hash for testing // Create a "random" hash for testing
var hash common.Hash var hash common.Hash
for i, _ := range hash { for i := range hash {
hash[i] = byte(i) hash[i] = byte(i)
} }
// Assemble some table driven tests // Assemble some table driven tests

2
ethdb/memory_database.go
Unescape View File

@ -67,7 +67,7 @@ func (db *MemDatabase) Keys() [][]byte {
defer db.lock.RUnlock() defer db.lock.RUnlock()
keys := [][]byte{} keys := [][]byte{}
for key, _ := range db.db { for key := range db.db {
keys = append(keys, []byte(key)) keys = append(keys, []byte(key))
} }
return keys return keys

14
ethstats/ethstats.go
Unescape View File

@ -326,7 +326,7 @@ func (s *Service) login(in *json.Decoder, out *json.Encoder) error {
Secret: s.pass, Secret: s.pass,
} }
login := map[string][]interface{}{ login := map[string][]interface{}{
"emit": []interface{}{"hello", auth}, "emit": {"hello", auth},
} }
if err := out.Encode(login); err != nil { if err := out.Encode(login); err != nil {
return err return err
@ -365,7 +365,7 @@ func (s *Service) reportLatency(out *json.Encoder) error {
start := time.Now() start := time.Now()
ping := map[string][]interface{}{ ping := map[string][]interface{}{
"emit": []interface{}{"node-ping", map[string]string{ "emit": {"node-ping", map[string]string{
"id": s.node, "id": s.node,
"clientTime": start.String(), "clientTime": start.String(),
}}, }},
@ -383,7 +383,7 @@ func (s *Service) reportLatency(out *json.Encoder) error {
} }
// Send back the measured latency // Send back the measured latency
latency := map[string][]interface{}{ latency := map[string][]interface{}{
"emit": []interface{}{"latency", map[string]string{ "emit": {"latency", map[string]string{
"id": s.node, "id": s.node,
"latency": strconv.Itoa(int((time.Since(start) / time.Duration(2)).Nanoseconds() / 1000000)), "latency": strconv.Itoa(int((time.Since(start) / time.Duration(2)).Nanoseconds() / 1000000)),
}}, }},
@ -438,7 +438,7 @@ func (s *Service) reportBlock(out *json.Encoder, block *types.Block) error {
"block": s.assembleBlockStats(block), "block": s.assembleBlockStats(block),
} }
report := map[string][]interface{}{ report := map[string][]interface{}{
"emit": []interface{}{"block", stats}, "emit": {"block", stats},
} }
if err := out.Encode(report); err != nil { if err := out.Encode(report); err != nil {
return err return err
@ -531,7 +531,7 @@ func (s *Service) reportHistory(out *json.Encoder, list []uint64) error {
"history": history, "history": history,
} }
report := map[string][]interface{}{ report := map[string][]interface{}{
"emit": []interface{}{"history", stats}, "emit": {"history", stats},
} }
if err := out.Encode(report); err != nil { if err := out.Encode(report); err != nil {
return err return err
@ -562,7 +562,7 @@ func (s *Service) reportPending(out *json.Encoder) error {
}, },
} }
report := map[string][]interface{}{ report := map[string][]interface{}{
"emit": []interface{}{"pending", stats}, "emit": {"pending", stats},
} }
if err := out.Encode(report); err != nil { if err := out.Encode(report); err != nil {
return err return err
@ -616,7 +616,7 @@ func (s *Service) reportStats(out *json.Encoder) error {
}, },
} }
report := map[string][]interface{}{ report := map[string][]interface{}{
"emit": []interface{}{"stats", stats}, "emit": {"stats", stats},
} }
if err := out.Encode(report); err != nil { if err := out.Encode(report); err != nil {
return err return err

4
event/event_test.go
Unescape View File

@ -144,7 +144,7 @@ func TestMuxConcurrent(t *testing.T) {
func emptySubscriber(mux *TypeMux, types ...interface{}) { func emptySubscriber(mux *TypeMux, types ...interface{}) {
s := mux.Subscribe(testEvent(0)) s := mux.Subscribe(testEvent(0))
go func() { go func() {
for _ = range s.Chan() { for range s.Chan() {
} }
}() }()
} }
@ -187,7 +187,7 @@ func BenchmarkChanSend(b *testing.B) {
c := make(chan interface{}) c := make(chan interface{})
closed := make(chan struct{}) closed := make(chan struct{})
go func() { go func() {
for _ = range c { for range c {
} }
}() }()

2
event/filter/generic_filter.go
Unescape View File

@ -34,7 +34,7 @@ func (self Generic) Compare(f Filter) bool {
strMatch = false strMatch = false
} }
for k, _ := range self.Data { for k := range self.Data {
if _, ok := filter.Data[k]; !ok { if _, ok := filter.Data[k]; !ok {
return false return false
} }

2
les/fetcher.go
Unescape View File

@ -664,7 +664,7 @@ func (f *lightFetcher) updateMaxConfirmedTd(td *big.Int) {
f.lastUpdateStats.next = newEntry f.lastUpdateStats.next = newEntry
} }
f.lastUpdateStats = newEntry f.lastUpdateStats = newEntry
for p, _ := range f.peers { for p := range f.peers {
f.checkUpdateStats(p, newEntry) f.checkUpdateStats(p, newEntry)
} }
} }

6
les/flowcontrol/manager.go
Unescape View File

@ -126,7 +126,7 @@ func (self *ClientManager) removeNode(node *cmNode) {
// recalc sumWeight // recalc sumWeight
func (self *ClientManager) updateNodes(time int64) (rce bool) { func (self *ClientManager) updateNodes(time int64) (rce bool) {
var sumWeight, rcSum uint64 var sumWeight, rcSum uint64
for node, _ := range self.nodes { for node := range self.nodes {
rc := node.recharging rc := node.recharging
node.update(time) node.update(time)
if rc && !node.recharging { if rc && !node.recharging {
@ -145,13 +145,13 @@ func (self *ClientManager) updateNodes(time int64) (rce bool) {
func (self *ClientManager) update(time int64) { func (self *ClientManager) update(time int64) {
for { for {
firstTime := time firstTime := time
for node, _ := range self.nodes { for node := range self.nodes {
if node.recharging && node.finishRecharge < firstTime { if node.recharging && node.finishRecharge < firstTime {
firstTime = node.finishRecharge firstTime = node.finishRecharge
} }
} }
if self.updateNodes(firstTime) { if self.updateNodes(firstTime) {
for node, _ := range self.nodes { for node := range self.nodes {
if node.recharging { if node.recharging {
node.set(node.serving, self.simReqCnt, self.sumWeight) node.set(node.serving, self.simReqCnt, self.sumWeight)
} }

14
les/handler_test.go
Unescape View File

@ -49,7 +49,7 @@ func testGetBlockHeaders(t *testing.T, protocol int) {
// Create a "random" unknown hash for testing // Create a "random" unknown hash for testing
var unknown common.Hash var unknown common.Hash
for i, _ := range unknown { for i := range unknown {
unknown[i] = byte(i) unknown[i] = byte(i)
} }
// Create a batch of tests for various scenarios // Create a batch of tests for various scenarios
@ -189,17 +189,17 @@ func testGetBlockBodies(t *testing.T, protocol int) {
//{limit + 1, nil, nil, limit}, // No more than the possible block count should be returned //{limit + 1, nil, nil, limit}, // No more than the possible block count should be returned
{0, []common.Hash{bc.Genesis().Hash()}, []bool{true}, 1}, // The genesis block should be retrievable {0, []common.Hash{bc.Genesis().Hash()}, []bool{true}, 1}, // The genesis block should be retrievable
{0, []common.Hash{bc.CurrentBlock().Hash()}, []bool{true}, 1}, // The chains head block should be retrievable {0, []common.Hash{bc.CurrentBlock().Hash()}, []bool{true}, 1}, // The chains head block should be retrievable
{0, []common.Hash{common.Hash{}}, []bool{false}, 0}, // A non existent block should not be returned {0, []common.Hash{{}}, []bool{false}, 0}, // A non existent block should not be returned
// Existing and non-existing blocks interleaved should not cause problems // Existing and non-existing blocks interleaved should not cause problems
{0, []common.Hash{ {0, []common.Hash{
common.Hash{}, {},
bc.GetBlockByNumber(1).Hash(), bc.GetBlockByNumber(1).Hash(),
common.Hash{}, {},
bc.GetBlockByNumber(10).Hash(), bc.GetBlockByNumber(10).Hash(),
common.Hash{}, {},
bc.GetBlockByNumber(100).Hash(), bc.GetBlockByNumber(100).Hash(),
common.Hash{}, {},
}, []bool{false, true, false, true, false, true, false}, 3}, }, []bool{false, true, false, true, false, true, false}, 3},
} }
// Run each of the tests and verify the results against the chain // Run each of the tests and verify the results against the chain
@ -312,7 +312,7 @@ func testGetProofs(t *testing.T, protocol int) {
var proofreqs []ProofReq var proofreqs []ProofReq
var proofs [][]rlp.RawValue var proofs [][]rlp.RawValue
accounts := []common.Address{testBankAddress, acc1Addr, acc2Addr, common.Address{}} accounts := []common.Address{testBankAddress, acc1Addr, acc2Addr, {}}
for i := uint64(0); i <= bc.CurrentBlock().NumberU64(); i++ { for i := uint64(0); i <= bc.CurrentBlock().NumberU64(); i++ {
header := bc.GetHeaderByNumber(i) header := bc.GetHeaderByNumber(i)
root := header.Root root := header.Root

2
les/peer.go
Unescape View File

@ -467,7 +467,7 @@ func (ps *peerSet) AllPeerIDs() []string {
res := make([]string, len(ps.peers)) res := make([]string, len(ps.peers))
idx := 0 idx := 0
for id, _ := range ps.peers { for id := range ps.peers {
res[idx] = id res[idx] = id
idx++ idx++
} }

2
les/randselect_test.go
Unescape View File

@ -39,7 +39,7 @@ func TestWeightedRandomSelect(t *testing.T) {
s := newWeightedRandomSelect() s := newWeightedRandomSelect()
w := -1 w := -1
list := make([]testWrsItem, cnt) list := make([]testWrsItem, cnt)
for i, _ := range list { for i := range list {
list[i] = testWrsItem{idx: i, widx: &w} list[i] = testWrsItem{idx: i, widx: &w}
s.update(&list[i]) s.update(&list[i])
} }

2
les/serverpool.go
Unescape View File

@ -414,7 +414,7 @@ func (pool *serverPool) loadNodes() {
// ordered from least to most recently connected. // ordered from least to most recently connected.
func (pool *serverPool) saveNodes() { func (pool *serverPool) saveNodes() {
list := make([]*poolEntry, len(pool.knownQueue.queue)) list := make([]*poolEntry, len(pool.knownQueue.queue))
for i, _ := range list { for i := range list {
list[i] = pool.knownQueue.fetchOldest() list[i] = pool.knownQueue.fetchOldest()
} }
enc, err := rlp.EncodeToBytes(list) enc, err := rlp.EncodeToBytes(list)

12
les/sync.go
Unescape View File

@ -43,12 +43,12 @@ func (pm *ProtocolManager) syncer() {
for { for {
select { select {
case <-pm.newPeerCh: case <-pm.newPeerCh:
/* // Make sure we have peers to select from, then sync /* // Make sure we have peers to select from, then sync
if pm.peers.Len() < minDesiredPeerCount { if pm.peers.Len() < minDesiredPeerCount {
break break
} }
go pm.synchronise(pm.peers.BestPeer()) go pm.synchronise(pm.peers.BestPeer())
*/ */
/*case <-forceSync: /*case <-forceSync:
// Force a sync even if not enough peers are present // Force a sync even if not enough peers are present
go pm.synchronise(pm.peers.BestPeer()) go pm.synchronise(pm.peers.BestPeer())

2
les/txrelay.go
Unescape View File

@ -138,7 +138,7 @@ func (self *LesTxRelay) NewHead(head common.Hash, mined []common.Hash, rollback
if len(self.txPending) > 0 { if len(self.txPending) > 0 {
txs := make(types.Transactions, len(self.txPending)) txs := make(types.Transactions, len(self.txPending))
i := 0 i := 0
for hash, _ := range self.txPending { for hash := range self.txPending {
txs[i] = self.txSent[hash].tx txs[i] = self.txSent[hash].tx
i++ i++
} }

2
light/lightchain.go
Unescape View File

@ -135,7 +135,7 @@ func NewLightChain(odr OdrBackend, config *params.ChainConfig, pow pow.PoW, mux
return nil, err return nil, err
} }
// Check the current state of the block hashes and make sure that we do not have any of the bad blocks in our chain // Check the current state of the block hashes and make sure that we do not have any of the bad blocks in our chain
for hash, _ := range core.BadHashes { for hash := range core.BadHashes {
if header := bc.GetHeaderByHash(hash); header != nil { if header := bc.GetHeaderByHash(hash); header != nil {
glog.V(logger.Error).Infof("Found bad hash, rewinding chain to block #%d [%x…]", header.Number, header.ParentHash[:4]) glog.V(logger.Error).Infof("Found bad hash, rewinding chain to block #%d [%x…]", header.Number, header.ParentHash[:4])
bc.SetHead(header.Number.Uint64() - 1) bc.SetHead(header.Number.Uint64() - 1)

2
light/txpool_test.go
Unescape View File

@ -73,7 +73,7 @@ func txPoolTestChainGen(i int, block *core.BlockGen) {
} }
func TestTxPool(t *testing.T) { func TestTxPool(t *testing.T) {
for i, _ := range testTx { for i := range testTx {
testTx[i], _ = types.SignTx(types.NewTransaction(uint64(i), acc1Addr, big.NewInt(10000), params.TxGas, nil, nil), types.HomesteadSigner{}, testBankKey) testTx[i], _ = types.SignTx(types.NewTransaction(uint64(i), acc1Addr, big.NewInt(10000), params.TxGas, nil, nil), types.HomesteadSigner{}, testBankKey)
} }

2
logger/glog/glog.go
Unescape View File

@ -928,7 +928,7 @@ const flushInterval = 30 * time.Second
// flushDaemon periodically flushes the log file buffers. // flushDaemon periodically flushes the log file buffers.
func (l *loggingT) flushDaemon() { func (l *loggingT) flushDaemon() {
for _ = range time.NewTicker(flushInterval).C { for range time.NewTicker(flushInterval).C {
l.lockAndFlushAll() l.lockAndFlushAll()
} }
} }

2
miner/worker.go
Unescape View File

@ -256,7 +256,7 @@ func (self *worker) update() {
self.currentMu.Lock() self.currentMu.Lock()
acc, _ := types.Sender(self.current.signer, ev.Tx) acc, _ := types.Sender(self.current.signer, ev.Tx)
txs := map[common.Address]types.Transactions{acc: types.Transactions{ev.Tx}} txs := map[common.Address]types.Transactions{acc: {ev.Tx}}
txset := types.NewTransactionsByPriceAndNonce(txs) txset := types.NewTransactionsByPriceAndNonce(txs)
self.current.commitTransactions(self.mux, txset, self.gasPrice, self.chain) self.current.commitTransactions(self.mux, txset, self.gasPrice, self.chain)

2
mobile/p2p.go
Unescape View File

@ -38,7 +38,7 @@ func (ni *NodeInfo) GetListenerPort() int { return ni.info.Ports.Listener
func (ni *NodeInfo) GetListenerAddress() string { return ni.info.ListenAddr } func (ni *NodeInfo) GetListenerAddress() string { return ni.info.ListenAddr }
func (ni *NodeInfo) GetProtocols() *Strings { func (ni *NodeInfo) GetProtocols() *Strings {
protos := []string{} protos := []string{}
for proto, _ := range ni.info.Protocols { for proto := range ni.info.Protocols {
protos = append(protos, proto) protos = append(protos, proto)
} }
return &Strings{protos} return &Strings{protos}

12
node/node_test.go
Unescape View File

@ -166,7 +166,7 @@ func TestServiceLifeCycle(t *testing.T) {
if err := stack.Start(); err != nil { if err := stack.Start(); err != nil {
t.Fatalf("failed to start protocol stack: %v", err) t.Fatalf("failed to start protocol stack: %v", err)
} }
for id, _ := range services { for id := range services {
if !started[id] { if !started[id] {
t.Fatalf("service %s: freshly started service not running", id) t.Fatalf("service %s: freshly started service not running", id)
} }
@ -178,7 +178,7 @@ func TestServiceLifeCycle(t *testing.T) {
if err := stack.Stop(); err != nil { if err := stack.Stop(); err != nil {
t.Fatalf("failed to stop protocol stack: %v", err) t.Fatalf("failed to stop protocol stack: %v", err)
} }
for id, _ := range services { for id := range services {
if !stopped[id] { if !stopped[id] {
t.Fatalf("service %s: freshly terminated service still running", id) t.Fatalf("service %s: freshly terminated service still running", id)
} }
@ -270,7 +270,7 @@ func TestServiceConstructionAbortion(t *testing.T) {
if err := stack.Start(); err != failure { if err := stack.Start(); err != failure {
t.Fatalf("iter %d: stack startup failure mismatch: have %v, want %v", i, err, failure) t.Fatalf("iter %d: stack startup failure mismatch: have %v, want %v", i, err, failure)
} }
for id, _ := range services { for id := range services {
if started[id] { if started[id] {
t.Fatalf("service %s: started should not have", id) t.Fatalf("service %s: started should not have", id)
} }
@ -322,7 +322,7 @@ func TestServiceStartupAbortion(t *testing.T) {
if err := stack.Start(); err != failure { if err := stack.Start(); err != failure {
t.Fatalf("iter %d: stack startup failure mismatch: have %v, want %v", i, err, failure) t.Fatalf("iter %d: stack startup failure mismatch: have %v, want %v", i, err, failure)
} }
for id, _ := range services { for id := range services {
if started[id] && !stopped[id] { if started[id] && !stopped[id] {
t.Fatalf("service %s: started but not stopped", id) t.Fatalf("service %s: started but not stopped", id)
} }
@ -376,7 +376,7 @@ func TestServiceTerminationGuarantee(t *testing.T) {
if err := stack.Start(); err != nil { if err := stack.Start(); err != nil {
t.Fatalf("iter %d: failed to start protocol stack: %v", i, err) t.Fatalf("iter %d: failed to start protocol stack: %v", i, err)
} }
for id, _ := range services { for id := range services {
if !started[id] { if !started[id] {
t.Fatalf("iter %d, service %s: service not running", i, id) t.Fatalf("iter %d, service %s: service not running", i, id)
} }
@ -397,7 +397,7 @@ func TestServiceTerminationGuarantee(t *testing.T) {
t.Fatalf("iter %d: failure count mismatch: have %d, want %d", i, len(err.Services), 1) t.Fatalf("iter %d: failure count mismatch: have %d, want %d", i, len(err.Services), 1)
} }
} }
for id, _ := range services { for id := range services {
if !stopped[id] { if !stopped[id] {
t.Fatalf("iter %d, service %s: service not terminated", i, id) t.Fatalf("iter %d, service %s: service not terminated", i, id)
} }

4
p2p/discover/database_test.go
Unescape View File

@ -242,12 +242,12 @@ func TestNodeDBSeedQuery(t *testing.T) {
if len(seeds) != len(want) { if len(seeds) != len(want) {
t.Errorf("seed count mismatch: have %v, want %v", len(seeds), len(want)) t.Errorf("seed count mismatch: have %v, want %v", len(seeds), len(want))
} }
for id, _ := range have { for id := range have {
if _, ok := want[id]; !ok { if _, ok := want[id]; !ok {
t.Errorf("extra seed: %v", id) t.Errorf("extra seed: %v", id)
} }
} }
for id, _ := range want { for id := range want {
if _, ok := have[id]; !ok { if _, ok := have[id]; !ok {
t.Errorf("missing seed: %v", id) t.Errorf("missing seed: %v", id)
} }

2
p2p/discover/table.go
Unescape View File

@ -433,7 +433,7 @@ func (tab *Table) bondall(nodes []*Node) (result []*Node) {
rc <- nn rc <- nn
}(nodes[i]) }(nodes[i])
} }
for _ = range nodes { for range nodes {
if n := <-rc; n != nil { if n := <-rc; n != nil {
result = append(result, n) result = append(result, n)
} }

26
p2p/discover/table_test.go
Unescape View File

@ -314,19 +314,19 @@ var lookupTestnet = &preminedTestnet{
target: MustHexID("166aea4f556532c6d34e8b740e5d314af7e9ac0ca79833bd751d6b665f12dfd38ec563c363b32f02aef4a80b44fd3def94612d497b99cb5f17fd24de454927ec"), target: MustHexID("166aea4f556532c6d34e8b740e5d314af7e9ac0ca79833bd751d6b665f12dfd38ec563c363b32f02aef4a80b44fd3def94612d497b99cb5f17fd24de454927ec"),
targetSha: common.Hash{0x5c, 0x94, 0x4e, 0xe5, 0x1c, 0x5a, 0xe9, 0xf7, 0x2a, 0x95, 0xec, 0xcb, 0x8a, 0xed, 0x3, 0x74, 0xee, 0xcb, 0x51, 0x19, 0xd7, 0x20, 0xcb, 0xea, 0x68, 0x13, 0xe8, 0xe0, 0xd6, 0xad, 0x92, 0x61}, targetSha: common.Hash{0x5c, 0x94, 0x4e, 0xe5, 0x1c, 0x5a, 0xe9, 0xf7, 0x2a, 0x95, 0xec, 0xcb, 0x8a, 0xed, 0x3, 0x74, 0xee, 0xcb, 0x51, 0x19, 0xd7, 0x20, 0xcb, 0xea, 0x68, 0x13, 0xe8, 0xe0, 0xd6, 0xad, 0x92, 0x61},
dists: [257][]NodeID{ dists: [257][]NodeID{
240: []NodeID{ 240: {
MustHexID("2001ad5e3e80c71b952161bc0186731cf5ffe942d24a79230a0555802296238e57ea7a32f5b6f18564eadc1c65389448481f8c9338df0a3dbd18f708cbc2cbcb"), MustHexID("2001ad5e3e80c71b952161bc0186731cf5ffe942d24a79230a0555802296238e57ea7a32f5b6f18564eadc1c65389448481f8c9338df0a3dbd18f708cbc2cbcb"),
MustHexID("6ba3f4f57d084b6bf94cc4555b8c657e4a8ac7b7baf23c6874efc21dd1e4f56b7eb2721e07f5242d2f1d8381fc8cae535e860197c69236798ba1ad231b105794"), MustHexID("6ba3f4f57d084b6bf94cc4555b8c657e4a8ac7b7baf23c6874efc21dd1e4f56b7eb2721e07f5242d2f1d8381fc8cae535e860197c69236798ba1ad231b105794"),
}, },
244: []NodeID{ 244: {
MustHexID("696ba1f0a9d55c59246f776600542a9e6432490f0cd78f8bb55a196918df2081a9b521c3c3ba48e465a75c10768807717f8f689b0b4adce00e1c75737552a178"), MustHexID("696ba1f0a9d55c59246f776600542a9e6432490f0cd78f8bb55a196918df2081a9b521c3c3ba48e465a75c10768807717f8f689b0b4adce00e1c75737552a178"),
}, },
246: []NodeID{ 246: {
MustHexID("d6d32178bdc38416f46ffb8b3ec9e4cb2cfff8d04dd7e4311a70e403cb62b10be1b447311b60b4f9ee221a8131fc2cbd45b96dd80deba68a949d467241facfa8"), MustHexID("d6d32178bdc38416f46ffb8b3ec9e4cb2cfff8d04dd7e4311a70e403cb62b10be1b447311b60b4f9ee221a8131fc2cbd45b96dd80deba68a949d467241facfa8"),
MustHexID("3ea3d04a43a3dfb5ac11cffc2319248cf41b6279659393c2f55b8a0a5fc9d12581a9d97ef5d8ff9b5abf3321a290e8f63a4f785f450dc8a672aba3ba2ff4fdab"), MustHexID("3ea3d04a43a3dfb5ac11cffc2319248cf41b6279659393c2f55b8a0a5fc9d12581a9d97ef5d8ff9b5abf3321a290e8f63a4f785f450dc8a672aba3ba2ff4fdab"),
MustHexID("2fc897f05ae585553e5c014effd3078f84f37f9333afacffb109f00ca8e7a3373de810a3946be971cbccdfd40249f9fe7f322118ea459ac71acca85a1ef8b7f4"), MustHexID("2fc897f05ae585553e5c014effd3078f84f37f9333afacffb109f00ca8e7a3373de810a3946be971cbccdfd40249f9fe7f322118ea459ac71acca85a1ef8b7f4"),
}, },
247: []NodeID{ 247: {
MustHexID("3155e1427f85f10a5c9a7755877748041af1bcd8d474ec065eb33df57a97babf54bfd2103575fa829115d224c523596b401065a97f74010610fce76382c0bf32"), MustHexID("3155e1427f85f10a5c9a7755877748041af1bcd8d474ec065eb33df57a97babf54bfd2103575fa829115d224c523596b401065a97f74010610fce76382c0bf32"),
MustHexID("312c55512422cf9b8a4097e9a6ad79402e87a15ae909a4bfefa22398f03d20951933beea1e4dfa6f968212385e829f04c2d314fc2d4e255e0d3bc08792b069db"), MustHexID("312c55512422cf9b8a4097e9a6ad79402e87a15ae909a4bfefa22398f03d20951933beea1e4dfa6f968212385e829f04c2d314fc2d4e255e0d3bc08792b069db"),
MustHexID("38643200b172dcfef857492156971f0e6aa2c538d8b74010f8e140811d53b98c765dd2d96126051913f44582e8c199ad7c6d6819e9a56483f637feaac9448aac"), MustHexID("38643200b172dcfef857492156971f0e6aa2c538d8b74010f8e140811d53b98c765dd2d96126051913f44582e8c199ad7c6d6819e9a56483f637feaac9448aac"),
@ -338,7 +338,7 @@ var lookupTestnet = &preminedTestnet{
MustHexID("4ab0a75941b12892369b4490a1928c8ca52a9ad6d3dffbd1d8c0b907bc200fe74c022d011ec39b64808a39c0ca41f1d3254386c3e7733e7044c44259486461b6"), MustHexID("4ab0a75941b12892369b4490a1928c8ca52a9ad6d3dffbd1d8c0b907bc200fe74c022d011ec39b64808a39c0ca41f1d3254386c3e7733e7044c44259486461b6"),
MustHexID("d45150a72dc74388773e68e03133a3b5f51447fe91837d566706b3c035ee4b56f160c878c6273394daee7f56cc398985269052f22f75a8057df2fe6172765354"), MustHexID("d45150a72dc74388773e68e03133a3b5f51447fe91837d566706b3c035ee4b56f160c878c6273394daee7f56cc398985269052f22f75a8057df2fe6172765354"),
}, },
248: []NodeID{ 248: {
MustHexID("6aadfce366a189bab08ac84721567483202c86590642ea6d6a14f37ca78d82bdb6509eb7b8b2f6f63c78ae3ae1d8837c89509e41497d719b23ad53dd81574afa"), MustHexID("6aadfce366a189bab08ac84721567483202c86590642ea6d6a14f37ca78d82bdb6509eb7b8b2f6f63c78ae3ae1d8837c89509e41497d719b23ad53dd81574afa"),
MustHexID("a605ecfd6069a4cf4cf7f5840e5bc0ce10d23a3ac59e2aaa70c6afd5637359d2519b4524f56fc2ca180cdbebe54262f720ccaae8c1b28fd553c485675831624d"), MustHexID("a605ecfd6069a4cf4cf7f5840e5bc0ce10d23a3ac59e2aaa70c6afd5637359d2519b4524f56fc2ca180cdbebe54262f720ccaae8c1b28fd553c485675831624d"),
MustHexID("29701451cb9448ca33fc33680b44b840d815be90146eb521641efbffed0859c154e8892d3906eae9934bfacee72cd1d2fa9dd050fd18888eea49da155ab0efd2"), MustHexID("29701451cb9448ca33fc33680b44b840d815be90146eb521641efbffed0859c154e8892d3906eae9934bfacee72cd1d2fa9dd050fd18888eea49da155ab0efd2"),
@ -356,7 +356,7 @@ var lookupTestnet = &preminedTestnet{
MustHexID("b76ea1a6fd6506ef6e3506a4f1f60ed6287fff8114af6141b2ff13e61242331b54082b023cfea5b3083354a4fb3f9eb8be01fb4a518f579e731a5d0707291a6b"), MustHexID("b76ea1a6fd6506ef6e3506a4f1f60ed6287fff8114af6141b2ff13e61242331b54082b023cfea5b3083354a4fb3f9eb8be01fb4a518f579e731a5d0707291a6b"),
MustHexID("9b53a37950ca8890ee349b325032d7b672cab7eced178d3060137b24ef6b92a43977922d5bdfb4a3409a2d80128e02f795f9dae6d7d99973ad0e23a2afb8442f"), MustHexID("9b53a37950ca8890ee349b325032d7b672cab7eced178d3060137b24ef6b92a43977922d5bdfb4a3409a2d80128e02f795f9dae6d7d99973ad0e23a2afb8442f"),
}, },
249: []NodeID{ 249: {
MustHexID("675ae65567c3c72c50c73bc0fd4f61f202ea5f93346ca57b551de3411ccc614fad61cb9035493af47615311b9d44ee7a161972ee4d77c28fe1ec029d01434e6a"), MustHexID("675ae65567c3c72c50c73bc0fd4f61f202ea5f93346ca57b551de3411ccc614fad61cb9035493af47615311b9d44ee7a161972ee4d77c28fe1ec029d01434e6a"),
MustHexID("8eb81408389da88536ae5800392b16ef5109d7ea132c18e9a82928047ecdb502693f6e4a4cdd18b54296caf561db937185731456c456c98bfe7de0baf0eaa495"), MustHexID("8eb81408389da88536ae5800392b16ef5109d7ea132c18e9a82928047ecdb502693f6e4a4cdd18b54296caf561db937185731456c456c98bfe7de0baf0eaa495"),
MustHexID("2adba8b1612a541771cb93a726a38a4b88e97b18eced2593eb7daf82f05a5321ca94a72cc780c306ff21e551a932fc2c6d791e4681907b5ceab7f084c3fa2944"), MustHexID("2adba8b1612a541771cb93a726a38a4b88e97b18eced2593eb7daf82f05a5321ca94a72cc780c306ff21e551a932fc2c6d791e4681907b5ceab7f084c3fa2944"),
@ -374,7 +374,7 @@ var lookupTestnet = &preminedTestnet{
MustHexID("d94193f236105010972f5df1b7818b55846592a0445b9cdc4eaed811b8c4c0f7c27dc8cc9837a4774656d6b34682d6d329d42b6ebb55da1d475c2474dc3dfdf4"), MustHexID("d94193f236105010972f5df1b7818b55846592a0445b9cdc4eaed811b8c4c0f7c27dc8cc9837a4774656d6b34682d6d329d42b6ebb55da1d475c2474dc3dfdf4"),
MustHexID("edd9af6aded4094e9785637c28fccbd3980cbe28e2eb9a411048a23c2ace4bd6b0b7088a7817997b49a3dd05fc6929ca6c7abbb69438dbdabe65e971d2a794b2"), MustHexID("edd9af6aded4094e9785637c28fccbd3980cbe28e2eb9a411048a23c2ace4bd6b0b7088a7817997b49a3dd05fc6929ca6c7abbb69438dbdabe65e971d2a794b2"),
}, },
250: []NodeID{ 250: {
MustHexID("53a5bd1215d4ab709ae8fdc2ced50bba320bced78bd9c5dc92947fb402250c914891786db0978c898c058493f86fc68b1c5de8a5cb36336150ac7a88655b6c39"), MustHexID("53a5bd1215d4ab709ae8fdc2ced50bba320bced78bd9c5dc92947fb402250c914891786db0978c898c058493f86fc68b1c5de8a5cb36336150ac7a88655b6c39"),
MustHexID("b7f79e3ab59f79262623c9ccefc8f01d682323aee56ffbe295437487e9d5acaf556a9c92e1f1c6a9601f2b9eb6b027ae1aeaebac71d61b9b78e88676efd3e1a3"), MustHexID("b7f79e3ab59f79262623c9ccefc8f01d682323aee56ffbe295437487e9d5acaf556a9c92e1f1c6a9601f2b9eb6b027ae1aeaebac71d61b9b78e88676efd3e1a3"),
MustHexID("d374bf7e8d7ffff69cc00bebff38ef5bc1dcb0a8d51c1a3d70e61ac6b2e2d6617109254b0ac224354dfbf79009fe4239e09020c483cc60c071e00b9238684f30"), MustHexID("d374bf7e8d7ffff69cc00bebff38ef5bc1dcb0a8d51c1a3d70e61ac6b2e2d6617109254b0ac224354dfbf79009fe4239e09020c483cc60c071e00b9238684f30"),
@ -392,7 +392,7 @@ var lookupTestnet = &preminedTestnet{
MustHexID("5b116f0751526868a909b61a30b0c5282c37df6925cc03ddea556ef0d0602a9595fd6c14d371f8ed7d45d89918a032dcd22be4342a8793d88fdbeb3ca3d75bd7"), MustHexID("5b116f0751526868a909b61a30b0c5282c37df6925cc03ddea556ef0d0602a9595fd6c14d371f8ed7d45d89918a032dcd22be4342a8793d88fdbeb3ca3d75bd7"),
MustHexID("50f3222fb6b82481c7c813b2172e1daea43e2710a443b9c2a57a12bd160dd37e20f87aa968c82ad639af6972185609d47036c0d93b4b7269b74ebd7073221c10"), MustHexID("50f3222fb6b82481c7c813b2172e1daea43e2710a443b9c2a57a12bd160dd37e20f87aa968c82ad639af6972185609d47036c0d93b4b7269b74ebd7073221c10"),
}, },
251: []NodeID{ 251: {
MustHexID("9b8f702a62d1bee67bedfeb102eca7f37fa1713e310f0d6651cc0c33ea7c5477575289ccd463e5a2574a00a676a1fdce05658ba447bb9d2827f0ba47b947e894"), MustHexID("9b8f702a62d1bee67bedfeb102eca7f37fa1713e310f0d6651cc0c33ea7c5477575289ccd463e5a2574a00a676a1fdce05658ba447bb9d2827f0ba47b947e894"),
MustHexID("b97532eb83054ed054b4abdf413bb30c00e4205545c93521554dbe77faa3cfaa5bd31ef466a107b0b34a71ec97214c0c83919720142cddac93aa7a3e928d4708"), MustHexID("b97532eb83054ed054b4abdf413bb30c00e4205545c93521554dbe77faa3cfaa5bd31ef466a107b0b34a71ec97214c0c83919720142cddac93aa7a3e928d4708"),
MustHexID("2f7a5e952bfb67f2f90b8441b5fadc9ee13b1dcde3afeeb3dd64bf937f86663cc5c55d1fa83952b5422763c7df1b7f2794b751c6be316ebc0beb4942e65ab8c1"), MustHexID("2f7a5e952bfb67f2f90b8441b5fadc9ee13b1dcde3afeeb3dd64bf937f86663cc5c55d1fa83952b5422763c7df1b7f2794b751c6be316ebc0beb4942e65ab8c1"),
@ -410,7 +410,7 @@ var lookupTestnet = &preminedTestnet{
MustHexID("fcc9a2e1ac3667026ff16192876d1813bb75abdbf39b929a92863012fe8b1d890badea7a0de36274d5c1eb1e8f975785532c50d80fd44b1a4b692f437303393f"), MustHexID("fcc9a2e1ac3667026ff16192876d1813bb75abdbf39b929a92863012fe8b1d890badea7a0de36274d5c1eb1e8f975785532c50d80fd44b1a4b692f437303393f"),
MustHexID("6d8b3efb461151dd4f6de809b62726f5b89e9b38e9ba1391967f61cde844f7528fecf821b74049207cee5a527096b31f3ad623928cd3ce51d926fa345a6b2951"), MustHexID("6d8b3efb461151dd4f6de809b62726f5b89e9b38e9ba1391967f61cde844f7528fecf821b74049207cee5a527096b31f3ad623928cd3ce51d926fa345a6b2951"),
}, },
252: []NodeID{ 252: {
MustHexID("f1ae93157cc48c2075dd5868fbf523e79e06caf4b8198f352f6e526680b78ff4227263de92612f7d63472bd09367bb92a636fff16fe46ccf41614f7a72495c2a"), MustHexID("f1ae93157cc48c2075dd5868fbf523e79e06caf4b8198f352f6e526680b78ff4227263de92612f7d63472bd09367bb92a636fff16fe46ccf41614f7a72495c2a"),
MustHexID("587f482d111b239c27c0cb89b51dd5d574db8efd8de14a2e6a1400c54d4567e77c65f89c1da52841212080b91604104768350276b6682f2f961cdaf4039581c7"), MustHexID("587f482d111b239c27c0cb89b51dd5d574db8efd8de14a2e6a1400c54d4567e77c65f89c1da52841212080b91604104768350276b6682f2f961cdaf4039581c7"),
MustHexID("e3f88274d35cefdaabdf205afe0e80e936cc982b8e3e47a84ce664c413b29016a4fb4f3a3ebae0a2f79671f8323661ed462bf4390af94c424dc8ace0c301b90f"), MustHexID("e3f88274d35cefdaabdf205afe0e80e936cc982b8e3e47a84ce664c413b29016a4fb4f3a3ebae0a2f79671f8323661ed462bf4390af94c424dc8ace0c301b90f"),
@ -428,7 +428,7 @@ var lookupTestnet = &preminedTestnet{
MustHexID("d84f06fe64debc4cd0625e36d19b99014b6218375262cc2209202bdbafd7dffcc4e34ce6398e182e02fd8faeed622c3e175545864902dfd3d1ac57647cddf4c6"), MustHexID("d84f06fe64debc4cd0625e36d19b99014b6218375262cc2209202bdbafd7dffcc4e34ce6398e182e02fd8faeed622c3e175545864902dfd3d1ac57647cddf4c6"),
MustHexID("d0ed87b294f38f1d741eb601020eeec30ac16331d05880fe27868f1e454446de367d7457b41c79e202eaf9525b029e4f1d7e17d85a55f83a557c005c68d7328a"), MustHexID("d0ed87b294f38f1d741eb601020eeec30ac16331d05880fe27868f1e454446de367d7457b41c79e202eaf9525b029e4f1d7e17d85a55f83a557c005c68d7328a"),
}, },
253: []NodeID{ 253: {
MustHexID("ad4485e386e3cc7c7310366a7c38fb810b8896c0d52e55944bfd320ca294e7912d6c53c0a0cf85e7ce226e92491d60430e86f8f15cda0161ed71893fb4a9e3a1"), MustHexID("ad4485e386e3cc7c7310366a7c38fb810b8896c0d52e55944bfd320ca294e7912d6c53c0a0cf85e7ce226e92491d60430e86f8f15cda0161ed71893fb4a9e3a1"),
MustHexID("36d0e7e5b7734f98c6183eeeb8ac5130a85e910a925311a19c4941b1290f945d4fc3996b12ef4966960b6fa0fb29b1604f83a0f81bd5fd6398d2e1a22e46af0c"), MustHexID("36d0e7e5b7734f98c6183eeeb8ac5130a85e910a925311a19c4941b1290f945d4fc3996b12ef4966960b6fa0fb29b1604f83a0f81bd5fd6398d2e1a22e46af0c"),
MustHexID("7d307d8acb4a561afa23bdf0bd945d35c90245e26345ec3a1f9f7df354222a7cdcb81339c9ed6744526c27a1a0c8d10857e98df942fa433602facac71ac68a31"), MustHexID("7d307d8acb4a561afa23bdf0bd945d35c90245e26345ec3a1f9f7df354222a7cdcb81339c9ed6744526c27a1a0c8d10857e98df942fa433602facac71ac68a31"),
@ -446,7 +446,7 @@ var lookupTestnet = &preminedTestnet{
MustHexID("7a369b2b8962cc4c65900be046482fbf7c14f98a135bbbae25152c82ad168fb2097b3d1429197cf46d3ce9fdeb64808f908a489cc6019725db040060fdfe5405"), MustHexID("7a369b2b8962cc4c65900be046482fbf7c14f98a135bbbae25152c82ad168fb2097b3d1429197cf46d3ce9fdeb64808f908a489cc6019725db040060fdfe5405"),
MustHexID("47bcae48288da5ecc7f5058dfa07cf14d89d06d6e449cb946e237aa6652ea050d9f5a24a65efdc0013ccf232bf88670979eddef249b054f63f38da9d7796dbd8"), MustHexID("47bcae48288da5ecc7f5058dfa07cf14d89d06d6e449cb946e237aa6652ea050d9f5a24a65efdc0013ccf232bf88670979eddef249b054f63f38da9d7796dbd8"),
}, },
254: []NodeID{ 254: {
MustHexID("099739d7abc8abd38ecc7a816c521a1168a4dbd359fa7212a5123ab583ffa1cf485a5fed219575d6475dbcdd541638b2d3631a6c7fce7474e7fe3cba1d4d5853"), MustHexID("099739d7abc8abd38ecc7a816c521a1168a4dbd359fa7212a5123ab583ffa1cf485a5fed219575d6475dbcdd541638b2d3631a6c7fce7474e7fe3cba1d4d5853"),
MustHexID("c2b01603b088a7182d0cf7ef29fb2b04c70acb320fccf78526bf9472e10c74ee70b3fcfa6f4b11d167bd7d3bc4d936b660f2c9bff934793d97cb21750e7c3d31"), MustHexID("c2b01603b088a7182d0cf7ef29fb2b04c70acb320fccf78526bf9472e10c74ee70b3fcfa6f4b11d167bd7d3bc4d936b660f2c9bff934793d97cb21750e7c3d31"),
MustHexID("20e4d8f45f2f863e94b45548c1ef22a11f7d36f263e4f8623761e05a64c4572379b000a52211751e2561b0f14f4fc92dd4130410c8ccc71eb4f0e95a700d4ca9"), MustHexID("20e4d8f45f2f863e94b45548c1ef22a11f7d36f263e4f8623761e05a64c4572379b000a52211751e2561b0f14f4fc92dd4130410c8ccc71eb4f0e95a700d4ca9"),
@ -464,7 +464,7 @@ var lookupTestnet = &preminedTestnet{
MustHexID("82504b6eb49bb2c0f91a7006ce9cefdbaf6df38706198502c2e06601091fc9dc91e4f15db3410d45c6af355bc270b0f268d3dff560f956985c7332d4b10bd1ed"), MustHexID("82504b6eb49bb2c0f91a7006ce9cefdbaf6df38706198502c2e06601091fc9dc91e4f15db3410d45c6af355bc270b0f268d3dff560f956985c7332d4b10bd1ed"),
MustHexID("b39b5b677b45944ceebe76e76d1f051de2f2a0ec7b0d650da52135743e66a9a5dba45f638258f9a7545d9a790c7fe6d3fdf82c25425c7887323e45d27d06c057"), MustHexID("b39b5b677b45944ceebe76e76d1f051de2f2a0ec7b0d650da52135743e66a9a5dba45f638258f9a7545d9a790c7fe6d3fdf82c25425c7887323e45d27d06c057"),
}, },
255: []NodeID{ 255: {
MustHexID("5c4d58d46e055dd1f093f81ee60a675e1f02f54da6206720adee4dccef9b67a31efc5c2a2949c31a04ee31beadc79aba10da31440a1f9ff2a24093c63c36d784"), MustHexID("5c4d58d46e055dd1f093f81ee60a675e1f02f54da6206720adee4dccef9b67a31efc5c2a2949c31a04ee31beadc79aba10da31440a1f9ff2a24093c63c36d784"),
MustHexID("ea72161ffdd4b1e124c7b93b0684805f4c4b58d617ed498b37a145c670dbc2e04976f8785583d9c805ffbf343c31d492d79f841652bbbd01b61ed85640b23495"), MustHexID("ea72161ffdd4b1e124c7b93b0684805f4c4b58d617ed498b37a145c670dbc2e04976f8785583d9c805ffbf343c31d492d79f841652bbbd01b61ed85640b23495"),
MustHexID("51caa1d93352d47a8e531692a3612adac1e8ac68d0a200d086c1c57ae1e1a91aa285ab242e8c52ef9d7afe374c9485b122ae815f1707b875569d0433c1c3ce85"), MustHexID("51caa1d93352d47a8e531692a3612adac1e8ac68d0a200d086c1c57ae1e1a91aa285ab242e8c52ef9d7afe374c9485b122ae815f1707b875569d0433c1c3ce85"),
@ -482,7 +482,7 @@ var lookupTestnet = &preminedTestnet{
MustHexID("f492c6ee2696d5f682f7f537757e52744c2ae560f1090a07024609e903d334e9e174fc01609c5a229ddbcac36c9d21adaf6457dab38a25bfd44f2f0ee4277998"), MustHexID("f492c6ee2696d5f682f7f537757e52744c2ae560f1090a07024609e903d334e9e174fc01609c5a229ddbcac36c9d21adaf6457dab38a25bfd44f2f0ee4277998"),
MustHexID("459e4db99298cb0467a90acee6888b08bb857450deac11015cced5104853be5adce5b69c740968bc7f931495d671a70cad9f48546d7cd203357fe9af0e8d2164"), MustHexID("459e4db99298cb0467a90acee6888b08bb857450deac11015cced5104853be5adce5b69c740968bc7f931495d671a70cad9f48546d7cd203357fe9af0e8d2164"),
}, },
256: []NodeID{ 256: {
MustHexID("a8593af8a4aef7b806b5197612017951bac8845a1917ca9a6a15dd6086d608505144990b245785c4cd2d67a295701c7aac2aa18823fb0033987284b019656268"), MustHexID("a8593af8a4aef7b806b5197612017951bac8845a1917ca9a6a15dd6086d608505144990b245785c4cd2d67a295701c7aac2aa18823fb0033987284b019656268"),
MustHexID("d2eebef914928c3aad77fc1b2a495f52d2294acf5edaa7d8a530b540f094b861a68fe8348a46a7c302f08ab609d85912a4968eacfea0740847b29421b4795d9e"), MustHexID("d2eebef914928c3aad77fc1b2a495f52d2294acf5edaa7d8a530b540f094b861a68fe8348a46a7c302f08ab609d85912a4968eacfea0740847b29421b4795d9e"),
MustHexID("b14bfcb31495f32b650b63cf7d08492e3e29071fdc73cf2da0da48d4b191a70ba1a65f42ad8c343206101f00f8a48e8db4b08bf3f622c0853e7323b250835b91"), MustHexID("b14bfcb31495f32b650b63cf7d08492e3e29071fdc73cf2da0da48d4b191a70ba1a65f42ad8c343206101f00f8a48e8db4b08bf3f622c0853e7323b250835b91"),

4
p2p/discv5/database_test.go
Unescape View File

@ -242,12 +242,12 @@ func TestNodeDBSeedQuery(t *testing.T) {
if len(seeds) != len(want) { if len(seeds) != len(want) {
t.Errorf("seed count mismatch: have %v, want %v", len(seeds), len(want)) t.Errorf("seed count mismatch: have %v, want %v", len(seeds), len(want))
} }
for id, _ := range have { for id := range have {
if _, ok := want[id]; !ok { if _, ok := want[id]; !ok {
t.Errorf("extra seed: %v", id) t.Errorf("extra seed: %v", id)
} }
} }
for id, _ := range want { for id := range want {
if _, ok := have[id]; !ok { if _, ok := have[id]; !ok {
t.Errorf("missing seed: %v", id) t.Errorf("missing seed: %v", id)
} }

26
p2p/discv5/net_test.go
Unescape View File

@ -69,19 +69,19 @@ var lookupTestnet = &preminedTestnet{
target: MustHexID("166aea4f556532c6d34e8b740e5d314af7e9ac0ca79833bd751d6b665f12dfd38ec563c363b32f02aef4a80b44fd3def94612d497b99cb5f17fd24de454927ec"), target: MustHexID("166aea4f556532c6d34e8b740e5d314af7e9ac0ca79833bd751d6b665f12dfd38ec563c363b32f02aef4a80b44fd3def94612d497b99cb5f17fd24de454927ec"),
targetSha: common.Hash{0x5c, 0x94, 0x4e, 0xe5, 0x1c, 0x5a, 0xe9, 0xf7, 0x2a, 0x95, 0xec, 0xcb, 0x8a, 0xed, 0x3, 0x74, 0xee, 0xcb, 0x51, 0x19, 0xd7, 0x20, 0xcb, 0xea, 0x68, 0x13, 0xe8, 0xe0, 0xd6, 0xad, 0x92, 0x61}, targetSha: common.Hash{0x5c, 0x94, 0x4e, 0xe5, 0x1c, 0x5a, 0xe9, 0xf7, 0x2a, 0x95, 0xec, 0xcb, 0x8a, 0xed, 0x3, 0x74, 0xee, 0xcb, 0x51, 0x19, 0xd7, 0x20, 0xcb, 0xea, 0x68, 0x13, 0xe8, 0xe0, 0xd6, 0xad, 0x92, 0x61},
dists: [257][]NodeID{ dists: [257][]NodeID{
240: []NodeID{ 240: {
MustHexID("2001ad5e3e80c71b952161bc0186731cf5ffe942d24a79230a0555802296238e57ea7a32f5b6f18564eadc1c65389448481f8c9338df0a3dbd18f708cbc2cbcb"), MustHexID("2001ad5e3e80c71b952161bc0186731cf5ffe942d24a79230a0555802296238e57ea7a32f5b6f18564eadc1c65389448481f8c9338df0a3dbd18f708cbc2cbcb"),
MustHexID("6ba3f4f57d084b6bf94cc4555b8c657e4a8ac7b7baf23c6874efc21dd1e4f56b7eb2721e07f5242d2f1d8381fc8cae535e860197c69236798ba1ad231b105794"), MustHexID("6ba3f4f57d084b6bf94cc4555b8c657e4a8ac7b7baf23c6874efc21dd1e4f56b7eb2721e07f5242d2f1d8381fc8cae535e860197c69236798ba1ad231b105794"),
}, },
244: []NodeID{ 244: {
MustHexID("696ba1f0a9d55c59246f776600542a9e6432490f0cd78f8bb55a196918df2081a9b521c3c3ba48e465a75c10768807717f8f689b0b4adce00e1c75737552a178"), MustHexID("696ba1f0a9d55c59246f776600542a9e6432490f0cd78f8bb55a196918df2081a9b521c3c3ba48e465a75c10768807717f8f689b0b4adce00e1c75737552a178"),
}, },
246: []NodeID{ 246: {
MustHexID("d6d32178bdc38416f46ffb8b3ec9e4cb2cfff8d04dd7e4311a70e403cb62b10be1b447311b60b4f9ee221a8131fc2cbd45b96dd80deba68a949d467241facfa8"), MustHexID("d6d32178bdc38416f46ffb8b3ec9e4cb2cfff8d04dd7e4311a70e403cb62b10be1b447311b60b4f9ee221a8131fc2cbd45b96dd80deba68a949d467241facfa8"),
MustHexID("3ea3d04a43a3dfb5ac11cffc2319248cf41b6279659393c2f55b8a0a5fc9d12581a9d97ef5d8ff9b5abf3321a290e8f63a4f785f450dc8a672aba3ba2ff4fdab"), MustHexID("3ea3d04a43a3dfb5ac11cffc2319248cf41b6279659393c2f55b8a0a5fc9d12581a9d97ef5d8ff9b5abf3321a290e8f63a4f785f450dc8a672aba3ba2ff4fdab"),
MustHexID("2fc897f05ae585553e5c014effd3078f84f37f9333afacffb109f00ca8e7a3373de810a3946be971cbccdfd40249f9fe7f322118ea459ac71acca85a1ef8b7f4"), MustHexID("2fc897f05ae585553e5c014effd3078f84f37f9333afacffb109f00ca8e7a3373de810a3946be971cbccdfd40249f9fe7f322118ea459ac71acca85a1ef8b7f4"),
}, },
247: []NodeID{ 247: {
MustHexID("3155e1427f85f10a5c9a7755877748041af1bcd8d474ec065eb33df57a97babf54bfd2103575fa829115d224c523596b401065a97f74010610fce76382c0bf32"), MustHexID("3155e1427f85f10a5c9a7755877748041af1bcd8d474ec065eb33df57a97babf54bfd2103575fa829115d224c523596b401065a97f74010610fce76382c0bf32"),
MustHexID("312c55512422cf9b8a4097e9a6ad79402e87a15ae909a4bfefa22398f03d20951933beea1e4dfa6f968212385e829f04c2d314fc2d4e255e0d3bc08792b069db"), MustHexID("312c55512422cf9b8a4097e9a6ad79402e87a15ae909a4bfefa22398f03d20951933beea1e4dfa6f968212385e829f04c2d314fc2d4e255e0d3bc08792b069db"),
MustHexID("38643200b172dcfef857492156971f0e6aa2c538d8b74010f8e140811d53b98c765dd2d96126051913f44582e8c199ad7c6d6819e9a56483f637feaac9448aac"), MustHexID("38643200b172dcfef857492156971f0e6aa2c538d8b74010f8e140811d53b98c765dd2d96126051913f44582e8c199ad7c6d6819e9a56483f637feaac9448aac"),
@ -93,7 +93,7 @@ var lookupTestnet = &preminedTestnet{
MustHexID("4ab0a75941b12892369b4490a1928c8ca52a9ad6d3dffbd1d8c0b907bc200fe74c022d011ec39b64808a39c0ca41f1d3254386c3e7733e7044c44259486461b6"), MustHexID("4ab0a75941b12892369b4490a1928c8ca52a9ad6d3dffbd1d8c0b907bc200fe74c022d011ec39b64808a39c0ca41f1d3254386c3e7733e7044c44259486461b6"),
MustHexID("d45150a72dc74388773e68e03133a3b5f51447fe91837d566706b3c035ee4b56f160c878c6273394daee7f56cc398985269052f22f75a8057df2fe6172765354"), MustHexID("d45150a72dc74388773e68e03133a3b5f51447fe91837d566706b3c035ee4b56f160c878c6273394daee7f56cc398985269052f22f75a8057df2fe6172765354"),
}, },
248: []NodeID{ 248: {
MustHexID("6aadfce366a189bab08ac84721567483202c86590642ea6d6a14f37ca78d82bdb6509eb7b8b2f6f63c78ae3ae1d8837c89509e41497d719b23ad53dd81574afa"), MustHexID("6aadfce366a189bab08ac84721567483202c86590642ea6d6a14f37ca78d82bdb6509eb7b8b2f6f63c78ae3ae1d8837c89509e41497d719b23ad53dd81574afa"),
MustHexID("a605ecfd6069a4cf4cf7f5840e5bc0ce10d23a3ac59e2aaa70c6afd5637359d2519b4524f56fc2ca180cdbebe54262f720ccaae8c1b28fd553c485675831624d"), MustHexID("a605ecfd6069a4cf4cf7f5840e5bc0ce10d23a3ac59e2aaa70c6afd5637359d2519b4524f56fc2ca180cdbebe54262f720ccaae8c1b28fd553c485675831624d"),
MustHexID("29701451cb9448ca33fc33680b44b840d815be90146eb521641efbffed0859c154e8892d3906eae9934bfacee72cd1d2fa9dd050fd18888eea49da155ab0efd2"), MustHexID("29701451cb9448ca33fc33680b44b840d815be90146eb521641efbffed0859c154e8892d3906eae9934bfacee72cd1d2fa9dd050fd18888eea49da155ab0efd2"),
@ -111,7 +111,7 @@ var lookupTestnet = &preminedTestnet{
MustHexID("b76ea1a6fd6506ef6e3506a4f1f60ed6287fff8114af6141b2ff13e61242331b54082b023cfea5b3083354a4fb3f9eb8be01fb4a518f579e731a5d0707291a6b"), MustHexID("b76ea1a6fd6506ef6e3506a4f1f60ed6287fff8114af6141b2ff13e61242331b54082b023cfea5b3083354a4fb3f9eb8be01fb4a518f579e731a5d0707291a6b"),
MustHexID("9b53a37950ca8890ee349b325032d7b672cab7eced178d3060137b24ef6b92a43977922d5bdfb4a3409a2d80128e02f795f9dae6d7d99973ad0e23a2afb8442f"), MustHexID("9b53a37950ca8890ee349b325032d7b672cab7eced178d3060137b24ef6b92a43977922d5bdfb4a3409a2d80128e02f795f9dae6d7d99973ad0e23a2afb8442f"),
}, },
249: []NodeID{ 249: {
MustHexID("675ae65567c3c72c50c73bc0fd4f61f202ea5f93346ca57b551de3411ccc614fad61cb9035493af47615311b9d44ee7a161972ee4d77c28fe1ec029d01434e6a"), MustHexID("675ae65567c3c72c50c73bc0fd4f61f202ea5f93346ca57b551de3411ccc614fad61cb9035493af47615311b9d44ee7a161972ee4d77c28fe1ec029d01434e6a"),
MustHexID("8eb81408389da88536ae5800392b16ef5109d7ea132c18e9a82928047ecdb502693f6e4a4cdd18b54296caf561db937185731456c456c98bfe7de0baf0eaa495"), MustHexID("8eb81408389da88536ae5800392b16ef5109d7ea132c18e9a82928047ecdb502693f6e4a4cdd18b54296caf561db937185731456c456c98bfe7de0baf0eaa495"),
MustHexID("2adba8b1612a541771cb93a726a38a4b88e97b18eced2593eb7daf82f05a5321ca94a72cc780c306ff21e551a932fc2c6d791e4681907b5ceab7f084c3fa2944"), MustHexID("2adba8b1612a541771cb93a726a38a4b88e97b18eced2593eb7daf82f05a5321ca94a72cc780c306ff21e551a932fc2c6d791e4681907b5ceab7f084c3fa2944"),
@ -129,7 +129,7 @@ var lookupTestnet = &preminedTestnet{
MustHexID("d94193f236105010972f5df1b7818b55846592a0445b9cdc4eaed811b8c4c0f7c27dc8cc9837a4774656d6b34682d6d329d42b6ebb55da1d475c2474dc3dfdf4"), MustHexID("d94193f236105010972f5df1b7818b55846592a0445b9cdc4eaed811b8c4c0f7c27dc8cc9837a4774656d6b34682d6d329d42b6ebb55da1d475c2474dc3dfdf4"),
MustHexID("edd9af6aded4094e9785637c28fccbd3980cbe28e2eb9a411048a23c2ace4bd6b0b7088a7817997b49a3dd05fc6929ca6c7abbb69438dbdabe65e971d2a794b2"), MustHexID("edd9af6aded4094e9785637c28fccbd3980cbe28e2eb9a411048a23c2ace4bd6b0b7088a7817997b49a3dd05fc6929ca6c7abbb69438dbdabe65e971d2a794b2"),
}, },
250: []NodeID{ 250: {
MustHexID("53a5bd1215d4ab709ae8fdc2ced50bba320bced78bd9c5dc92947fb402250c914891786db0978c898c058493f86fc68b1c5de8a5cb36336150ac7a88655b6c39"), MustHexID("53a5bd1215d4ab709ae8fdc2ced50bba320bced78bd9c5dc92947fb402250c914891786db0978c898c058493f86fc68b1c5de8a5cb36336150ac7a88655b6c39"),
MustHexID("b7f79e3ab59f79262623c9ccefc8f01d682323aee56ffbe295437487e9d5acaf556a9c92e1f1c6a9601f2b9eb6b027ae1aeaebac71d61b9b78e88676efd3e1a3"), MustHexID("b7f79e3ab59f79262623c9ccefc8f01d682323aee56ffbe295437487e9d5acaf556a9c92e1f1c6a9601f2b9eb6b027ae1aeaebac71d61b9b78e88676efd3e1a3"),
MustHexID("d374bf7e8d7ffff69cc00bebff38ef5bc1dcb0a8d51c1a3d70e61ac6b2e2d6617109254b0ac224354dfbf79009fe4239e09020c483cc60c071e00b9238684f30"), MustHexID("d374bf7e8d7ffff69cc00bebff38ef5bc1dcb0a8d51c1a3d70e61ac6b2e2d6617109254b0ac224354dfbf79009fe4239e09020c483cc60c071e00b9238684f30"),
@ -147,7 +147,7 @@ var lookupTestnet = &preminedTestnet{
MustHexID("5b116f0751526868a909b61a30b0c5282c37df6925cc03ddea556ef0d0602a9595fd6c14d371f8ed7d45d89918a032dcd22be4342a8793d88fdbeb3ca3d75bd7"), MustHexID("5b116f0751526868a909b61a30b0c5282c37df6925cc03ddea556ef0d0602a9595fd6c14d371f8ed7d45d89918a032dcd22be4342a8793d88fdbeb3ca3d75bd7"),
MustHexID("50f3222fb6b82481c7c813b2172e1daea43e2710a443b9c2a57a12bd160dd37e20f87aa968c82ad639af6972185609d47036c0d93b4b7269b74ebd7073221c10"), MustHexID("50f3222fb6b82481c7c813b2172e1daea43e2710a443b9c2a57a12bd160dd37e20f87aa968c82ad639af6972185609d47036c0d93b4b7269b74ebd7073221c10"),
}, },
251: []NodeID{ 251: {
MustHexID("9b8f702a62d1bee67bedfeb102eca7f37fa1713e310f0d6651cc0c33ea7c5477575289ccd463e5a2574a00a676a1fdce05658ba447bb9d2827f0ba47b947e894"), MustHexID("9b8f702a62d1bee67bedfeb102eca7f37fa1713e310f0d6651cc0c33ea7c5477575289ccd463e5a2574a00a676a1fdce05658ba447bb9d2827f0ba47b947e894"),
MustHexID("b97532eb83054ed054b4abdf413bb30c00e4205545c93521554dbe77faa3cfaa5bd31ef466a107b0b34a71ec97214c0c83919720142cddac93aa7a3e928d4708"), MustHexID("b97532eb83054ed054b4abdf413bb30c00e4205545c93521554dbe77faa3cfaa5bd31ef466a107b0b34a71ec97214c0c83919720142cddac93aa7a3e928d4708"),
MustHexID("2f7a5e952bfb67f2f90b8441b5fadc9ee13b1dcde3afeeb3dd64bf937f86663cc5c55d1fa83952b5422763c7df1b7f2794b751c6be316ebc0beb4942e65ab8c1"), MustHexID("2f7a5e952bfb67f2f90b8441b5fadc9ee13b1dcde3afeeb3dd64bf937f86663cc5c55d1fa83952b5422763c7df1b7f2794b751c6be316ebc0beb4942e65ab8c1"),
@ -165,7 +165,7 @@ var lookupTestnet = &preminedTestnet{
MustHexID("fcc9a2e1ac3667026ff16192876d1813bb75abdbf39b929a92863012fe8b1d890badea7a0de36274d5c1eb1e8f975785532c50d80fd44b1a4b692f437303393f"), MustHexID("fcc9a2e1ac3667026ff16192876d1813bb75abdbf39b929a92863012fe8b1d890badea7a0de36274d5c1eb1e8f975785532c50d80fd44b1a4b692f437303393f"),
MustHexID("6d8b3efb461151dd4f6de809b62726f5b89e9b38e9ba1391967f61cde844f7528fecf821b74049207cee5a527096b31f3ad623928cd3ce51d926fa345a6b2951"), MustHexID("6d8b3efb461151dd4f6de809b62726f5b89e9b38e9ba1391967f61cde844f7528fecf821b74049207cee5a527096b31f3ad623928cd3ce51d926fa345a6b2951"),
}, },
252: []NodeID{ 252: {
MustHexID("f1ae93157cc48c2075dd5868fbf523e79e06caf4b8198f352f6e526680b78ff4227263de92612f7d63472bd09367bb92a636fff16fe46ccf41614f7a72495c2a"), MustHexID("f1ae93157cc48c2075dd5868fbf523e79e06caf4b8198f352f6e526680b78ff4227263de92612f7d63472bd09367bb92a636fff16fe46ccf41614f7a72495c2a"),
MustHexID("587f482d111b239c27c0cb89b51dd5d574db8efd8de14a2e6a1400c54d4567e77c65f89c1da52841212080b91604104768350276b6682f2f961cdaf4039581c7"), MustHexID("587f482d111b239c27c0cb89b51dd5d574db8efd8de14a2e6a1400c54d4567e77c65f89c1da52841212080b91604104768350276b6682f2f961cdaf4039581c7"),
MustHexID("e3f88274d35cefdaabdf205afe0e80e936cc982b8e3e47a84ce664c413b29016a4fb4f3a3ebae0a2f79671f8323661ed462bf4390af94c424dc8ace0c301b90f"), MustHexID("e3f88274d35cefdaabdf205afe0e80e936cc982b8e3e47a84ce664c413b29016a4fb4f3a3ebae0a2f79671f8323661ed462bf4390af94c424dc8ace0c301b90f"),
@ -183,7 +183,7 @@ var lookupTestnet = &preminedTestnet{
MustHexID("d84f06fe64debc4cd0625e36d19b99014b6218375262cc2209202bdbafd7dffcc4e34ce6398e182e02fd8faeed622c3e175545864902dfd3d1ac57647cddf4c6"), MustHexID("d84f06fe64debc4cd0625e36d19b99014b6218375262cc2209202bdbafd7dffcc4e34ce6398e182e02fd8faeed622c3e175545864902dfd3d1ac57647cddf4c6"),
MustHexID("d0ed87b294f38f1d741eb601020eeec30ac16331d05880fe27868f1e454446de367d7457b41c79e202eaf9525b029e4f1d7e17d85a55f83a557c005c68d7328a"), MustHexID("d0ed87b294f38f1d741eb601020eeec30ac16331d05880fe27868f1e454446de367d7457b41c79e202eaf9525b029e4f1d7e17d85a55f83a557c005c68d7328a"),
}, },
253: []NodeID{ 253: {
MustHexID("ad4485e386e3cc7c7310366a7c38fb810b8896c0d52e55944bfd320ca294e7912d6c53c0a0cf85e7ce226e92491d60430e86f8f15cda0161ed71893fb4a9e3a1"), MustHexID("ad4485e386e3cc7c7310366a7c38fb810b8896c0d52e55944bfd320ca294e7912d6c53c0a0cf85e7ce226e92491d60430e86f8f15cda0161ed71893fb4a9e3a1"),
MustHexID("36d0e7e5b7734f98c6183eeeb8ac5130a85e910a925311a19c4941b1290f945d4fc3996b12ef4966960b6fa0fb29b1604f83a0f81bd5fd6398d2e1a22e46af0c"), MustHexID("36d0e7e5b7734f98c6183eeeb8ac5130a85e910a925311a19c4941b1290f945d4fc3996b12ef4966960b6fa0fb29b1604f83a0f81bd5fd6398d2e1a22e46af0c"),
MustHexID("7d307d8acb4a561afa23bdf0bd945d35c90245e26345ec3a1f9f7df354222a7cdcb81339c9ed6744526c27a1a0c8d10857e98df942fa433602facac71ac68a31"), MustHexID("7d307d8acb4a561afa23bdf0bd945d35c90245e26345ec3a1f9f7df354222a7cdcb81339c9ed6744526c27a1a0c8d10857e98df942fa433602facac71ac68a31"),
@ -201,7 +201,7 @@ var lookupTestnet = &preminedTestnet{
MustHexID("7a369b2b8962cc4c65900be046482fbf7c14f98a135bbbae25152c82ad168fb2097b3d1429197cf46d3ce9fdeb64808f908a489cc6019725db040060fdfe5405"), MustHexID("7a369b2b8962cc4c65900be046482fbf7c14f98a135bbbae25152c82ad168fb2097b3d1429197cf46d3ce9fdeb64808f908a489cc6019725db040060fdfe5405"),
MustHexID("47bcae48288da5ecc7f5058dfa07cf14d89d06d6e449cb946e237aa6652ea050d9f5a24a65efdc0013ccf232bf88670979eddef249b054f63f38da9d7796dbd8"), MustHexID("47bcae48288da5ecc7f5058dfa07cf14d89d06d6e449cb946e237aa6652ea050d9f5a24a65efdc0013ccf232bf88670979eddef249b054f63f38da9d7796dbd8"),
}, },
254: []NodeID{ 254: {
MustHexID("099739d7abc8abd38ecc7a816c521a1168a4dbd359fa7212a5123ab583ffa1cf485a5fed219575d6475dbcdd541638b2d3631a6c7fce7474e7fe3cba1d4d5853"), MustHexID("099739d7abc8abd38ecc7a816c521a1168a4dbd359fa7212a5123ab583ffa1cf485a5fed219575d6475dbcdd541638b2d3631a6c7fce7474e7fe3cba1d4d5853"),
MustHexID("c2b01603b088a7182d0cf7ef29fb2b04c70acb320fccf78526bf9472e10c74ee70b3fcfa6f4b11d167bd7d3bc4d936b660f2c9bff934793d97cb21750e7c3d31"), MustHexID("c2b01603b088a7182d0cf7ef29fb2b04c70acb320fccf78526bf9472e10c74ee70b3fcfa6f4b11d167bd7d3bc4d936b660f2c9bff934793d97cb21750e7c3d31"),
MustHexID("20e4d8f45f2f863e94b45548c1ef22a11f7d36f263e4f8623761e05a64c4572379b000a52211751e2561b0f14f4fc92dd4130410c8ccc71eb4f0e95a700d4ca9"), MustHexID("20e4d8f45f2f863e94b45548c1ef22a11f7d36f263e4f8623761e05a64c4572379b000a52211751e2561b0f14f4fc92dd4130410c8ccc71eb4f0e95a700d4ca9"),
@ -219,7 +219,7 @@ var lookupTestnet = &preminedTestnet{
MustHexID("82504b6eb49bb2c0f91a7006ce9cefdbaf6df38706198502c2e06601091fc9dc91e4f15db3410d45c6af355bc270b0f268d3dff560f956985c7332d4b10bd1ed"), MustHexID("82504b6eb49bb2c0f91a7006ce9cefdbaf6df38706198502c2e06601091fc9dc91e4f15db3410d45c6af355bc270b0f268d3dff560f956985c7332d4b10bd1ed"),
MustHexID("b39b5b677b45944ceebe76e76d1f051de2f2a0ec7b0d650da52135743e66a9a5dba45f638258f9a7545d9a790c7fe6d3fdf82c25425c7887323e45d27d06c057"), MustHexID("b39b5b677b45944ceebe76e76d1f051de2f2a0ec7b0d650da52135743e66a9a5dba45f638258f9a7545d9a790c7fe6d3fdf82c25425c7887323e45d27d06c057"),
}, },
255: []NodeID{ 255: {
MustHexID("5c4d58d46e055dd1f093f81ee60a675e1f02f54da6206720adee4dccef9b67a31efc5c2a2949c31a04ee31beadc79aba10da31440a1f9ff2a24093c63c36d784"), MustHexID("5c4d58d46e055dd1f093f81ee60a675e1f02f54da6206720adee4dccef9b67a31efc5c2a2949c31a04ee31beadc79aba10da31440a1f9ff2a24093c63c36d784"),
MustHexID("ea72161ffdd4b1e124c7b93b0684805f4c4b58d617ed498b37a145c670dbc2e04976f8785583d9c805ffbf343c31d492d79f841652bbbd01b61ed85640b23495"), MustHexID("ea72161ffdd4b1e124c7b93b0684805f4c4b58d617ed498b37a145c670dbc2e04976f8785583d9c805ffbf343c31d492d79f841652bbbd01b61ed85640b23495"),
MustHexID("51caa1d93352d47a8e531692a3612adac1e8ac68d0a200d086c1c57ae1e1a91aa285ab242e8c52ef9d7afe374c9485b122ae815f1707b875569d0433c1c3ce85"), MustHexID("51caa1d93352d47a8e531692a3612adac1e8ac68d0a200d086c1c57ae1e1a91aa285ab242e8c52ef9d7afe374c9485b122ae815f1707b875569d0433c1c3ce85"),
@ -237,7 +237,7 @@ var lookupTestnet = &preminedTestnet{
MustHexID("f492c6ee2696d5f682f7f537757e52744c2ae560f1090a07024609e903d334e9e174fc01609c5a229ddbcac36c9d21adaf6457dab38a25bfd44f2f0ee4277998"), MustHexID("f492c6ee2696d5f682f7f537757e52744c2ae560f1090a07024609e903d334e9e174fc01609c5a229ddbcac36c9d21adaf6457dab38a25bfd44f2f0ee4277998"),
MustHexID("459e4db99298cb0467a90acee6888b08bb857450deac11015cced5104853be5adce5b69c740968bc7f931495d671a70cad9f48546d7cd203357fe9af0e8d2164"), MustHexID("459e4db99298cb0467a90acee6888b08bb857450deac11015cced5104853be5adce5b69c740968bc7f931495d671a70cad9f48546d7cd203357fe9af0e8d2164"),
}, },
256: []NodeID{ 256: {
MustHexID("a8593af8a4aef7b806b5197612017951bac8845a1917ca9a6a15dd6086d608505144990b245785c4cd2d67a295701c7aac2aa18823fb0033987284b019656268"), MustHexID("a8593af8a4aef7b806b5197612017951bac8845a1917ca9a6a15dd6086d608505144990b245785c4cd2d67a295701c7aac2aa18823fb0033987284b019656268"),
MustHexID("d2eebef914928c3aad77fc1b2a495f52d2294acf5edaa7d8a530b540f094b861a68fe8348a46a7c302f08ab609d85912a4968eacfea0740847b29421b4795d9e"), MustHexID("d2eebef914928c3aad77fc1b2a495f52d2294acf5edaa7d8a530b540f094b861a68fe8348a46a7c302f08ab609d85912a4968eacfea0740847b29421b4795d9e"),
MustHexID("b14bfcb31495f32b650b63cf7d08492e3e29071fdc73cf2da0da48d4b191a70ba1a65f42ad8c343206101f00f8a48e8db4b08bf3f622c0853e7323b250835b91"), MustHexID("b14bfcb31495f32b650b63cf7d08492e3e29071fdc73cf2da0da48d4b191a70ba1a65f42ad8c343206101f00f8a48e8db4b08bf3f622c0853e7323b250835b91"),

6
p2p/discv5/sim_test.go
Unescape View File

@ -74,7 +74,7 @@ func TestSimTopics(t *testing.T) {
go func() { go func() {
nets := make([]*Network, 1024) nets := make([]*Network, 1024)
for i, _ := range nets { for i := range nets {
net := sim.launchNode(false) net := sim.launchNode(false)
nets[i] = net nets[i] = net
if err := net.SetFallbackNodes([]*Node{bootnode.Self()}); err != nil { if err := net.SetFallbackNodes([]*Node{bootnode.Self()}); err != nil {
@ -147,7 +147,7 @@ func TestSimTopics(t *testing.T) {
func testHierarchicalTopics(i int) []Topic { func testHierarchicalTopics(i int) []Topic {
digits := strconv.FormatInt(int64(128+i/8), 2) digits := strconv.FormatInt(int64(128+i/8), 2)
res := make([]Topic, 8) res := make([]Topic, 8)
for i, _ := range res { for i := range res {
res[i] = Topic("foo" + digits[1:i+1]) res[i] = Topic("foo" + digits[1:i+1])
} }
return res return res
@ -167,7 +167,7 @@ func TestSimTopicHierarchy(t *testing.T) {
go func() { go func() {
nets := make([]*Network, 1024) nets := make([]*Network, 1024)
for i, _ := range nets { for i := range nets {
net := sim.launchNode(false) net := sim.launchNode(false)
nets[i] = net nets[i] = net
if err := net.SetFallbackNodes([]*Node{bootnode.Self()}); err != nil { if err := net.SetFallbackNodes([]*Node{bootnode.Self()}); err != nil {

2
p2p/discv5/ticket.go
Unescape View File

@ -831,7 +831,7 @@ func (r *topicRadius) recalcRadius() (radius uint64, radiusLookup int) {
maxValue := float64(0) maxValue := float64(0)
now := mclock.Now() now := mclock.Now()
v := float64(0) v := float64(0)
for i, _ := range r.buckets { for i := range r.buckets {
r.buckets[i].update(now) r.buckets[i].update(now)
v += r.buckets[i].weights[trOutside] - r.buckets[i].weights[trInside] v += r.buckets[i].weights[trOutside] - r.buckets[i].weights[trInside]
r.buckets[i].value = v r.buckets[i].value = v

2
p2p/discv5/topic.go
Unescape View File

@ -316,7 +316,7 @@ func (t *topicTable) collectGarbage() {
t.checkDeleteNode(node) t.checkDeleteNode(node)
} }
for topic, _ := range t.topics { for topic := range t.topics {
t.checkDeleteTopic(topic) t.checkDeleteTopic(topic)
} }
} }

2
p2p/nat/natpmp.go
Unescape View File

@ -82,7 +82,7 @@ func discoverPMP() Interface {
// any responses after a very short timeout. // any responses after a very short timeout.
timeout := time.NewTimer(1 * time.Second) timeout := time.NewTimer(1 * time.Second)
defer timeout.Stop() defer timeout.Stop()
for _ = range gws { for range gws {
select { select {
case c := <-found: case c := <-found:
if c != nil { if c != nil {

2
p2p/peer_test.go
Unescape View File

@ -299,7 +299,7 @@ func TestMatchProtocols(t *testing.T) {
} }
} }
// Make sure no protocols missed negotiation // Make sure no protocols missed negotiation
for name, _ := range tt.Match { for name := range tt.Match {
if _, ok := result[name]; !ok { if _, ok := result[name]; !ok {
t.Errorf("test %d, proto '%s': not negotiated, should have", i, name) t.Errorf("test %d, proto '%s': not negotiated, should have", i, name)
continue continue

8
rpc/json.go
Unescape View File

@ -166,7 +166,7 @@ func parseRequest(incomingMsg json.RawMessage) ([]rpcRequest, bool, Error) {
// subscribe are special, they will always use `subscribeMethod` as first param in the payload // subscribe are special, they will always use `subscribeMethod` as first param in the payload
if in.Method == subscribeMethod { if in.Method == subscribeMethod {
reqs := []rpcRequest{rpcRequest{id: &in.Id, isPubSub: true}} reqs := []rpcRequest{{id: &in.Id, isPubSub: true}}
if len(in.Payload) > 0 { if len(in.Payload) > 0 {
// first param must be subscription name // first param must be subscription name
var subscribeMethod [1]string var subscribeMethod [1]string
@ -184,7 +184,7 @@ func parseRequest(incomingMsg json.RawMessage) ([]rpcRequest, bool, Error) {
} }
if in.Method == unsubscribeMethod { if in.Method == unsubscribeMethod {
return []rpcRequest{rpcRequest{id: &in.Id, isPubSub: true, return []rpcRequest{{id: &in.Id, isPubSub: true,
method: unsubscribeMethod, params: in.Payload}}, false, nil method: unsubscribeMethod, params: in.Payload}}, false, nil
} }
@ -195,10 +195,10 @@ func parseRequest(incomingMsg json.RawMessage) ([]rpcRequest, bool, Error) {
// regular RPC call // regular RPC call
if len(in.Payload) == 0 { if len(in.Payload) == 0 {
return []rpcRequest{rpcRequest{service: elems[0], method: elems[1], id: &in.Id}}, false, nil return []rpcRequest{{service: elems[0], method: elems[1], id: &in.Id}}, false, nil
} }
return []rpcRequest{rpcRequest{service: elems[0], method: elems[1], id: &in.Id, params: in.Payload}}, false, nil return []rpcRequest{{service: elems[0], method: elems[1], id: &in.Id, params: in.Payload}}, false, nil
} }
// parseBatchRequest will parse a batch request into a collection of requests from the given RawMessage, an indication // parseBatchRequest will parse a batch request into a collection of requests from the given RawMessage, an indication

4
swarm/storage/dpa_test.go
Unescape View File

@ -67,7 +67,7 @@ func TestDPArandom(t *testing.T) {
ioutil.WriteFile("/tmp/result.bzz.16M", resultSlice, 0666) ioutil.WriteFile("/tmp/result.bzz.16M", resultSlice, 0666)
localStore.memStore = NewMemStore(dbStore, defaultCacheCapacity) localStore.memStore = NewMemStore(dbStore, defaultCacheCapacity)
resultReader = dpa.Retrieve(key) resultReader = dpa.Retrieve(key)
for i, _ := range resultSlice { for i := range resultSlice {
resultSlice[i] = 0 resultSlice[i] = 0
} }
n, err = resultReader.ReadAt(resultSlice, 0) n, err = resultReader.ReadAt(resultSlice, 0)
@ -128,7 +128,7 @@ func TestDPA_capacity(t *testing.T) {
dpa.ChunkStore = localStore dpa.ChunkStore = localStore
// localStore.dbStore.setCapacity(0) // localStore.dbStore.setCapacity(0)
resultReader = dpa.Retrieve(key) resultReader = dpa.Retrieve(key)
for i, _ := range resultSlice { for i := range resultSlice {
resultSlice[i] = 0 resultSlice[i] = 0
} }
n, err = resultReader.ReadAt(resultSlice, 0) n, err = resultReader.ReadAt(resultSlice, 0)

2
trie/encoding.go
Unescape View File

@ -80,7 +80,7 @@ func compactHexEncode(nibbles []byte) []byte {
} }
l := (nl + 1) / 2 l := (nl + 1) / 2
var str = make([]byte, l) var str = make([]byte, l)
for i, _ := range str { for i := range str {
b := nibbles[i*2] * 16 b := nibbles[i*2] * 16
if nl > i*2 { if nl > i*2 {
b += nibbles[i*2+1] b += nibbles[i*2+1]

2
trie/iterator_test.go
Unescape View File

@ -105,7 +105,7 @@ func TestNodeIteratorCoverage(t *testing.T) {
} }
} }
// Cross check the hashes and the database itself // Cross check the hashes and the database itself
for hash, _ := range hashes { for hash := range hashes {
if _, err := db.Get(hash.Bytes()); err != nil { if _, err := db.Get(hash.Bytes()); err != nil {
t.Errorf("failed to retrieve reported node %x: %v", hash, err) t.Errorf("failed to retrieve reported node %x: %v", hash, err)
} }

4
trie/sync_test.go
Unescape View File

@ -182,7 +182,7 @@ func testIterativeRandomTrieSync(t *testing.T, batch int) {
for len(queue) > 0 { for len(queue) > 0 {
// Fetch all the queued nodes in a random order // Fetch all the queued nodes in a random order
results := make([]SyncResult, 0, len(queue)) results := make([]SyncResult, 0, len(queue))
for hash, _ := range queue { for hash := range queue {
data, err := srcDb.Get(hash.Bytes()) data, err := srcDb.Get(hash.Bytes())
if err != nil { if err != nil {
t.Fatalf("failed to retrieve node data for %x: %v", hash, err) t.Fatalf("failed to retrieve node data for %x: %v", hash, err)
@ -219,7 +219,7 @@ func TestIterativeRandomDelayedTrieSync(t *testing.T) {
for len(queue) > 0 { for len(queue) > 0 {
// Sync only half of the scheduled nodes, even those in random order // Sync only half of the scheduled nodes, even those in random order
results := make([]SyncResult, 0, len(queue)/2+1) results := make([]SyncResult, 0, len(queue)/2+1)
for hash, _ := range queue { for hash := range queue {
data, err := srcDb.Get(hash.Bytes()) data, err := srcDb.Get(hash.Bytes())
if err != nil { if err != nil {
t.Fatalf("failed to retrieve node data for %x: %v", hash, err) t.Fatalf("failed to retrieve node data for %x: %v", hash, err)

2
whisper/whisperv2/filter.go
Unescape View File

@ -116,7 +116,7 @@ func (self filterer) Compare(f filter.Filter) bool {
topics := make([]Topic, len(filter.matcher.conditions)) topics := make([]Topic, len(filter.matcher.conditions))
for i, group := range filter.matcher.conditions { for i, group := range filter.matcher.conditions {
// Message should contain a single topic entry, extract // Message should contain a single topic entry, extract
for topics[i], _ = range group { for topics[i] = range group {
break break
} }
} }

2
whisper/whisperv2/peer.go
Unescape View File

@ -149,7 +149,7 @@ func (self *peer) expire() {
return true return true
}) })
// Dump all known but unavailable // Dump all known but unavailable
for hash, _ := range unmark { for hash := range unmark {
self.known.Remove(hash) self.known.Remove(hash)
} }
} }

2
whisper/whisperv2/peer_test.go
Unescape View File

@ -221,7 +221,7 @@ func TestPeerMessageExpiration(t *testing.T) {
t.Fatalf("peer pool size mismatch: have %v, want %v", peers, 1) t.Fatalf("peer pool size mismatch: have %v, want %v", peers, 1)
} }
var peer *peer var peer *peer
for peer, _ = range tester.client.peers { for peer = range tester.client.peers {
break break
} }
tester.client.peerMu.RUnlock() tester.client.peerMu.RUnlock()

52
whisper/whisperv2/topic_test.go
Unescape View File

@ -73,30 +73,30 @@ var topicMatcherCreationTest = struct {
matcher []map[[4]byte]struct{} matcher []map[[4]byte]struct{}
}{ }{
binary: [][][]byte{ binary: [][][]byte{
[][]byte{}, {},
[][]byte{ {
[]byte("Topic A"), []byte("Topic A"),
}, },
[][]byte{ {
[]byte("Topic B1"), []byte("Topic B1"),
[]byte("Topic B2"), []byte("Topic B2"),
[]byte("Topic B3"), []byte("Topic B3"),
}, },
}, },
textual: [][]string{ textual: [][]string{
[]string{}, {},
[]string{"Topic A"}, {"Topic A"},
[]string{"Topic B1", "Topic B2", "Topic B3"}, {"Topic B1", "Topic B2", "Topic B3"},
}, },
matcher: []map[[4]byte]struct{}{ matcher: []map[[4]byte]struct{}{
map[[4]byte]struct{}{}, {},
map[[4]byte]struct{}{ {
[4]byte{0x25, 0xfc, 0x95, 0x66}: struct{}{}, {0x25, 0xfc, 0x95, 0x66}: {},
}, },
map[[4]byte]struct{}{ {
[4]byte{0x93, 0x6d, 0xec, 0x09}: struct{}{}, {0x93, 0x6d, 0xec, 0x09}: {},
[4]byte{0x25, 0x23, 0x34, 0xd3}: struct{}{}, {0x25, 0x23, 0x34, 0xd3}: {},
[4]byte{0x6b, 0xc2, 0x73, 0xd1}: struct{}{}, {0x6b, 0xc2, 0x73, 0xd1}: {},
}, },
}, },
} }
@ -106,14 +106,14 @@ func TestTopicMatcherCreation(t *testing.T) {
matcher := newTopicMatcherFromBinary(test.binary...) matcher := newTopicMatcherFromBinary(test.binary...)
for i, cond := range matcher.conditions { for i, cond := range matcher.conditions {
for topic, _ := range cond { for topic := range cond {
if _, ok := test.matcher[i][topic]; !ok { if _, ok := test.matcher[i][topic]; !ok {
t.Errorf("condition %d; extra topic found: 0x%x", i, topic[:]) t.Errorf("condition %d; extra topic found: 0x%x", i, topic[:])
} }
} }
} }
for i, cond := range test.matcher { for i, cond := range test.matcher {
for topic, _ := range cond { for topic := range cond {
if _, ok := matcher.conditions[i][topic]; !ok { if _, ok := matcher.conditions[i][topic]; !ok {
t.Errorf("condition %d; topic not found: 0x%x", i, topic[:]) t.Errorf("condition %d; topic not found: 0x%x", i, topic[:])
} }
@ -122,14 +122,14 @@ func TestTopicMatcherCreation(t *testing.T) {
matcher = newTopicMatcherFromStrings(test.textual...) matcher = newTopicMatcherFromStrings(test.textual...)
for i, cond := range matcher.conditions { for i, cond := range matcher.conditions {
for topic, _ := range cond { for topic := range cond {
if _, ok := test.matcher[i][topic]; !ok { if _, ok := test.matcher[i][topic]; !ok {
t.Errorf("condition %d; extra topic found: 0x%x", i, topic[:]) t.Errorf("condition %d; extra topic found: 0x%x", i, topic[:])
} }
} }
} }
for i, cond := range test.matcher { for i, cond := range test.matcher {
for topic, _ := range cond { for topic := range cond {
if _, ok := matcher.conditions[i][topic]; !ok { if _, ok := matcher.conditions[i][topic]; !ok {
t.Errorf("condition %d; topic not found: 0x%x", i, topic[:]) t.Errorf("condition %d; topic not found: 0x%x", i, topic[:])
} }
@ -155,49 +155,49 @@ var topicMatcherTests = []struct {
}, },
// Fixed topic matcher should match strictly, but only prefix // Fixed topic matcher should match strictly, but only prefix
{ {
filter: [][]string{[]string{"a"}, []string{"b"}}, filter: [][]string{{"a"}, {"b"}},
topics: []string{"a"}, topics: []string{"a"},
match: false, match: false,
}, },
{ {
filter: [][]string{[]string{"a"}, []string{"b"}}, filter: [][]string{{"a"}, {"b"}},
topics: []string{"a", "b"}, topics: []string{"a", "b"},
match: true, match: true,
}, },
{ {
filter: [][]string{[]string{"a"}, []string{"b"}}, filter: [][]string{{"a"}, {"b"}},
topics: []string{"a", "b", "c"}, topics: []string{"a", "b", "c"},
match: true, match: true,
}, },
// Multi-matcher should match any from a sub-group // Multi-matcher should match any from a sub-group
{ {
filter: [][]string{[]string{"a1", "a2"}}, filter: [][]string{{"a1", "a2"}},
topics: []string{"a"}, topics: []string{"a"},
match: false, match: false,
}, },
{ {
filter: [][]string{[]string{"a1", "a2"}}, filter: [][]string{{"a1", "a2"}},
topics: []string{"a1"}, topics: []string{"a1"},
match: true, match: true,
}, },
{ {
filter: [][]string{[]string{"a1", "a2"}}, filter: [][]string{{"a1", "a2"}},
topics: []string{"a2"}, topics: []string{"a2"},
match: true, match: true,
}, },
// Wild-card condition should match anything // Wild-card condition should match anything
{ {
filter: [][]string{[]string{}, []string{"b"}}, filter: [][]string{{}, {"b"}},
topics: []string{"a"}, topics: []string{"a"},
match: false, match: false,
}, },
{ {
filter: [][]string{[]string{}, []string{"b"}}, filter: [][]string{{}, {"b"}},
topics: []string{"a", "b"}, topics: []string{"a", "b"},
match: true, match: true,
}, },
{ {
filter: [][]string{[]string{}, []string{"b"}}, filter: [][]string{{}, {"b"}},
topics: []string{"b", "b"}, topics: []string{"b", "b"},
match: true, match: true,
}, },

2
whisper/whisperv5/peer.go
Unescape View File

@ -148,7 +148,7 @@ func (peer *Peer) expire() {
return true return true
}) })
// Dump all known but unavailable // Dump all known but unavailable
for hash, _ := range unmark { for hash := range unmark {
peer.known.Remove(hash) peer.known.Remove(hash)
} }
} }

2
whisper/whisperv5/whisper.go
Unescape View File

@ -105,7 +105,7 @@ func (w *Whisper) Version() uint {
func (w *Whisper) getPeer(peerID []byte) (*Peer, error) { func (w *Whisper) getPeer(peerID []byte) (*Peer, error) {
w.peerMu.Lock() w.peerMu.Lock()
defer w.peerMu.Unlock() defer w.peerMu.Unlock()
for p, _ := range w.peers { for p := range w.peers {
id := p.peer.ID() id := p.peer.ID()
if bytes.Equal(peerID, id[:]) { if bytes.Equal(peerID, id[:]) {
return p, nil return p, nil

Write Preview
Loading…
Cancel
Save