aboutsummaryrefslogblamecommitdiffstats
path: root/rpc/api/args_test.go
blob: a30f247bca92e4b433dd8aaf8ca58e9938fabf48 (plain) (tree)
1
2
3
4
5
6
7
8
9
           



                       
             

                  
 
                                                    

 






















































                                                           




                                                         
                                     











                                                                                                                 
                                      











                                                                                                                  
                                             











                                                                                                                       
                                      






                                                                                                                  








































                                                                                  


                                                                         
                                                                       















                                                                                                      



















                                                                                                      


                                                                           
                                                                       






                                                                    








                                                                                                      
                                            


                                   
                                                                                  

                            






                                              


                                                                           
         



                                                                        
 
                                   


                                                                           






                                                     


                                                                           
         

 


                                                                                              
                                                                                                
                                  









                                                                                                

                                                                                                   


         
                                                


                                       


                                                                                  






                                                  


                                                                           






                                                  
                                                                                  

                            


         









                                                                           




















                                                                                                      


                                             
                                   






                                                                    
                                                                                                      

         

                                                                                                   

         


















                                                                                                      
 



                                              


                                                                                  


         









                                                                                  



                                             


                                                                           





                                                    


                                                                           


         





                                                                         

                                                                                                  
                                  

                                                                    



                                                                                                              
                                                     




























                                                                                               





                                                                                                       







                                                                                                  
                                  



                                               





                                                                    









                                                                                            


                                                     
                                                                                                     
         
 
 







                                                                                                  

                              
                                                                           



























































                                                                                                
                                  
                          

                              



                                                                    

                                                                                  
                                                                             










                                                                                                
                                  
                               

                              

                                                                    
         
 

                                                                                            


                                                                                            









                                                                                                

                                      

                              

                                                                    
         




                                                                                   

 



                                       


                                                                                  






                                         


                                                                           





                                            


                                                                           


         

                                                                         
 
                              



























                                                                                                              










































































































































                                                                                                       
                          
 

                                                                                  



















                                                                                                
                               
 

                                                                                            






















































                                                                                                

                                                                           



                                                                          


         


                                                                           
                                                                       






                                                                    








                                                                                                       



















                                                                                                       



                                              


                                                                           






                                                                     


                                                                           


         



                                            


                                                                                  






                                             


                                                                           


         


                                                                               

                                                                       






                                                                    












                                                                                                       
























                                                                                                       



                                              


                                                                                  






                                                


                                                                           






                                                         


                                                                           






                                                                              


                                                                           






                                                                              


                                                                           


         
                                       
                                                                            
                                       
                                                                       
                                 





                                                                    








                                                                                                       



                                            


                                                                                  






                                                   


                                                                           






                                                   


                                                                           


         



















                                                                                                       



                                                                     


                                                                           


         


                                                                           
                                                                       






                                                                    








                                                                                                       



















                                                                                                       
                                         


                                


                                                                                  






                                           


                                                                           






                                                    


                                                                           






                                                                        


                                                                           


         
                                        





                                                          






                         
                                        



                             




                                                                                 
 
                                    



















                                                                                              





















































                                                                                              


                                                                                           






                                                                                        

 
                                             



                        
                                        

                              
 
                                    












                                                                                              










                                                                           
                    
                    













                                                                           

     
                                    


                                                                           
         

 
                                                 

                     
                                    





                                                            









































































































                                                                                   
                               
                                              
                               


                                         

















                                                                                              




                                                                                     













































































                                                                                  
























                                                                                              



                                                                                     













































































                                                                                  











                                                                 
                                                                 

























                                                                                              
                                              



                                                                                     

























































































                                                                                            














                                                                            





























                                                                                  
                                          

                                                                                        
                                         
                                                                          





                                                                    








                                                                                        



















                                                                                 









                                                                          









                                                                          














                                                                          









                                                                          














                                                                                                             





























                                                                                 














                                                                                  



                                              
































                                                                                  


         













                                                                                              
 





























                                                                                  














                                                                                                       














                                                                                                       




























                                                                                  



















                                                                                                       



















                                                                                                       



                                               


                                                                                  






                                                 


                                                                           






                                                         


                                                                           



                                                      
                                  

                                      


                                                                           


         


                                                                                                
                                                                                            






                                                                    

                                                                                  





                                                                                     
 



                                           


                                                                                  






                                             


                                                                           






                                                 


                                                                           






                                                                                                


                                                                           


         












































                                                                                            



                                                                                                                     

                                                              

















                                                                                        















































                                                                                                  








                                                                     









                                                                                  










                                                                        







                                                                                 

















































                                                                                 





















































                                                                                 
package api

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

    "github.com/ethereum/go-ethereum/rpc/shared"
)

func TestBlockheightInvalidString(t *testing.T) {
    v := "foo"
    var num int64

    str := ExpectInvalidTypeError(blockHeight(v, &num))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestBlockheightEarliest(t *testing.T) {
    v := "earliest"
    e := int64(0)
    var num int64

    err := blockHeight(v, &num)
    if err != nil {
        t.Error(err)
    }

    if num != e {
        t.Errorf("Expected %s but got %s", e, num)
    }
}

func TestBlockheightLatest(t *testing.T) {
    v := "latest"
    e := int64(-1)
    var num int64

    err := blockHeight(v, &num)
    if err != nil {
        t.Error(err)
    }

    if num != e {
        t.Errorf("Expected %s but got %s", e, num)
    }
}

func TestBlockheightPending(t *testing.T) {
    v := "pending"
    e := int64(-2)
    var num int64

    err := blockHeight(v, &num)
    if err != nil {
        t.Error(err)
    }

    if num != e {
        t.Errorf("Expected %s but got %s", e, num)
    }
}

func ExpectValidationError(err error) string {
    var str string
    switch err.(type) {
    case nil:
        str = "Expected error but didn't get one"
    case *shared.ValidationError:
        break
    default:
        str = fmt.Sprintf("Expected *rpc.ValidationError but got %T with message `%s`", err, err.Error())
    }
    return str
}

func ExpectInvalidTypeError(err error) string {
    var str string
    switch err.(type) {
    case nil:
        str = "Expected error but didn't get one"
    case *shared.InvalidTypeError:
        break
    default:
        str = fmt.Sprintf("Expected *rpc.InvalidTypeError but got %T with message `%s`", err, err.Error())
    }
    return str
}

func ExpectInsufficientParamsError(err error) string {
    var str string
    switch err.(type) {
    case nil:
        str = "Expected error but didn't get one"
    case *shared.InsufficientParamsError:
        break
    default:
        str = fmt.Sprintf("Expected *rpc.InsufficientParamsError but got %T with message %s", err, err.Error())
    }
    return str
}

func ExpectDecodeParamError(err error) string {
    var str string
    switch err.(type) {
    case nil:
        str = "Expected error but didn't get one"
    case *shared.DecodeParamError:
        break
    default:
        str = fmt.Sprintf("Expected *rpc.DecodeParamError but got %T with message `%s`", err, err.Error())
    }
    return str
}

func TestSha3(t *testing.T) {
    input := `["0x68656c6c6f20776f726c64"]`
    expected := "0x68656c6c6f20776f726c64"

    args := new(Sha3Args)
    json.Unmarshal([]byte(input), &args)

    if args.Data != expected {
        t.Error("got %s expected %s", input, expected)
    }
}

func TestSha3ArgsInvalid(t *testing.T) {
    input := `{}`

    args := new(Sha3Args)
    str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestSha3ArgsEmpty(t *testing.T) {
    input := `[]`

    args := new(Sha3Args)
    str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}
func TestSha3ArgsDataInvalid(t *testing.T) {
    input := `[4]`

    args := new(Sha3Args)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestGetBalanceArgs(t *testing.T) {
    input := `["0x407d73d8a49eeb85d32cf465507dd71d507100c1", "0x1f"]`
    expected := new(GetBalanceArgs)
    expected.Address = "0x407d73d8a49eeb85d32cf465507dd71d507100c1"
    expected.BlockNumber = 31

    args := new(GetBalanceArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if args.Address != expected.Address {
        t.Errorf("Address should be %v but is %v", expected.Address, args.Address)
    }

    if args.BlockNumber != expected.BlockNumber {
        t.Errorf("BlockNumber should be %v but is %v", expected.BlockNumber, args.BlockNumber)
    }
}

func TestGetBalanceArgsBlocknumMissing(t *testing.T) {
    input := `["0x407d73d8a49eeb85d32cf465507dd71d507100c1"]`
    expected := new(GetBalanceArgs)
    expected.Address = "0x407d73d8a49eeb85d32cf465507dd71d507100c1"
    expected.BlockNumber = -1

    args := new(GetBalanceArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if args.Address != expected.Address {
        t.Errorf("Address should be %v but is %v", expected.Address, args.Address)
    }

    if args.BlockNumber != expected.BlockNumber {
        t.Errorf("BlockNumber should be %v but is %v", expected.BlockNumber, args.BlockNumber)
    }
}

func TestGetBalanceArgsLatest(t *testing.T) {
    input := `["0x407d73d8a49eeb85d32cf465507dd71d507100c1", "latest"]`
    expected := new(GetBalanceArgs)
    expected.Address = "0x407d73d8a49eeb85d32cf465507dd71d507100c1"
    expected.BlockNumber = -1

    args := new(GetBalanceArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if args.Address != expected.Address {
        t.Errorf("Address should be %v but is %v", expected.Address, args.Address)
    }

    if args.BlockNumber != expected.BlockNumber {
        t.Errorf("BlockNumber should be %v but is %v", expected.BlockNumber, args.BlockNumber)
    }
}

func TestGetBalanceArgsEmpty(t *testing.T) {
    input := `[]`

    args := new(GetBalanceArgs)
    str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestGetBalanceArgsInvalid(t *testing.T) {
    input := `6`

    args := new(GetBalanceArgs)
    str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestGetBalanceArgsBlockInvalid(t *testing.T) {
    input := `["0x407d73d8a49eeb85d32cf465507dd71d507100c1", false]`

    args := new(GetBalanceArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestGetBalanceArgsAddressInvalid(t *testing.T) {
    input := `[-9, "latest"]`

    args := new(GetBalanceArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestGetBlockByHashArgs(t *testing.T) {
    input := `["0xe670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331", true]`
    expected := new(GetBlockByHashArgs)
    expected.BlockHash = "0xe670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331"
    expected.IncludeTxs = true

    args := new(GetBlockByHashArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if args.BlockHash != expected.BlockHash {
        t.Errorf("BlockHash should be %v but is %v", expected.BlockHash, args.BlockHash)
    }

    if args.IncludeTxs != expected.IncludeTxs {
        t.Errorf("IncludeTxs should be %v but is %v", expected.IncludeTxs, args.IncludeTxs)
    }
}

func TestGetBlockByHashArgsEmpty(t *testing.T) {
    input := `[]`

    args := new(GetBlockByHashArgs)
    str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestGetBlockByHashArgsInvalid(t *testing.T) {
    input := `{}`

    args := new(GetBlockByHashArgs)
    str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestGetBlockByHashArgsHashInt(t *testing.T) {
    input := `[8]`

    args := new(GetBlockByHashArgs)
    str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestGetBlockByHashArgsHashBool(t *testing.T) {
    input := `[false, true]`

    args := new(GetBlockByHashArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestGetBlockByNumberArgsBlockNum(t *testing.T) {
    input := `[436, false]`
    expected := new(GetBlockByNumberArgs)
    expected.BlockNumber = 436
    expected.IncludeTxs = false

    args := new(GetBlockByNumberArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if args.BlockNumber != expected.BlockNumber {
        t.Errorf("BlockNumber should be %v but is %v", expected.BlockNumber, args.BlockNumber)
    }

    if args.IncludeTxs != expected.IncludeTxs {
        t.Errorf("IncludeTxs should be %v but is %v", expected.IncludeTxs, args.IncludeTxs)
    }
}

func TestGetBlockByNumberArgsBlockHex(t *testing.T) {
    input := `["0x1b4", false]`
    expected := new(GetBlockByNumberArgs)
    expected.BlockNumber = 436
    expected.IncludeTxs = false

    args := new(GetBlockByNumberArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if args.BlockNumber != expected.BlockNumber {
        t.Errorf("BlockNumber should be %v but is %v", expected.BlockNumber, args.BlockNumber)
    }

    if args.IncludeTxs != expected.IncludeTxs {
        t.Errorf("IncludeTxs should be %v but is %v", expected.IncludeTxs, args.IncludeTxs)
    }
}
func TestGetBlockByNumberArgsWords(t *testing.T) {
    input := `["earliest", true]`
    expected := new(GetBlockByNumberArgs)
    expected.BlockNumber = 0
    expected.IncludeTxs = true

    args := new(GetBlockByNumberArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if args.BlockNumber != expected.BlockNumber {
        t.Errorf("BlockNumber should be %v but is %v", expected.BlockNumber, args.BlockNumber)
    }

    if args.IncludeTxs != expected.IncludeTxs {
        t.Errorf("IncludeTxs should be %v but is %v", expected.IncludeTxs, args.IncludeTxs)
    }
}

func TestGetBlockByNumberEmpty(t *testing.T) {
    input := `[]`

    args := new(GetBlockByNumberArgs)
    str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestGetBlockByNumberShort(t *testing.T) {
    input := `["0xbbb"]`

    args := new(GetBlockByNumberArgs)
    str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestGetBlockByNumberBool(t *testing.T) {
    input := `[true, true]`

    args := new(GetBlockByNumberArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}
func TestGetBlockByNumberBlockObject(t *testing.T) {
    input := `{}`

    args := new(GetBlockByNumberArgs)
    str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestNewTxArgs(t *testing.T) {
    input := `[{"from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
  "to": "0xd46e8dd67c5d32be8058bb8eb970870f072445675",
  "gas": "0x76c0",
  "gasPrice": "0x9184e72a000",
  "value": "0x9184e72a000",
  "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"},
  "0x10"]`
    expected := new(NewTxArgs)
    expected.From = "0xb60e8dd61c5d32be8058bb8eb970870f07233155"
    expected.To = "0xd46e8dd67c5d32be8058bb8eb970870f072445675"
    expected.Gas = big.NewInt(30400)
    expected.GasPrice = big.NewInt(10000000000000)
    expected.Value = big.NewInt(10000000000000)
    expected.Data = "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
    expected.BlockNumber = big.NewInt(16).Int64()

    args := new(NewTxArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if expected.From != args.From {
        t.Errorf("From shoud be %#v but is %#v", expected.From, args.From)
    }

    if expected.To != args.To {
        t.Errorf("To shoud be %#v but is %#v", expected.To, args.To)
    }

    if bytes.Compare(expected.Gas.Bytes(), args.Gas.Bytes()) != 0 {
        t.Errorf("Gas shoud be %#v but is %#v", expected.Gas.Bytes(), args.Gas.Bytes())
    }

    if bytes.Compare(expected.GasPrice.Bytes(), args.GasPrice.Bytes()) != 0 {
        t.Errorf("GasPrice shoud be %#v but is %#v", expected.GasPrice, args.GasPrice)
    }

    if bytes.Compare(expected.Value.Bytes(), args.Value.Bytes()) != 0 {
        t.Errorf("Value shoud be %#v but is %#v", expected.Value, args.Value)
    }

    if expected.Data != args.Data {
        t.Errorf("Data shoud be %#v but is %#v", expected.Data, args.Data)
    }

    if expected.BlockNumber != args.BlockNumber {
        t.Errorf("BlockNumber shoud be %#v but is %#v", expected.BlockNumber, args.BlockNumber)
    }
}

func TestNewTxArgsInt(t *testing.T) {
    input := `[{"from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
  "to": "0xd46e8dd67c5d32be8058bb8eb970870f072445675",
  "gas": 100,
  "gasPrice": 50,
  "value": 8765456789,
  "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"},
  5]`
    expected := new(NewTxArgs)
    expected.Gas = big.NewInt(100)
    expected.GasPrice = big.NewInt(50)
    expected.Value = big.NewInt(8765456789)
    expected.BlockNumber = int64(5)

    args := new(NewTxArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if bytes.Compare(expected.Gas.Bytes(), args.Gas.Bytes()) != 0 {
        t.Errorf("Gas shoud be %v but is %v", expected.Gas, args.Gas)
    }

    if bytes.Compare(expected.GasPrice.Bytes(), args.GasPrice.Bytes()) != 0 {
        t.Errorf("GasPrice shoud be %v but is %v", expected.GasPrice, args.GasPrice)
    }

    if bytes.Compare(expected.Value.Bytes(), args.Value.Bytes()) != 0 {
        t.Errorf("Value shoud be %v but is %v", expected.Value, args.Value)
    }

    if expected.BlockNumber != args.BlockNumber {
        t.Errorf("BlockNumber shoud be %v but is %v", expected.BlockNumber, args.BlockNumber)
    }
}

func TestNewTxArgsBlockBool(t *testing.T) {
    input := `[{"from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
  "to": "0xd46e8dd67c5d32be8058bb8eb970870f072445675",
  "gas": "0x76c0",
  "gasPrice": "0x9184e72a000",
  "value": "0x9184e72a000",
  "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"},
  false]`

    args := new(NewTxArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestNewTxArgsGasInvalid(t *testing.T) {
    input := `[{"from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
  "to": "0xd46e8dd67c5d32be8058bb8eb970870f072445675",
  "gas": false,
  "gasPrice": "0x9184e72a000",
  "value": "0x9184e72a000",
  "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
  }]`

    args := new(NewTxArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestNewTxArgsGaspriceInvalid(t *testing.T) {
    input := `[{"from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
  "to": "0xd46e8dd67c5d32be8058bb8eb970870f072445675",
  "gas": "0x76c0",
  "gasPrice": false,
  "value": "0x9184e72a000",
  "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
  }]`

    args := new(NewTxArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestNewTxArgsValueInvalid(t *testing.T) {
    input := `[{"from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
  "to": "0xd46e8dd67c5d32be8058bb8eb970870f072445675",
  "gas": "0x76c0",
  "gasPrice": "0x9184e72a000",
  "value": false,
  "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
    }]`

    args := new(NewTxArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestNewTxArgsGasMissing(t *testing.T) {
    input := `[{"from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
  "to": "0xd46e8dd67c5d32be8058bb8eb970870f072445675",
  "gasPrice": "0x9184e72a000",
  "value": "0x9184e72a000",
  "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
  }]`
    expected := new(NewTxArgs)
    expected.Gas = nil

    args := new(NewTxArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if args.Gas != expected.Gas {
        // if bytes.Compare(expected.Gas.Bytes(), args.Gas.Bytes()) != 0 {
        t.Errorf("Gas shoud be %v but is %v", expected.Gas, args.Gas)
    }
}

func TestNewTxArgsBlockGaspriceMissing(t *testing.T) {
    input := `[{
    "from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
  "to": "0xd46e8dd67c5d32be8058bb8eb970870f072445675",
  "gas": "0x76c0",
  "value": "0x9184e72a000",
  "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
  }]`
    expected := new(NewTxArgs)
    expected.GasPrice = nil

    args := new(NewTxArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if args.GasPrice != expected.GasPrice {
        // if bytes.Compare(expected.GasPrice.Bytes(), args.GasPrice.Bytes()) != 0 {
        t.Errorf("GasPrice shoud be %v but is %v", expected.GasPrice, args.GasPrice)
    }

}

func TestNewTxArgsValueMissing(t *testing.T) {
    input := `[{
    "from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
  "to": "0xd46e8dd67c5d32be8058bb8eb970870f072445675",
  "gas": "0x76c0",
  "gasPrice": "0x9184e72a000",
  "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
    }]`
    expected := new(NewTxArgs)
    expected.Value = big.NewInt(0)

    args := new(NewTxArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if bytes.Compare(expected.Value.Bytes(), args.Value.Bytes()) != 0 {
        t.Errorf("Value shoud be %v but is %v", expected.Value, args.Value)
    }

}

func TestNewTxArgsEmpty(t *testing.T) {
    input := `[]`

    args := new(NewTxArgs)
    str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestNewTxArgsInvalid(t *testing.T) {
    input := `{}`

    args := new(NewTxArgs)
    str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}
func TestNewTxArgsNotStrings(t *testing.T) {
    input := `[{"from":6}]`

    args := new(NewTxArgs)
    str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestNewTxArgsFromEmpty(t *testing.T) {
    input := `[{"to": "0xb60e8dd61c5d32be8058bb8eb970870f07233155"}]`

    args := new(NewTxArgs)
    str := ExpectValidationError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestCallArgs(t *testing.T) {
    input := `[{"from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
  "to": "0xd46e8dd67c5d32be8058bb8eb970870f072445675",
  "gas": "0x76c0",
  "gasPrice": "0x9184e72a000",
  "value": "0x9184e72a000",
  "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"},
  "0x10"]`
    expected := new(CallArgs)
    expected.From = "0xb60e8dd61c5d32be8058bb8eb970870f07233155"
    expected.To = "0xd46e8dd67c5d32be8058bb8eb970870f072445675"
    expected.Gas = big.NewInt(30400)
    expected.GasPrice = big.NewInt(10000000000000)
    expected.Value = big.NewInt(10000000000000)
    expected.Data = "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
    expected.BlockNumber = big.NewInt(16).Int64()

    args := new(CallArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if expected.To != args.To {
        t.Errorf("To shoud be %#v but is %#v", expected.To, args.To)
    }

    if bytes.Compare(expected.Gas.Bytes(), args.Gas.Bytes()) != 0 {
        t.Errorf("Gas shoud be %#v but is %#v", expected.Gas.Bytes(), args.Gas.Bytes())
    }

    if bytes.Compare(expected.GasPrice.Bytes(), args.GasPrice.Bytes()) != 0 {
        t.Errorf("GasPrice shoud be %#v but is %#v", expected.GasPrice, args.GasPrice)
    }

    if bytes.Compare(expected.Value.Bytes(), args.Value.Bytes()) != 0 {
        t.Errorf("Value shoud be %#v but is %#v", expected.Value, args.Value)
    }

    if expected.Data != args.Data {
        t.Errorf("Data shoud be %#v but is %#v", expected.Data, args.Data)
    }

    if expected.BlockNumber != args.BlockNumber {
        t.Errorf("BlockNumber shoud be %#v but is %#v", expected.BlockNumber, args.BlockNumber)
    }
}

func TestCallArgsInt(t *testing.T) {
    input := `[{"from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
  "to": "0xd46e8dd67c5d32be8058bb8eb970870f072445675",
  "gas": 100,
  "gasPrice": 50,
  "value": 8765456789,
  "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"},
  5]`
    expected := new(CallArgs)
    expected.Gas = big.NewInt(100)
    expected.GasPrice = big.NewInt(50)
    expected.Value = big.NewInt(8765456789)
    expected.BlockNumber = int64(5)

    args := new(CallArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if bytes.Compare(expected.Gas.Bytes(), args.Gas.Bytes()) != 0 {
        t.Errorf("Gas shoud be %v but is %v", expected.Gas, args.Gas)
    }

    if bytes.Compare(expected.GasPrice.Bytes(), args.GasPrice.Bytes()) != 0 {
        t.Errorf("GasPrice shoud be %v but is %v", expected.GasPrice, args.GasPrice)
    }

    if bytes.Compare(expected.Value.Bytes(), args.Value.Bytes()) != 0 {
        t.Errorf("Value shoud be %v but is %v", expected.Value, args.Value)
    }

    if expected.BlockNumber != args.BlockNumber {
        t.Errorf("BlockNumber shoud be %v but is %v", expected.BlockNumber, args.BlockNumber)
    }
}

func TestCallArgsBlockBool(t *testing.T) {
    input := `[{"from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
  "to": "0xd46e8dd67c5d32be8058bb8eb970870f072445675",
  "gas": "0x76c0",
  "gasPrice": "0x9184e72a000",
  "value": "0x9184e72a000",
  "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"},
  false]`

    args := new(CallArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestCallArgsGasInvalid(t *testing.T) {
    input := `[{"from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
  "to": "0xd46e8dd67c5d32be8058bb8eb970870f072445675",
  "gas": false,
  "gasPrice": "0x9184e72a000",
  "value": "0x9184e72a000",
  "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
  }]`

    args := new(CallArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestCallArgsGaspriceInvalid(t *testing.T) {
    input := `[{"from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
  "to": "0xd46e8dd67c5d32be8058bb8eb970870f072445675",
  "gas": "0x76c0",
  "gasPrice": false,
  "value": "0x9184e72a000",
  "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
  }]`

    args := new(CallArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestCallArgsValueInvalid(t *testing.T) {
    input := `[{"from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
  "to": "0xd46e8dd67c5d32be8058bb8eb970870f072445675",
  "gas": "0x76c0",
  "gasPrice": "0x9184e72a000",
  "value": false,
  "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
    }]`

    args := new(CallArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestCallArgsGasMissing(t *testing.T) {
    input := `[{"from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
  "to": "0xd46e8dd67c5d32be8058bb8eb970870f072445675",
  "gasPrice": "0x9184e72a000",
  "value": "0x9184e72a000",
  "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
  }]`

    args := new(CallArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    expected := new(CallArgs)
    expected.Gas = nil

    if args.Gas != expected.Gas {
        // if bytes.Compare(expected.Gas.Bytes(), args.Gas.Bytes()) != 0 {
        t.Errorf("Gas shoud be %v but is %v", expected.Gas, args.Gas)
    }

}

func TestCallArgsBlockGaspriceMissing(t *testing.T) {
    input := `[{
    "from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
  "to": "0xd46e8dd67c5d32be8058bb8eb970870f072445675",
  "gas": "0x76c0",
  "value": "0x9184e72a000",
  "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
  }]`

    args := new(CallArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    expected := new(CallArgs)
    expected.GasPrice = nil

    if args.GasPrice != expected.GasPrice {
        // if bytes.Compare(expected.GasPrice.Bytes(), args.GasPrice.Bytes()) != 0 {
        t.Errorf("GasPrice shoud be %v but is %v", expected.GasPrice, args.GasPrice)
    }
}

func TestCallArgsValueMissing(t *testing.T) {
    input := `[{
    "from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
  "to": "0xd46e8dd67c5d32be8058bb8eb970870f072445675",
  "gas": "0x76c0",
  "gasPrice": "0x9184e72a000",
  "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
    }]`

    args := new(CallArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    expected := new(CallArgs)
    expected.Value = big.NewInt(int64(0))

    if bytes.Compare(expected.Value.Bytes(), args.Value.Bytes()) != 0 {
        t.Errorf("GasPrice shoud be %v but is %v", expected.Value, args.Value)
    }
}

func TestCallArgsEmpty(t *testing.T) {
    input := `[]`

    args := new(CallArgs)
    str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestCallArgsInvalid(t *testing.T) {
    input := `{}`

    args := new(CallArgs)
    str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}
func TestCallArgsNotStrings(t *testing.T) {
    input := `[{"from":6}]`

    args := new(CallArgs)
    str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestCallArgsToEmpty(t *testing.T) {
    input := `[{"from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155"}]`
    args := new(CallArgs)
    str := ExpectValidationError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestGetStorageArgs(t *testing.T) {
    input := `["0x407d73d8a49eeb85d32cf465507dd71d507100c1", "latest"]`
    expected := new(GetStorageArgs)
    expected.Address = "0x407d73d8a49eeb85d32cf465507dd71d507100c1"
    expected.BlockNumber = -1

    args := new(GetStorageArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if expected.Address != args.Address {
        t.Errorf("Address shoud be %#v but is %#v", expected.Address, args.Address)
    }

    if expected.BlockNumber != args.BlockNumber {
        t.Errorf("BlockNumber shoud be %#v but is %#v", expected.BlockNumber, args.BlockNumber)
    }
}

func TestGetStorageArgsMissingBlocknum(t *testing.T) {
    input := `["0x407d73d8a49eeb85d32cf465507dd71d507100c1"]`
    expected := new(GetStorageArgs)
    expected.Address = "0x407d73d8a49eeb85d32cf465507dd71d507100c1"
    expected.BlockNumber = -1

    args := new(GetStorageArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if expected.Address != args.Address {
        t.Errorf("Address shoud be %#v but is %#v", expected.Address, args.Address)
    }

    if expected.BlockNumber != args.BlockNumber {
        t.Errorf("BlockNumber shoud be %#v but is %#v", expected.BlockNumber, args.BlockNumber)
    }
}

func TestGetStorageInvalidArgs(t *testing.T) {
    input := `{}`

    args := new(GetStorageArgs)
    str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestGetStorageInvalidBlockheight(t *testing.T) {
    input := `["0x407d73d8a49eeb85d32cf465507dd71d507100c1", {}]`

    args := new(GetStorageArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestGetStorageEmptyArgs(t *testing.T) {
    input := `[]`

    args := new(GetStorageArgs)
    str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestGetStorageAddressInt(t *testing.T) {
    input := `[32456785432456, "latest"]`

    args := new(GetStorageArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestGetStorageAtArgs(t *testing.T) {
    input := `["0x407d73d8a49eeb85d32cf465507dd71d507100c1", "0x0", "0x2"]`
    expected := new(GetStorageAtArgs)
    expected.Address = "0x407d73d8a49eeb85d32cf465507dd71d507100c1"
    expected.Key = "0x0"
    expected.BlockNumber = 2

    args := new(GetStorageAtArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if expected.Address != args.Address {
        t.Errorf("Address shoud be %#v but is %#v", expected.Address, args.Address)
    }

    if expected.Key != args.Key {
        t.Errorf("Address shoud be %#v but is %#v", expected.Address, args.Address)
    }

    if expected.BlockNumber != args.BlockNumber {
        t.Errorf("BlockNumber shoud be %#v but is %#v", expected.BlockNumber, args.BlockNumber)
    }
}

func TestGetStorageAtArgsMissingBlocknum(t *testing.T) {
    input := `["0x407d73d8a49eeb85d32cf465507dd71d507100c1", "0x0"]`
    expected := new(GetStorageAtArgs)
    expected.Address = "0x407d73d8a49eeb85d32cf465507dd71d507100c1"
    expected.Key = "0x0"
    expected.BlockNumber = -1

    args := new(GetStorageAtArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if expected.Address != args.Address {
        t.Errorf("Address shoud be %#v but is %#v", expected.Address, args.Address)
    }

    if expected.Key != args.Key {
        t.Errorf("Address shoud be %#v but is %#v", expected.Address, args.Address)
    }

    if expected.BlockNumber != args.BlockNumber {
        t.Errorf("BlockNumber shoud be %#v but is %#v", expected.BlockNumber, args.BlockNumber)
    }
}

func TestGetStorageAtEmptyArgs(t *testing.T) {
    input := `[]`

    args := new(GetStorageAtArgs)
    str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestGetStorageAtArgsInvalid(t *testing.T) {
    input := `{}`

    args := new(GetStorageAtArgs)
    str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestGetStorageAtArgsAddressNotString(t *testing.T) {
    input := `[true, "0x0", "0x2"]`

    args := new(GetStorageAtArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestGetStorageAtArgsKeyNotString(t *testing.T) {
    input := `["0x407d73d8a49eeb85d32cf465507dd71d507100c1", true, "0x2"]`

    args := new(GetStorageAtArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestGetStorageAtArgsValueNotString(t *testing.T) {
    input := `["0x407d73d8a49eeb85d32cf465507dd71d507100c1", "0x1", true]`

    args := new(GetStorageAtArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestGetTxCountArgs(t *testing.T) {
    input := `["0x407d73d8a49eeb85d32cf465507dd71d507100c1", "pending"]`
    expected := new(GetTxCountArgs)
    expected.Address = "0x407d73d8a49eeb85d32cf465507dd71d507100c1"
    expected.BlockNumber = -2

    args := new(GetTxCountArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if expected.Address != args.Address {
        t.Errorf("Address shoud be %#v but is %#v", expected.Address, args.Address)
    }

    if expected.BlockNumber != args.BlockNumber {
        t.Errorf("BlockNumber shoud be %#v but is %#v", expected.BlockNumber, args.BlockNumber)
    }
}

func TestGetTxCountEmptyArgs(t *testing.T) {
    input := `[]`

    args := new(GetTxCountArgs)
    str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestGetTxCountEmptyArgsInvalid(t *testing.T) {
    input := `false`

    args := new(GetTxCountArgs)
    str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestGetTxCountAddressNotString(t *testing.T) {
    input := `[false, "pending"]`

    args := new(GetTxCountArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestGetTxCountBlockheightMissing(t *testing.T) {
    input := `["0x407d73d8a49eeb85d32cf465507dd71d507100c1"]`
    expected := new(GetTxCountArgs)
    expected.Address = "0x407d73d8a49eeb85d32cf465507dd71d507100c1"
    expected.BlockNumber = -1

    args := new(GetTxCountArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if expected.Address != args.Address {
        t.Errorf("Address shoud be %#v but is %#v", expected.Address, args.Address)
    }

    if expected.BlockNumber != args.BlockNumber {
        t.Errorf("BlockNumber shoud be %#v but is %#v", expected.BlockNumber, args.BlockNumber)
    }
}

func TestGetTxCountBlockheightInvalid(t *testing.T) {
    input := `["0x407d73d8a49eeb85d32cf465507dd71d507100c1", {}]`

    args := new(GetTxCountArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestGetDataArgs(t *testing.T) {
    input := `["0xd5677cf67b5aa051bb40496e68ad359eb97cfbf8", "latest"]`
    expected := new(GetDataArgs)
    expected.Address = "0xd5677cf67b5aa051bb40496e68ad359eb97cfbf8"
    expected.BlockNumber = -1

    args := new(GetDataArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if expected.Address != args.Address {
        t.Errorf("Address shoud be %#v but is %#v", expected.Address, args.Address)
    }

    if expected.BlockNumber != args.BlockNumber {
        t.Errorf("BlockNumber shoud be %#v but is %#v", expected.BlockNumber, args.BlockNumber)
    }
}

func TestGetDataArgsBlocknumMissing(t *testing.T) {
    input := `["0xd5677cf67b5aa051bb40496e68ad359eb97cfbf8"]`
    expected := new(GetDataArgs)
    expected.Address = "0xd5677cf67b5aa051bb40496e68ad359eb97cfbf8"
    expected.BlockNumber = -1

    args := new(GetDataArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if expected.Address != args.Address {
        t.Errorf("Address shoud be %#v but is %#v", expected.Address, args.Address)
    }

    if expected.BlockNumber != args.BlockNumber {
        t.Errorf("BlockNumber shoud be %#v but is %#v", expected.BlockNumber, args.BlockNumber)
    }
}

func TestGetDataArgsEmpty(t *testing.T) {
    input := `[]`

    args := new(GetDataArgs)
    str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestGetDataArgsInvalid(t *testing.T) {
    input := `{}`

    args := new(GetDataArgs)
    str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestGetDataArgsAddressNotString(t *testing.T) {
    input := `[12, "latest"]`

    args := new(GetDataArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestGetDataArgsBlocknumberNotString(t *testing.T) {
    input := `["0xd5677cf67b5aa051bb40496e68ad359eb97cfbf8", false]`

    args := new(GetDataArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestBlockFilterArgs(t *testing.T) {
    input := `[{
  "fromBlock": "0x1",
  "toBlock": "0x2",
  "limit": "0x3",
  "offset": "0x0",
  "address": "0xd5677cf67b5aa051bb40496e68ad359eb97cfbf8",
  "topics":
  [
    ["0xAA", "0xBB"],
    ["0xCC", "0xDD"]
  ]
  }]`

    expected := new(BlockFilterArgs)
    expected.Earliest = 1
    expected.Latest = 2
    expected.Max = 3
    expected.Skip = 0
    expected.Address = []string{"0xd5677cf67b5aa051bb40496e68ad359eb97cfbf8"}
    expected.Topics = [][]string{
        []string{"0xAA", "0xBB"},
        []string{"0xCC", "0xDD"},
    }

    args := new(BlockFilterArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if expected.Earliest != args.Earliest {
        t.Errorf("Earliest shoud be %#v but is %#v", expected.Earliest, args.Earliest)
    }

    if expected.Latest != args.Latest {
        t.Errorf("Latest shoud be %#v but is %#v", expected.Latest, args.Latest)
    }

    if expected.Max != args.Max {
        t.Errorf("Max shoud be %#v but is %#v", expected.Max, args.Max)
    }

    if expected.Skip != args.Skip {
        t.Errorf("Skip shoud be %#v but is %#v", expected.Skip, args.Skip)
    }

    if expected.Address[0] != args.Address[0] {
        t.Errorf("Address shoud be %#v but is %#v", expected.Address, args.Address)
    }

    if expected.Topics[0][0] != args.Topics[0][0] {
        t.Errorf("Topics shoud be %#v but is %#v", expected.Topics, args.Topics)
    }
    if expected.Topics[0][1] != args.Topics[0][1] {
        t.Errorf("Topics shoud be %#v but is %#v", expected.Topics, args.Topics)
    }
    if expected.Topics[1][0] != args.Topics[1][0] {
        t.Errorf("Topics shoud be %#v but is %#v", expected.Topics, args.Topics)
    }
    if expected.Topics[1][1] != args.Topics[1][1] {
        t.Errorf("Topics shoud be %#v but is %#v", expected.Topics, args.Topics)
    }

}

func TestBlockFilterArgsDefaults(t *testing.T) {
    input := `[{
  "address": ["0xd5677cf67b5aa051bb40496e68ad359eb97cfbf8"],
  "topics": ["0xAA","0xBB"]
  }]`
    expected := new(BlockFilterArgs)
    expected.Earliest = -1
    expected.Latest = -1
    expected.Max = 100
    expected.Skip = 0
    expected.Address = []string{"0xd5677cf67b5aa051bb40496e68ad359eb97cfbf8"}
    expected.Topics = [][]string{[]string{"0xAA"}, []string{"0xBB"}}

    args := new(BlockFilterArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if expected.Earliest != args.Earliest {
        t.Errorf("Earliest shoud be %#v but is %#v", expected.Earliest, args.Earliest)
    }

    if expected.Latest != args.Latest {
        t.Errorf("Latest shoud be %#v but is %#v", expected.Latest, args.Latest)
    }

    if expected.Max != args.Max {
        t.Errorf("Max shoud be %#v but is %#v", expected.Max, args.Max)
    }

    if expected.Skip != args.Skip {
        t.Errorf("Skip shoud be %#v but is %#v", expected.Skip, args.Skip)
    }

    if expected.Address[0] != args.Address[0] {
        t.Errorf("Address shoud be %#v but is %#v", expected.Address, args.Address)
    }

    if expected.Topics[0][0] != args.Topics[0][0] {
        t.Errorf("Topics shoud be %#v but is %#v", expected.Topics, args.Topics)
    }

    if expected.Topics[1][0] != args.Topics[1][0] {
        t.Errorf("Topics shoud be %#v but is %#v", expected.Topics, args.Topics)
    }
}

func TestBlockFilterArgsWords(t *testing.T) {
    input := `[{
  "fromBlock": "latest",
  "toBlock": "pending"
  }]`
    expected := new(BlockFilterArgs)
    expected.Earliest = -1
    expected.Latest = -2

    args := new(BlockFilterArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if expected.Earliest != args.Earliest {
        t.Errorf("Earliest shoud be %#v but is %#v", expected.Earliest, args.Earliest)
    }

    if expected.Latest != args.Latest {
        t.Errorf("Latest shoud be %#v but is %#v", expected.Latest, args.Latest)
    }
}

func TestBlockFilterArgsInvalid(t *testing.T) {
    input := `{}`

    args := new(BlockFilterArgs)
    str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestBlockFilterArgsFromBool(t *testing.T) {
    input := `[{
  "fromBlock": true,
  "toBlock": "pending"
  }]`

    args := new(BlockFilterArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestBlockFilterArgsToBool(t *testing.T) {
    input := `[{
  "fromBlock": "pending",
  "toBlock": true
  }]`

    args := new(BlockFilterArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestBlockFilterArgsEmptyArgs(t *testing.T) {
    input := `[]`

    args := new(BlockFilterArgs)
    err := json.Unmarshal([]byte(input), &args)
    if err == nil {
        t.Error("Expected error but didn't get one")
    }
}

func TestBlockFilterArgsLimitInvalid(t *testing.T) {
    input := `[{"limit": false}]`

    args := new(BlockFilterArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestBlockFilterArgsOffsetInvalid(t *testing.T) {
    input := `[{"offset": true}]`

    args := new(BlockFilterArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestBlockFilterArgsAddressInt(t *testing.T) {
    input := `[{
  "address": 1,
  "topics": "0x12341234"}]`

    args := new(BlockFilterArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestBlockFilterArgsAddressSliceInt(t *testing.T) {
    input := `[{
  "address": [1],
  "topics": "0x12341234"}]`

    args := new(BlockFilterArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestBlockFilterArgsTopicInt(t *testing.T) {
    input := `[{
  "address": ["0xd5677cf67b5aa051bb40496e68ad359eb97cfbf8"],
  "topics": 1}]`

    args := new(BlockFilterArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestBlockFilterArgsTopicSliceInt(t *testing.T) {
    input := `[{
  "address": "0xd5677cf67b5aa051bb40496e68ad359eb97cfbf8",
  "topics": [1]}]`

    args := new(BlockFilterArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestBlockFilterArgsTopicSliceInt2(t *testing.T) {
    input := `[{
  "address": "0xd5677cf67b5aa051bb40496e68ad359eb97cfbf8",
  "topics": ["0xAA", [1]]}]`

    args := new(BlockFilterArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestBlockFilterArgsTopicComplex(t *testing.T) {
    input := `[{
    "address": "0xd5677cf67b5aa051bb40496e68ad359eb97cfbf8",
  "topics": ["0xAA", ["0xBB", "0xCC"]]
  }]`

    args := new(BlockFilterArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
        fmt.Printf("%v\n", args)
        return
    }

    if args.Topics[0][0] != "0xAA" {
        t.Errorf("Topic should be %s but is %s", "0xAA", args.Topics[0][0])
    }

    if args.Topics[1][0] != "0xBB" {
        t.Errorf("Topic should be %s but is %s", "0xBB", args.Topics[0][0])
    }

    if args.Topics[1][1] != "0xCC" {
        t.Errorf("Topic should be %s but is %s", "0xCC", args.Topics[0][0])
    }
}

func TestDbArgs(t *testing.T) {
    input := `["testDB","myKey","0xbeef"]`
    expected := new(DbArgs)
    expected.Database = "testDB"
    expected.Key = "myKey"
    expected.Value = []byte("0xbeef")

    args := new(DbArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if err := args.requirements(); err != nil {
        t.Error(err)
    }

    if expected.Database != args.Database {
        t.Errorf("Database shoud be %#v but is %#v", expected.Database, args.Database)
    }

    if expected.Key != args.Key {
        t.Errorf("Key shoud be %#v but is %#v", expected.Key, args.Key)
    }

    if bytes.Compare(expected.Value, args.Value) != 0 {
        t.Errorf("Value shoud be %#v but is %#v", expected.Value, args.Value)
    }
}

func TestDbArgsInvalid(t *testing.T) {
    input := `{}`

    args := new(DbArgs)
    str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestDbArgsEmpty(t *testing.T) {
    input := `[]`

    args := new(DbArgs)
    str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestDbArgsDatabaseType(t *testing.T) {
    input := `[true, "keyval", "valval"]`

    args := new(DbArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestDbArgsKeyType(t *testing.T) {
    input := `["dbval", 3, "valval"]`

    args := new(DbArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestDbArgsValType(t *testing.T) {
    input := `["dbval", "keyval", {}]`

    args := new(DbArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestDbArgsDatabaseEmpty(t *testing.T) {
    input := `["", "keyval", "valval"]`

    args := new(DbArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err.Error())
    }

    str := ExpectValidationError(args.requirements())
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestDbArgsKeyEmpty(t *testing.T) {
    input := `["dbval", "", "valval"]`

    args := new(DbArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err.Error())
    }

    str := ExpectValidationError(args.requirements())
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestDbHexArgs(t *testing.T) {
    input := `["testDB","myKey","0xbeef"]`
    expected := new(DbHexArgs)
    expected.Database = "testDB"
    expected.Key = "myKey"
    expected.Value = []byte{0xbe, 0xef}

    args := new(DbHexArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if err := args.requirements(); err != nil {
        t.Error(err)
    }

    if expected.Database != args.Database {
        t.Errorf("Database shoud be %#v but is %#v", expected.Database, args.Database)
    }

    if expected.Key != args.Key {
        t.Errorf("Key shoud be %#v but is %#v", expected.Key, args.Key)
    }

    if bytes.Compare(expected.Value, args.Value) != 0 {
        t.Errorf("Value shoud be %#v but is %#v", expected.Value, args.Value)
    }
}

func TestDbHexArgsInvalid(t *testing.T) {
    input := `{}`

    args := new(DbHexArgs)
    str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestDbHexArgsEmpty(t *testing.T) {
    input := `[]`

    args := new(DbHexArgs)
    str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestDbHexArgsDatabaseType(t *testing.T) {
    input := `[true, "keyval", "valval"]`

    args := new(DbHexArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestDbHexArgsKeyType(t *testing.T) {
    input := `["dbval", 3, "valval"]`

    args := new(DbHexArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestDbHexArgsValType(t *testing.T) {
    input := `["dbval", "keyval", {}]`

    args := new(DbHexArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestDbHexArgsDatabaseEmpty(t *testing.T) {
    input := `["", "keyval", "valval"]`

    args := new(DbHexArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err.Error())
    }

    str := ExpectValidationError(args.requirements())
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestDbHexArgsKeyEmpty(t *testing.T) {
    input := `["dbval", "", "valval"]`

    args := new(DbHexArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err.Error())
    }

    str := ExpectValidationError(args.requirements())
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestWhisperMessageArgs(t *testing.T) {
    input := `[{"from":"0xc931d93e97ab07fe42d923478ba2465f2",
  "topics": ["0x68656c6c6f20776f726c64"],
  "payload":"0x68656c6c6f20776f726c64",
  "ttl": "0x64",
  "priority": "0x64"}]`
    expected := new(WhisperMessageArgs)
    expected.From = "0xc931d93e97ab07fe42d923478ba2465f2"
    expected.To = ""
    expected.Payload = "0x68656c6c6f20776f726c64"
    expected.Priority = 100
    expected.Ttl = 100
    // expected.Topics = []string{"0x68656c6c6f20776f726c64"}

    args := new(WhisperMessageArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if expected.From != args.From {
        t.Errorf("From shoud be %#v but is %#v", expected.From, args.From)
    }

    if expected.To != args.To {
        t.Errorf("To shoud be %#v but is %#v", expected.To, args.To)
    }

    if expected.Payload != args.Payload {
        t.Errorf("Value shoud be %#v but is %#v", expected.Payload, args.Payload)
    }

    if expected.Ttl != args.Ttl {
        t.Errorf("Ttl shoud be %#v but is %#v", expected.Ttl, args.Ttl)
    }

    if expected.Priority != args.Priority {
        t.Errorf("Priority shoud be %#v but is %#v", expected.Priority, args.Priority)
    }

    // if expected.Topics != args.Topics {
    //  t.Errorf("Topic shoud be %#v but is %#v", expected.Topic, args.Topic)
    // }
}

func TestWhisperMessageArgsInt(t *testing.T) {
    input := `[{"from":"0xc931d93e97ab07fe42d923478ba2465f2",
  "topics": ["0x68656c6c6f20776f726c64"],
  "payload":"0x68656c6c6f20776f726c64",
  "ttl": 12,
  "priority": 16}]`
    expected := new(WhisperMessageArgs)
    expected.From = "0xc931d93e97ab07fe42d923478ba2465f2"
    expected.To = ""
    expected.Payload = "0x68656c6c6f20776f726c64"
    expected.Priority = 16
    expected.Ttl = 12
    // expected.Topics = []string{"0x68656c6c6f20776f726c64"}

    args := new(WhisperMessageArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if expected.From != args.From {
        t.Errorf("From shoud be %#v but is %#v", expected.From, args.From)
    }

    if expected.To != args.To {
        t.Errorf("To shoud be %#v but is %#v", expected.To, args.To)
    }

    if expected.Payload != args.Payload {
        t.Errorf("Value shoud be %#v but is %#v", expected.Payload, args.Payload)
    }

    if expected.Ttl != args.Ttl {
        t.Errorf("Ttl shoud be %v but is %v", expected.Ttl, args.Ttl)
    }

    if expected.Priority != args.Priority {
        t.Errorf("Priority shoud be %v but is %v", expected.Priority, args.Priority)
    }

    // if expected.Topics != args.Topics {
    //  t.Errorf("Topic shoud be %#v but is %#v", expected.Topic, args.Topic)
    // }
}

func TestWhisperMessageArgsInvalid(t *testing.T) {
    input := `{}`

    args := new(WhisperMessageArgs)
    str := ExpectDecodeParamError(json.Unmarshal([]byte(input), args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestWhisperMessageArgsEmpty(t *testing.T) {
    input := `[]`

    args := new(WhisperMessageArgs)
    str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestWhisperMessageArgsTtlBool(t *testing.T) {
    input := `[{"from":"0xc931d93e97ab07fe42d923478ba2465f2",
  "topics": ["0x68656c6c6f20776f726c64"],
  "payload":"0x68656c6c6f20776f726c64",
  "ttl": true,
  "priority": "0x64"}]`
    args := new(WhisperMessageArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestWhisperMessageArgsPriorityBool(t *testing.T) {
    input := `[{"from":"0xc931d93e97ab07fe42d923478ba2465f2",
  "topics": ["0x68656c6c6f20776f726c64"],
  "payload":"0x68656c6c6f20776f726c64",
  "ttl": "0x12",
  "priority": true}]`
    args := new(WhisperMessageArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestFilterIdArgs(t *testing.T) {
    input := `["0x7"]`
    expected := new(FilterIdArgs)
    expected.Id = 7

    args := new(FilterIdArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if expected.Id != args.Id {
        t.Errorf("Id shoud be %#v but is %#v", expected.Id, args.Id)
    }
}

func TestFilterIdArgsInvalid(t *testing.T) {
    input := `{}`

    args := new(FilterIdArgs)
    str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Errorf(str)
    }
}

func TestFilterIdArgsEmpty(t *testing.T) {
    input := `[]`

    args := new(FilterIdArgs)
    str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Errorf(str)
    }
}

func TestFilterIdArgsBool(t *testing.T) {
    input := `[true]`

    args := new(FilterIdArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Errorf(str)
    }
}

func TestWhisperFilterArgs(t *testing.T) {
    input := `[{"topics": ["0x68656c6c6f20776f726c64"], "to": "0x34ag445g3455b34"}]`
    expected := new(WhisperFilterArgs)
    expected.To = "0x34ag445g3455b34"
    expected.Topics = [][]string{[]string{"0x68656c6c6f20776f726c64"}}

    args := new(WhisperFilterArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if expected.To != args.To {
        t.Errorf("To shoud be %#v but is %#v", expected.To, args.To)
    }

    // if expected.Topics != args.Topics {
    //  t.Errorf("Topics shoud be %#v but is %#v", expected.Topics, args.Topics)
    // }
}

func TestWhisperFilterArgsInvalid(t *testing.T) {
    input := `{}`

    args := new(WhisperFilterArgs)
    str := ExpectDecodeParamError(json.Unmarshal([]byte(input), args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestWhisperFilterArgsEmpty(t *testing.T) {
    input := `[]`

    args := new(WhisperFilterArgs)
    str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestWhisperFilterArgsToInt(t *testing.T) {
    input := `[{"to": 2}]`

    args := new(WhisperFilterArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestWhisperFilterArgsToBool(t *testing.T) {
    input := `[{"topics": ["0x68656c6c6f20776f726c64"], "to": false}]`

    args := new(WhisperFilterArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestWhisperFilterArgsToMissing(t *testing.T) {
    input := `[{"topics": ["0x68656c6c6f20776f726c64"]}]`
    expected := new(WhisperFilterArgs)
    expected.To = ""

    args := new(WhisperFilterArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if args.To != expected.To {
        t.Errorf("To shoud be %v but is %v", expected.To, args.To)
    }
}

func TestWhisperFilterArgsTopicInt(t *testing.T) {
    input := `[{"topics": [6], "to": "0x34ag445g3455b34"}]`

    args := new(WhisperFilterArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestCompileArgs(t *testing.T) {
    input := `["contract test { function multiply(uint a) returns(uint d) {   return a * 7;   } }"]`
    expected := new(CompileArgs)
    expected.Source = `contract test { function multiply(uint a) returns(uint d) {   return a * 7;   } }`

    args := new(CompileArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if expected.Source != args.Source {
        t.Errorf("Source shoud be %#v but is %#v", expected.Source, args.Source)
    }
}

func TestCompileArgsInvalid(t *testing.T) {
    input := `{}`

    args := new(CompileArgs)
    str := ExpectDecodeParamError(json.Unmarshal([]byte(input), args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestCompileArgsEmpty(t *testing.T) {
    input := `[]`

    args := new(CompileArgs)
    str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestCompileArgsBool(t *testing.T) {
    input := `[false]`

    args := new(CompileArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestFilterStringArgs(t *testing.T) {
    input := `["pending"]`
    expected := new(FilterStringArgs)
    expected.Word = "pending"

    args := new(FilterStringArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if expected.Word != args.Word {
        t.Errorf("Word shoud be %#v but is %#v", expected.Word, args.Word)
    }
}

func TestFilterStringEmptyArgs(t *testing.T) {
    input := `[]`

    args := new(FilterStringArgs)
    str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Errorf(str)
    }
}

func TestFilterStringInvalidArgs(t *testing.T) {
    input := `{}`

    args := new(FilterStringArgs)
    str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Errorf(str)
    }
}

func TestFilterStringWordInt(t *testing.T) {
    input := `[7]`

    args := new(FilterStringArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Errorf(str)
    }
}

func TestFilterStringWordWrong(t *testing.T) {
    input := `["foo"]`

    args := new(FilterStringArgs)
    str := ExpectValidationError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Errorf(str)
    }
}

func TestWhisperIdentityArgs(t *testing.T) {
    input := `["0xc931d93e97ab07fe42d923478ba2465f283"]`
    expected := new(WhisperIdentityArgs)
    expected.Identity = "0xc931d93e97ab07fe42d923478ba2465f283"

    args := new(WhisperIdentityArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if expected.Identity != args.Identity {
        t.Errorf("Identity shoud be %#v but is %#v", expected.Identity, args.Identity)
    }
}

func TestWhisperIdentityArgsInvalid(t *testing.T) {
    input := `{}`

    args := new(WhisperIdentityArgs)
    str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Errorf(str)
    }
}

func TestWhisperIdentityArgsEmpty(t *testing.T) {
    input := `[]`

    args := new(WhisperIdentityArgs)
    str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Errorf(str)
    }
}

func TestWhisperIdentityArgsInt(t *testing.T) {
    input := `[4]`

    args := new(WhisperIdentityArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Errorf(str)
    }
}

func TestBlockNumArgs(t *testing.T) {
    input := `["0x29a"]`
    expected := new(BlockNumIndexArgs)
    expected.BlockNumber = 666

    args := new(BlockNumArg)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if expected.BlockNumber != args.BlockNumber {
        t.Errorf("BlockNumber shoud be %#v but is %#v", expected.BlockNumber, args.BlockNumber)
    }
}

func TestBlockNumArgsWord(t *testing.T) {
    input := `["pending"]`
    expected := new(BlockNumIndexArgs)
    expected.BlockNumber = -2

    args := new(BlockNumArg)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if expected.BlockNumber != args.BlockNumber {
        t.Errorf("BlockNumber shoud be %#v but is %#v", expected.BlockNumber, args.BlockNumber)
    }
}

func TestBlockNumArgsInvalid(t *testing.T) {
    input := `{}`

    args := new(BlockNumArg)
    str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestBlockNumArgsEmpty(t *testing.T) {
    input := `[]`

    args := new(BlockNumArg)
    str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}
func TestBlockNumArgsBool(t *testing.T) {
    input := `[true]`

    args := new(BlockNumArg)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestBlockNumIndexArgs(t *testing.T) {
    input := `["0x29a", "0x0"]`
    expected := new(BlockNumIndexArgs)
    expected.BlockNumber = 666
    expected.Index = 0

    args := new(BlockNumIndexArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if expected.BlockNumber != args.BlockNumber {
        t.Errorf("BlockNumber shoud be %#v but is %#v", expected.BlockNumber, args.BlockNumber)
    }

    if expected.Index != args.Index {
        t.Errorf("Index shoud be %#v but is %#v", expected.Index, args.Index)
    }
}

func TestBlockNumIndexArgsWord(t *testing.T) {
    input := `["latest", 67]`
    expected := new(BlockNumIndexArgs)
    expected.BlockNumber = -1
    expected.Index = 67

    args := new(BlockNumIndexArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if expected.BlockNumber != args.BlockNumber {
        t.Errorf("BlockNumber shoud be %#v but is %#v", expected.BlockNumber, args.BlockNumber)
    }

    if expected.Index != args.Index {
        t.Errorf("Index shoud be %#v but is %#v", expected.Index, args.Index)
    }
}

func TestBlockNumIndexArgsEmpty(t *testing.T) {
    input := `[]`

    args := new(BlockNumIndexArgs)
    str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestBlockNumIndexArgsInvalid(t *testing.T) {
    input := `"foo"`

    args := new(BlockNumIndexArgs)
    str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestBlockNumIndexArgsBlocknumInvalid(t *testing.T) {
    input := `[{}, "0x1"]`

    args := new(BlockNumIndexArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestBlockNumIndexArgsIndexInvalid(t *testing.T) {
    input := `["0x29a", true]`

    args := new(BlockNumIndexArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestHashIndexArgs(t *testing.T) {
    input := `["0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b", "0x1"]`
    expected := new(HashIndexArgs)
    expected.Hash = "0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b"
    expected.Index = 1

    args := new(HashIndexArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if expected.Hash != args.Hash {
        t.Errorf("Hash shoud be %#v but is %#v", expected.Hash, args.Hash)
    }

    if expected.Index != args.Index {
        t.Errorf("Index shoud be %#v but is %#v", expected.Index, args.Index)
    }
}

func TestHashIndexArgsEmpty(t *testing.T) {
    input := `[]`

    args := new(HashIndexArgs)
    str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestHashIndexArgsInvalid(t *testing.T) {
    input := `{}`

    args := new(HashIndexArgs)
    str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestHashIndexArgsInvalidHash(t *testing.T) {
    input := `[7, "0x1"]`

    args := new(HashIndexArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestHashIndexArgsInvalidIndex(t *testing.T) {
    input := `["0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b", false]`

    args := new(HashIndexArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestHashArgs(t *testing.T) {
    input := `["0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b"]`
    expected := new(HashIndexArgs)
    expected.Hash = "0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b"

    args := new(HashArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if expected.Hash != args.Hash {
        t.Errorf("Hash shoud be %#v but is %#v", expected.Hash, args.Hash)
    }
}

func TestHashArgsEmpty(t *testing.T) {
    input := `[]`

    args := new(HashArgs)
    str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestHashArgsInvalid(t *testing.T) {
    input := `{}`

    args := new(HashArgs)
    str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestHashArgsInvalidHash(t *testing.T) {
    input := `[7]`

    args := new(HashArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestSubmitWorkArgs(t *testing.T) {
    input := `["0x0000000000000001", "0x1234567890abcdef1234567890abcdef", "0xD1GE5700000000000000000000000000"]`
    expected := new(SubmitWorkArgs)
    expected.Nonce = 1
    expected.Header = "0x1234567890abcdef1234567890abcdef"
    expected.Digest = "0xD1GE5700000000000000000000000000"

    args := new(SubmitWorkArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if expected.Nonce != args.Nonce {
        t.Errorf("Nonce shoud be %d but is %d", expected.Nonce, args.Nonce)
    }

    if expected.Header != args.Header {
        t.Errorf("Header shoud be %#v but is %#v", expected.Header, args.Header)
    }

    if expected.Digest != args.Digest {
        t.Errorf("Digest shoud be %#v but is %#v", expected.Digest, args.Digest)
    }
}

func TestSubmitWorkArgsInvalid(t *testing.T) {
    input := `{}`

    args := new(SubmitWorkArgs)
    str := ExpectDecodeParamError(json.Unmarshal([]byte(input), args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestSubmitWorkArgsEmpty(t *testing.T) {
    input := `[]`

    args := new(SubmitWorkArgs)
    str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestSubmitWorkArgsNonceInt(t *testing.T) {
    input := `[1, "0x1234567890abcdef1234567890abcdef", "0xD1GE5700000000000000000000000000"]`

    args := new(SubmitWorkArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), args))
    if len(str) > 0 {
        t.Error(str)
    }
}
func TestSubmitWorkArgsHeaderInt(t *testing.T) {
    input := `["0x0000000000000001", 1, "0xD1GE5700000000000000000000000000"]`

    args := new(SubmitWorkArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), args))
    if len(str) > 0 {
        t.Error(str)
    }
}
func TestSubmitWorkArgsDigestInt(t *testing.T) {
    input := `["0x0000000000000001", "0x1234567890abcdef1234567890abcdef", 1]`

    args := new(SubmitWorkArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestBlockHeightFromJsonInvalid(t *testing.T) {
    var num int64
    var msg json.RawMessage = []byte(`}{`)
    str := ExpectDecodeParamError(blockHeightFromJson(msg, &num))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestSourceArgsEmpty(t *testing.T) {
    input := `[]`

    args := new(SourceArgs)
    str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestSigArgs(t *testing.T) {
    input := `["0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", "0x0"]`
    expected := new(NewSigArgs)
    expected.From = "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b"
    expected.Data = "0x0"

    args := new(NewSigArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if expected.From != args.From {
        t.Errorf("From should be %v but is %v", expected.From, args.From)
    }

    if expected.Data != args.Data {
        t.Errorf("Data should be %v but is %v", expected.Data, args.Data)
    }
}

func TestSigArgsEmptyData(t *testing.T) {
    input := `["0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", ""]`

    args := new(NewSigArgs)
    str := ExpectValidationError(json.Unmarshal([]byte(input), args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestSigArgsDataType(t *testing.T) {
    input := `["0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", 13]`

    args := new(NewSigArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestSigArgsEmptyFrom(t *testing.T) {
    input := `["", "0x0"]`

    args := new(NewSigArgs)
    str := ExpectValidationError(json.Unmarshal([]byte(input), args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestSigArgsFromType(t *testing.T) {
    input := `[false, "0x0"]`

    args := new(NewSigArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestSigArgsEmpty(t *testing.T) {
    input := `[]`
    args := new(NewSigArgs)
    str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestDataArgs(t *testing.T) {
    input := `["0x0123"]`
    expected := new(NewDataArgs)
    expected.Data = "0x0123"

    args := new(NewDataArgs)
    if err := json.Unmarshal([]byte(input), &args); err != nil {
        t.Error(err)
    }

    if expected.Data != args.Data {
        t.Errorf("Data should be %v but is %v", expected.Data, args.Data)
    }
}

func TestDataArgsEmptyData(t *testing.T) {
    input := `[""]`

    args := new(NewDataArgs)
    str := ExpectValidationError(json.Unmarshal([]byte(input), args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestDataArgsDataType(t *testing.T) {
    input := `[13]`

    args := new(NewDataArgs)
    str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestDataArgsEmpty(t *testing.T) {
    input := `[]`
    args := new(NewDataArgs)
    str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), args))
    if len(str) > 0 {
        t.Error(str)
    }
}

func TestDataArgsInvalid(t *testing.T) {
    input := `{}`

    args := new(NewDataArgs)
    str := ExpectDecodeParamError(json.Unmarshal([]byte(input), args))
    if len(str) > 0 {
        t.Error(str)
    }
}