github.com/mit-dci/lit@v0.0.0-20221102210550-8c3d3b49f2ce/elkrem/elkrem_test.go (about)

     1  package elkrem
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/mit-dci/lit/btcutil/chaincfg/chainhash"
     7  )
     8  
     9  // TestElkremBig tries 10K hashes
    10  func TestElkremBig(t *testing.T) {
    11  	sndr := NewElkremSender(chainhash.DoubleHashH([]byte("elktest")))
    12  	var rcv ElkremReceiver
    13  	//	SenderSerdesTest(t, sndr)
    14  	for n := uint64(0); n < 10000; n++ {
    15  		sha, err := sndr.AtIndex(n)
    16  		if err != nil {
    17  			t.Fatal(err)
    18  		}
    19  		err = rcv.AddNext(sha)
    20  		if err != nil {
    21  			t.Fatal(err)
    22  		}
    23  		if n%1000 == 999 {
    24  			t.Logf("stack with %d received hashes\n", n+1)
    25  			for i, n := range rcv.Nodes {
    26  				t.Logf("Stack element %d: index %d height %d %s\n",
    27  					i, n.I, n.H, n.Sha.String())
    28  			}
    29  		}
    30  	}
    31  	//	SenderSerdesTest(t, sndr)
    32  	ReceiverSerdesTest(t, &rcv)
    33  	for n := uint64(0); n < 10000; n += 500 {
    34  		sha, err := rcv.AtIndex(n)
    35  		if err != nil {
    36  			t.Fatal(err)
    37  		}
    38  		t.Logf("Retreived index %d %s\n", n, sha.String())
    39  	}
    40  }
    41  
    42  // TestElkremLess tries 10K hashes
    43  func TestElkremLess(t *testing.T) {
    44  	sndr := NewElkremSender(chainhash.DoubleHashH([]byte("elktest2")))
    45  	var rcv ElkremReceiver
    46  	for n := uint64(0); n < 5000; n++ {
    47  		sha, err := sndr.AtIndex(n)
    48  		if err != nil {
    49  			t.Fatal(err)
    50  		}
    51  		err = rcv.AddNext(sha)
    52  		if err != nil {
    53  			t.Fatal(err)
    54  		}
    55  		if n%1000 == 999 {
    56  			t.Logf("stack with %d received hashes\n", n+1)
    57  			for i, n := range rcv.Nodes {
    58  				t.Logf("Stack element %d: index %d height %d %s\n",
    59  					i, n.I, n.H, n.Sha.String())
    60  			}
    61  		}
    62  	}
    63  	for n := uint64(0); n < 5000; n += 500 {
    64  		sha, err := rcv.AtIndex(n)
    65  		if err != nil {
    66  			t.Fatal(err)
    67  		}
    68  		t.Logf("Retreived index %d %s\n",
    69  			n, sha.String())
    70  	}
    71  }
    72  
    73  // TestElkremIngestLeftFail puts a bed hash in such that the left child will fail
    74  func TestElkremIngestLeftFail(t *testing.T) {
    75  	sndr := NewElkremSender(chainhash.DoubleHashH([]byte("elkfailL")))
    76  	var rcv ElkremReceiver
    77  	for n := uint64(0); n < 31; n++ {
    78  		sha, err := sndr.AtIndex(n)
    79  		if err != nil {
    80  			t.Fatal(err)
    81  		}
    82  		err = rcv.AddNext(sha)
    83  		if err != nil {
    84  			t.Fatal(err)
    85  		}
    86  	}
    87  
    88  	// This is correct but we can't check; anything will be accepted
    89  	sha, err := sndr.AtIndex(31)
    90  	if err != nil {
    91  		t.Fatal(err)
    92  	}
    93  	// flip all the bits in the first byte
    94  	sha[0] ^= 0xff
    95  	err = rcv.AddNext(sha)
    96  	if err != nil {
    97  		t.Fatal(err)
    98  	}
    99  	// give the right thing here, but it's too late as 31 was wrong
   100  	sha, err = sndr.AtIndex(32)
   101  	if err != nil {
   102  		t.Fatal(err)
   103  	}
   104  
   105  	err = rcv.AddNext(sha)
   106  	if err != nil {
   107  		t.Fatal(err)
   108  	}
   109  	sha, err = sndr.AtIndex(33)
   110  	if err != nil {
   111  		t.Fatal(err)
   112  	}
   113  	err = rcv.AddNext(sha)
   114  	if err == nil {
   115  		t.Fatalf("Should have a left child mismatch, but everything went OK!")
   116  	}
   117  }
   118  
   119  // TestElkremIngestRightFail puts a bed hash in such that the left child will fail
   120  func TestElkremIngestRightFail(t *testing.T) {
   121  	sndr := NewElkremSender(chainhash.DoubleHashH([]byte("elkfailR")))
   122  	var rcv ElkremReceiver
   123  	for n := uint64(0); n < 31; n++ {
   124  		sha, err := sndr.AtIndex(n)
   125  		if err != nil {
   126  			t.Fatal(err)
   127  		}
   128  		err = rcv.AddNext(sha)
   129  		if err != nil {
   130  			t.Fatal(err)
   131  		}
   132  	}
   133  
   134  	// This is correct but we can't check; anything will be accepted
   135  	sha, err := sndr.AtIndex(31)
   136  	if err != nil {
   137  		t.Fatal(err)
   138  	}
   139  	err = rcv.AddNext(sha)
   140  	if err != nil {
   141  		t.Fatal(err)
   142  	}
   143  	sha, err = sndr.AtIndex(32)
   144  	if err != nil {
   145  		t.Fatal(err)
   146  	}
   147  	// flip all the bits in the first byte
   148  	sha[0] ^= 0xff
   149  	err = rcv.AddNext(sha)
   150  	if err != nil {
   151  		t.Fatal(err)
   152  	}
   153  	sha, err = sndr.AtIndex(33)
   154  	if err != nil {
   155  		t.Fatal(err)
   156  	}
   157  	err = rcv.AddNext(sha)
   158  	if err == nil {
   159  		t.Fatalf("Should have a right child mismatch, but everything went OK!")
   160  	}
   161  }
   162  
   163  func TestFixed(t *testing.T) {
   164  	root, _ := chainhash.NewHashFromStr(
   165  		"b43614f251760d689adf84211148a40d7dee13967b7109e13c8d1437a4966d58")
   166  
   167  	sndr := NewElkremSender(*root)
   168  
   169  	zero, _ := chainhash.NewHashFromStr(
   170  		"2a124935e0713149b71ff17cb43465e9828bacd1e833f0dc08460783a6a42cb4")
   171  
   172  	thousand, _ := chainhash.NewHashFromStr(
   173  		"0151a39169940cdd8ccf1ba619f254ddbf16ce260a243528839b2634eaa63d0a")
   174  
   175  	for n := uint64(0); n < 5000; n += 500 {
   176  		sha, err := sndr.AtIndex(n)
   177  		if err != nil {
   178  			t.Fatal(err)
   179  		}
   180  		t.Logf("elk %d: %s\n", n, sha.String())
   181  
   182  		if n == 0 && !sha.IsEqual(zero) {
   183  			t.Fatalf("Elk %d expected %s, got %s", n, zero.String(), sha.String())
   184  		}
   185  		if n == 1000 && !sha.IsEqual(thousand) {
   186  			t.Fatalf("Elk %d expected %s, got %s", n, thousand.String(), sha.String())
   187  		}
   188  
   189  	}
   190  
   191  }