github.com/sixexorg/magnetic-ring@v0.0.0-20191119090307-31705a21e419/common/sink/complex_test.go (about)

     1  package sink_test
     2  
     3  import (
     4  	"math/big"
     5  	"testing"
     6  
     7  	"bytes"
     8  
     9  	"github.com/stretchr/testify/assert"
    10  	"github.com/sixexorg/magnetic-ring/common"
    11  	"github.com/sixexorg/magnetic-ring/common/sink"
    12  )
    13  
    14  func TestBigIntToComplex(t *testing.T) {
    15  	a1, _ := big.NewInt(0).SetString("213000000001230000000000000022222222222", 10)
    16  	cp, err := sink.BigIntToComplex(a1)
    17  	if err != nil {
    18  		t.Error(err)
    19  		t.Fail()
    20  		return
    21  	}
    22  
    23  	a2, err := cp.ComplexToBigInt()
    24  	if err != nil {
    25  		t.Error(err)
    26  		t.Fail()
    27  		return
    28  	}
    29  	assert.Equal(t, a1, a2)
    30  }
    31  
    32  func TestTxAmountsToComplex(t *testing.T) {
    33  
    34  	Address_1, _ := common.ToAddress("ct1qK96vAkK6E8S7JgYUY3YY28Qhj6cmfdy")
    35  	Address_2, _ := common.ToAddress("ct1qK96vAkK6E8S7JgYUY3YY28Qhj6cmfdz")
    36  	tos := &common.TxOuts{}
    37  	tos.Tos = append(tos.Tos,
    38  		&common.TxOut{
    39  			Address: Address_1,
    40  			Amount:  big.NewInt(200),
    41  		},
    42  		&common.TxOut{
    43  			Address: Address_2,
    44  			Amount:  big.NewInt(300),
    45  		},
    46  	)
    47  
    48  	cp, err := sink.TxOutsToComplex(tos)
    49  	if err != nil {
    50  		t.Error(err)
    51  		t.Fail()
    52  		return
    53  	}
    54  	txa, err := cp.ComplexToTxOuts()
    55  	if err != nil {
    56  		t.Error(err)
    57  		t.Fail()
    58  		return
    59  	}
    60  	assert.Equal(t, txa, tos)
    61  
    62  }
    63  
    64  func TestBytesToComplex(t *testing.T) {
    65  	buff := bytes.NewBuffer(nil)
    66  	buff.WriteString("hello world")
    67  	bytes := buff.Bytes()
    68  	cp, err := sink.BytesToComplex(bytes)
    69  	if err != nil {
    70  		t.Error(err)
    71  		t.Fail()
    72  		return
    73  	}
    74  	txa, err := cp.ComplexToBytes()
    75  	if err != nil {
    76  		t.Error(err)
    77  		t.Fail()
    78  		return
    79  	}
    80  	assert.Equal(t, txa, bytes)
    81  }
    82  func TestHashArrayToComplex(t *testing.T) {
    83  	ha := common.HashArray{common.Hash{1, 2, 3}, common.Hash{3, 4, 5}, common.Hash{5, 6, 7}}
    84  	cp, err := sink.HashArrayToComplex(ha)
    85  	if err != nil {
    86  		t.Error(err)
    87  		t.Fail()
    88  		return
    89  	}
    90  	ha2, err := cp.ComplexToHashArray()
    91  	if err != nil {
    92  		t.Error(err)
    93  		t.Fail()
    94  		return
    95  	}
    96  	assert.Equal(t, ha, ha2)
    97  }
    98  
    99  func TestBytesArrToComplex(t *testing.T) {
   100  	bs := common.SigBuf{{1, 2, 3}, {4, 5, 6}}
   101  	cp, err := sink.SigBufToComplex(bs)
   102  	if err != nil {
   103  		t.Error(err)
   104  		t.Fail()
   105  		return
   106  	}
   107  	bs2, err := cp.ComplexToSigBuf()
   108  	if err != nil {
   109  		t.Error(err)
   110  		t.Fail()
   111  		return
   112  	}
   113  	assert.Equal(t, bs, bs2)
   114  }
   115  
   116  func TestUintptr(t *testing.T) {
   117  	a, _ := big.NewInt(0).SetString("98091100000000000000000002222312312312310000000000000000000022223123123123100000000000000000000222231231231231000000000000000000002222312312312310000000000000000000022223123123123100000000000000000000222231231231231000000000000000000002222312312312310000000000000000000022223123123123100000000000000000000222231231231231000000000000000000002222312312312310000000000000000000022223123123123100000000000000000000222231231231231000000000000000000002222312312312310000000000000000000022223123123123100000000000000000000222231231231231000000000000000000002222312312312310000000000000000000022223123123123100000000000000000000222231231231231000000000000000000002222312312312310000000000000000000022223123123123100000000000000000000222231231231231000000000000000000002222312312312310000000000000000000022223123123123100000000000000000000222231231231231230000000002000000000000000000000222231231231231230000000002000000000000000000000222231231231231230000000002000000000000000000000222231231231231230000000002000000000000000000000222231231231231230000000002000000000000000000000222231231231231230000000002000000000000000000000222231231231231230000000002000000000000000000000222231231231231230000000002000000000000000000000222231231231231230000000002000000000000000000000222231231231231230000000000000000000000000000000000000000000000000000000000", 10)
   118  	t.Log(a.BitLen())
   119  	t.Log(len(a.Bytes()))
   120  
   121  }
   122  func TestUint16Check(t *testing.T) {
   123  	uint16Max := ^uint16(0)
   124  	t.Log(int(uint16Max))
   125  	t.Log(^uint16(0))
   126  
   127  }