github.com/piotrnar/gocoin@v0.0.0-20240512203912-faa0448c5e96/lib/utxo/unspent_test.go (about)

     1  package utxo
     2  
     3  import (
     4  	"bytes"
     5  	"testing"
     6  	"github.com/piotrnar/gocoin/lib/btc"
     7  	"encoding/hex"
     8  )
     9  
    10  const (
    11  	UtxoRecord = "B26B877AF9D16E5F634C4997A8393C9496BAA14C34D73829767723D96D4AE368FE19AC0700060100166A146F6D6E69000000000000001F0000008B3B93DC0002FD22021976A914A25DEC4D0011064EF106A983C39C7A540699F22088AC"
    12  	//UtxoRecord = "875207AE844E25A60BB57C7E68FDEA8C3BD04FBF678866EF3E7E9FDD408B9E98FEF07A06000401FD60EA17A914379238E99325F2BD2D1F773B8D95CFB9EA92C31887"
    13  )
    14  
    15  func TestFullUtxoRec(t *testing.T) {
    16  	raw, _ := hex.DecodeString(UtxoRecord)
    17  	rec := FullUtxoRec(raw)
    18  	if rec == nil {
    19  		t.Error("nil returned")
    20  	}
    21  	refid := btc.NewUint256FromString("68e34a6dd92377762938d7344ca1ba96943c39a897494c635f6ed1f97a876bb2")
    22  	txid := btc.NewUint256(rec.TxID[:])
    23  	if !refid.Equal(txid) {
    24  		t.Error("TxID mismatch")
    25  	}
    26  	if rec.Coinbase {
    27  		t.Error("Coibase mismatch")
    28  	}
    29  	if rec.InBlock != 502809 {
    30  		t.Error("InBlock mismatch")
    31  	}
    32  	if len(rec.Outs) != 3 {
    33  		t.Error("Outs count mismatch")
    34  	}
    35  	if rec.Outs[0] != nil {
    36  		t.Error("Outs[0] not nil")
    37  	}
    38  	if rec.Outs[1] == nil {
    39  		t.Error("Outs[1] is nil")
    40  	}
    41  	if rec.Outs[1].Value != 0 {
    42  		t.Error("Outs[1] bad value")
    43  	}
    44  	if len(rec.Outs[1].PKScr) != 22 {
    45  		t.Error("Outs[1] bad script")
    46  	}
    47  	if rec.Outs[2].Value != 546 {
    48  		t.Error("Outs[2] bad value")
    49  	}
    50  	if len(rec.Outs[2].PKScr) != 25 {
    51  		t.Error("Outs[2] bad script")
    52  	}
    53  	if !bytes.Equal(raw, Serialize(rec, true, nil)) {
    54  		t.Error("Serialize error")
    55  	}
    56  }
    57  
    58  func BenchmarkFullUtxoRec(b *testing.B) {
    59  	raw, _ := hex.DecodeString(UtxoRecord)
    60  	b.ResetTimer()
    61  	for i := 0; i < b.N; i++ {
    62  		if FullUtxoRec(raw) == nil {
    63  			b.Fatal("Nil pointer returned")
    64  		}
    65  	}
    66  }
    67  
    68  
    69  func BenchmarkNewUtxoRec(b *testing.B) {
    70  	raw, _ := hex.DecodeString(UtxoRecord)
    71  	var key UtxoKeyType
    72  	copy(key[:], raw[:])
    73  	dat := raw[UtxoIdxLen:]
    74  	b.ResetTimer()
    75  	for i := 0; i < b.N; i++ {
    76  		if NewUtxoRec(key, dat) == nil {
    77  			b.Fatal("Nil pointer returned")
    78  		}
    79  	}
    80  }
    81  
    82  
    83  func BenchmarkNewUtxoRecStatic(b *testing.B) {
    84  	raw, _ := hex.DecodeString(UtxoRecord)
    85  	var key UtxoKeyType
    86  	copy(key[:], raw[:])
    87  	dat := raw[UtxoIdxLen:]
    88  	b.ResetTimer()
    89  	for i := 0; i < b.N; i++ {
    90  		if NewUtxoRecStatic(key, dat) == nil {
    91  			b.Fatal("Nil pointer returned")
    92  		}
    93  	}
    94  }
    95  
    96  
    97  func BenchmarkSerialize(b *testing.B) {
    98  	raw, _ := hex.DecodeString(UtxoRecord)
    99  	var key UtxoKeyType
   100  	var buf [0x100000]byte
   101  	copy(key[:], raw[:])
   102  	dat := raw[UtxoIdxLen:]
   103  	rec := NewUtxoRecStatic(key, dat)
   104  	b.ResetTimer()
   105  	for i := 0; i < b.N; i++ {
   106  		if Serialize(rec, false, buf[:]) == nil {
   107  			b.Fatal("Nil pointer returned")
   108  		}
   109  	}
   110  }
   111  
   112  
   113  func BenchmarkSerializeFull(b *testing.B) {
   114  	raw, _ := hex.DecodeString(UtxoRecord)
   115  	var key UtxoKeyType
   116  	var buf [0x100000]byte
   117  	copy(key[:], raw[:])
   118  	dat := raw[UtxoIdxLen:]
   119  	rec := NewUtxoRecStatic(key, dat)
   120  	b.ResetTimer()
   121  	for i := 0; i < b.N; i++ {
   122  		if Serialize(rec, false, buf[:]) == nil {
   123  			b.Fatal("Nil pointer returned")
   124  		}
   125  	}
   126  }
   127  
   128  
   129  func BenchmarkSerializeWithAlloc(b *testing.B) {
   130  	raw, _ := hex.DecodeString(UtxoRecord)
   131  	var key UtxoKeyType
   132  	copy(key[:], raw[:])
   133  	dat := raw[UtxoIdxLen:]
   134  	rec := NewUtxoRecStatic(key, dat)
   135  	b.ResetTimer()
   136  	for i := 0; i < b.N; i++ {
   137  		if Serialize(rec, false, nil) == nil {
   138  			b.Fatal("Nil pointer returned")
   139  		}
   140  	}
   141  }
   142  
   143  
   144  func BenchmarkSerializeCompress(b *testing.B) {
   145  	raw, _ := hex.DecodeString(UtxoRecord)
   146  	var key UtxoKeyType
   147  	var buf [0x100000]byte
   148  	copy(key[:], raw[:])
   149  	dat := raw[UtxoIdxLen:]
   150  	rec := NewUtxoRecStatic(key, dat)
   151  	SerializeC(rec, false, buf[:]) // serialize once to allocate the pools
   152  	b.ResetTimer()
   153  	for i := 0; i < b.N; i++ {
   154  		if SerializeC(rec, false, buf[:]) == nil {
   155  			b.Fatal("Nil pointer returned")
   156  		}
   157  	}
   158  }
   159  
   160  
   161  func BenchmarkSerializeCompressWithAlloc(b *testing.B) {
   162  	raw, _ := hex.DecodeString(UtxoRecord)
   163  	var key UtxoKeyType
   164  	copy(key[:], raw[:])
   165  	dat := raw[UtxoIdxLen:]
   166  	rec := NewUtxoRecStatic(key, dat)
   167  	SerializeC(rec, false, nil) // serialize once to allocate the pools
   168  	b.ResetTimer()
   169  	for i := 0; i < b.N; i++ {
   170  		if SerializeC(rec, false, nil) == nil {
   171  			b.Fatal("Nil pointer returned")
   172  		}
   173  	}
   174  }