path: root/rpc/responses_test.go

package rpc

import (
    "encoding/json"
    "math/big"
    "testing"

    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/core/state"
    "github.com/ethereum/go-ethereum/core/types"
)

func TestNewBlockRes(t *testing.T) {
    parentHash := common.HexToHash("0x01")
    coinbase := common.HexToAddress("0x01")
    root := common.HexToHash("0x01")
    difficulty := common.Big1
    nonce := uint64(1)
    extra := ""
    block := types.NewBlock(parentHash, coinbase, root, difficulty, nonce, extra)

    _ = NewBlockRes(block)
}

func TestBlockRes(t *testing.T) {
    v := &BlockRes{
        BlockNumber:     big.NewInt(0),
        BlockHash:       common.HexToHash("0x0"),
        ParentHash:      common.HexToHash("0x0"),
        Nonce:           [8]byte{0, 0, 0, 0, 0, 0, 0, 0},
        Sha3Uncles:      common.HexToHash("0x0"),
        LogsBloom:       types.BytesToBloom([]byte{0}),
        TransactionRoot: common.HexToHash("0x0"),
        StateRoot:       common.HexToHash("0x0"),
        Miner:           common.HexToAddress("0x0"),
        Difficulty:      big.NewInt(0),
        TotalDifficulty: big.NewInt(0),
        Size:            big.NewInt(0),
        ExtraData:       []byte{},
        GasLimit:        big.NewInt(0),
        MinGasPrice:     int64(0),
        GasUsed:         big.NewInt(0),
        UnixTimestamp:   int64(0),
        // Transactions    []*TransactionRes `json:"transactions"`
        // Uncles          []common.Hash     `json:"uncles"`
    }

    _, _ = json.Marshal(v)

    // fmt.Println(string(j))

}

func TestTransactionRes(t *testing.T) {
    a := common.HexToAddress("0x0")
    v := &TransactionRes{
        Hash:        common.HexToHash("0x0"),
        Nonce:       uint64(0),
        BlockHash:   common.HexToHash("0x0"),
        BlockNumber: int64(0),
        TxIndex:     int64(0),
        From:        common.HexToAddress("0x0"),
        To:          &a,
        Value:       big.NewInt(0),
        Gas:         big.NewInt(0),
        GasPrice:    big.NewInt(0),
        Input:       []byte{0},
    }

    _, _ = json.Marshal(v)
}

func TestNewTransactionRes(t *testing.T) {
    to := common.HexToAddress("0x02")
    amount := big.NewInt(1)
    gasAmount := big.NewInt(1)
    gasPrice := big.NewInt(1)
    data := []byte{1, 2, 3}
    tx := types.NewTransactionMessage(to, amount, gasAmount, gasPrice, data)

    _ = NewTransactionRes(tx)
}

func TestLogRes(t *testing.T) {
    topics := make([]common.Hash, 3)
    topics = append(topics, common.HexToHash("0x00"))
    topics = append(topics, common.HexToHash("0x10"))
    topics = append(topics, common.HexToHash("0x20"))

    v := &LogRes{
        Topics:      topics,
        Address:     common.HexToAddress("0x0"),
        Data:        []byte{1, 2, 3},
        BlockNumber: uint64(5),
    }

    _, _ = json.Marshal(v)
}

func MakeStateLog(num int) state.Log {
    address := common.HexToAddress("0x0")
    data := []byte{1, 2, 3}
    number := uint64(num)
    topics := make([]common.Hash, 3)
    topics = append(topics, common.HexToHash("0x00"))
    topics = append(topics, common.HexToHash("0x10"))
    topics = append(topics, common.HexToHash("0x20"))
    log := state.NewLog(address, topics, data, number)
    return log
}

func TestNewLogRes(t *testing.T) {
    log := MakeStateLog(0)
    _ = NewLogRes(log)
}

func TestNewLogsRes(t *testing.T) {
    logs := make([]state.Log, 3)
    logs[0] = MakeStateLog(1)
    logs[1] = MakeStateLog(2)
    logs[2] = MakeStateLog(3)
    _ = NewLogsRes(logs)
}