From 86661de07746cd4e4ad8d016afee9fa8074aa141 Mon Sep 17 00:00:00 2001
From: obscuren <geffobscura@gmail.com>
Date: Tue, 17 Mar 2015 18:00:03 +0100
Subject: Fixed tests and bloom

---
 core/types/bloom9.go | 17 ++++++++++-------
 core/types/common.go | 11 +++++++----
 tests/vm/gh_test.go  | 26 ++++++++++++++++++--------
 3 files changed, 35 insertions(+), 19 deletions(-)

diff --git a/core/types/bloom9.go b/core/types/bloom9.go
index 59b6c69c3..64a8ff49a 100644
--- a/core/types/bloom9.go
+++ b/core/types/bloom9.go
@@ -20,15 +20,15 @@ func CreateBloom(receipts Receipts) Bloom {
 func LogsBloom(logs state.Logs) *big.Int {
 	bin := new(big.Int)
 	for _, log := range logs {
-		data := make([]common.Hash, len(log.Topics())+1)
-		data[0] = log.Address().Hash()
+		data := make([]common.Hash, len(log.Topics()))
+		bin.Or(bin, bloom9(log.Address().Bytes()))
 
 		for i, topic := range log.Topics() {
-			data[i+1] = topic
+			data[i] = topic
 		}
 
 		for _, b := range data {
-			bin.Or(bin, bloom9(crypto.Sha3(b[:])))
+			bin.Or(bin, bloom9(b[:]))
 		}
 	}
 
@@ -36,21 +36,24 @@ func LogsBloom(logs state.Logs) *big.Int {
 }
 
 func bloom9(b []byte) *big.Int {
+	b = crypto.Sha3(b[:])
+
 	r := new(big.Int)
 
 	for i := 0; i < 6; i += 2 {
 		t := big.NewInt(1)
-		//b := uint(b[i+1]) + 512*(uint(b[i])&1)
-		b := (uint(b[i+1]) + (uint(b[i]) << 8)) & 511
+		b := (uint(b[i+1]) + (uint(b[i]) << 8)) & 2047
 		r.Or(r, t.Lsh(t, b))
 	}
 
 	return r
 }
 
+var Bloom9 = bloom9
+
 func BloomLookup(bin Bloom, topic common.Hash) bool {
 	bloom := bin.Big()
-	cmp := bloom9(crypto.Sha3(topic[:]))
+	cmp := bloom9(topic[:])
 
 	return bloom.And(bloom, cmp).Cmp(cmp) == 0
 }
diff --git a/core/types/common.go b/core/types/common.go
index 6c5ac06b1..cb57ef053 100644
--- a/core/types/common.go
+++ b/core/types/common.go
@@ -1,6 +1,7 @@
 package types
 
 import (
+	"fmt"
 	"math/big"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -10,7 +11,9 @@ type BlockProcessor interface {
 	Process(*Block) (*big.Int, error)
 }
 
-type Bloom [256]byte
+const bloomLength = 256
+
+type Bloom [bloomLength]byte
 
 func BytesToBloom(b []byte) Bloom {
 	var bloom Bloom
@@ -19,13 +22,13 @@ func BytesToBloom(b []byte) Bloom {
 }
 
 func (b *Bloom) SetBytes(d []byte) {
-	if len(b) > len(d) {
-		panic("bloom bytes too big")
+	if len(b) < len(d) {
+		panic(fmt.Sprintf("bloom bytes too big %d %d", len(b), len(d)))
 	}
 
 	// reverse loop
 	for i := len(d) - 1; i >= 0; i-- {
-		b[i] = b[i]
+		b[bloomLength-len(d)+i] = b[i]
 	}
 }
 
diff --git a/tests/vm/gh_test.go b/tests/vm/gh_test.go
index bce34bb5d..68600d304 100644
--- a/tests/vm/gh_test.go
+++ b/tests/vm/gh_test.go
@@ -2,7 +2,6 @@ package vm
 
 import (
 	"bytes"
-	"fmt"
 	"math/big"
 	"strconv"
 	"testing"
@@ -82,9 +81,6 @@ func RunVmTest(p string, t *testing.T) {
 	helper.CreateFileTests(t, p, &tests)
 
 	for name, test := range tests {
-		if name != "log2_nonEmptyMem" {
-			continue
-		}
 		db, _ := ethdb.NewMemDatabase()
 		statedb := state.New(common.Hash{}, db)
 		for addr, account := range test.Pre {
@@ -172,12 +168,26 @@ func RunVmTest(p string, t *testing.T) {
 			if len(test.Logs) != len(logs) {
 				t.Errorf("log length mismatch. Expected %d, got %d", len(test.Logs), len(logs))
 			} else {
-				fmt.Println("A", test.Logs)
-				fmt.Println("B", logs)
 				for i, log := range test.Logs {
+					if common.HexToAddress(log.AddressF) != logs[i].Address() {
+						t.Errorf("'%s' log address expected %v got %x", name, log.AddressF, logs[i].Address())
+					}
+
+					if !bytes.Equal(logs[i].Data(), helper.FromHex(log.DataF)) {
+						t.Errorf("'%s' log data expected %v got %x", name, log.DataF, logs[i].Data())
+					}
+
+					if len(log.TopicsF) != len(logs[i].Topics()) {
+						t.Errorf("'%s' log topics length expected %d got %d", name, len(log.TopicsF), logs[i].Topics())
+					} else {
+						for j, topic := range log.TopicsF {
+							if common.HexToHash(topic) != logs[i].Topics()[j] {
+								t.Errorf("'%s' log topic[%d] expected %v got %x", name, j, topic, logs[i].Topics()[j])
+							}
+						}
+					}
 					genBloom := common.LeftPadBytes(types.LogsBloom(state.Logs{logs[i]}).Bytes(), 256)
-					fmt.Println("A BLOOM", log.BloomF)
-					fmt.Printf("B BLOOM %x\n", genBloom)
+
 					if !bytes.Equal(genBloom, common.Hex2Bytes(log.BloomF)) {
 						t.Errorf("'%s' bloom mismatch", name)
 					}
-- 
cgit