You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

104 lines
3.0 KiB

package main
import (
"crypto/sha256"
"encoding/hex"
"encoding/json"
"fmt"
"os"
"testing"
"time"
"github.com/pkg/errors"
"github.com/stretchr/testify/require"
)
// This test tests that the output of generate tx and update tx is consistent
func TestGenerateTxUpdateTxConsistentency(t *testing.T) {
cases := []struct {
connIndex int
startingTxNumber int
txSize int
hostname string
numTxsToTest int
}{
{0, 0, 40, "localhost:26657", 1000},
{70, 300, 10000, "localhost:26657", 1000},
{0, 50, 100000, "localhost:26657", 1000},
}
for tcIndex, tc := range cases {
hostnameHash := sha256.Sum256([]byte(tc.hostname))
// Tx generated from update tx. This is defined outside of the loop, since we have
// to a have something initially to update
updatedTx := generateTx(tc.connIndex, tc.startingTxNumber, tc.txSize, hostnameHash)
updatedHex := make([]byte, len(updatedTx)*2)
hex.Encode(updatedHex, updatedTx)
for i := 0; i < tc.numTxsToTest; i++ {
expectedTx := generateTx(tc.connIndex, tc.startingTxNumber+i, tc.txSize, hostnameHash)
expectedHex := make([]byte, len(expectedTx)*2)
hex.Encode(expectedHex, expectedTx)
updateTx(updatedTx, updatedHex, tc.startingTxNumber+i)
// after first 32 bytes is 8 bytes of time, then purely random bytes
require.Equal(t, expectedTx[:32], updatedTx[:32],
"First 32 bytes of the txs differed. tc #%d, i #%d", tcIndex, i)
require.Equal(t, expectedHex[:64], updatedHex[:64],
"First 64 bytes of the hex differed. tc #%d, i #%d", tcIndex, i)
// Test the lengths of the txs are as expected
require.Equal(t, tc.txSize, len(expectedTx),
"Length of expected Tx differed. tc #%d, i #%d", tcIndex, i)
require.Equal(t, tc.txSize, len(updatedTx),
"Length of expected Tx differed. tc #%d, i #%d", tcIndex, i)
require.Equal(t, tc.txSize*2, len(expectedHex),
"Length of expected hex differed. tc #%d, i #%d", tcIndex, i)
require.Equal(t, tc.txSize*2, len(updatedHex),
"Length of updated hex differed. tc #%d, i #%d", tcIndex, i)
}
}
}
func BenchmarkIterationOfSendLoop(b *testing.B) {
var (
connIndex = 0
txSize = 25000
)
now := time.Now()
// something too far away to matter
endTime := now.Add(time.Hour)
txNumber := 0
hostnameHash := sha256.Sum256([]byte{0})
tx := generateTx(connIndex, txNumber, txSize, hostnameHash)
txHex := make([]byte, len(tx)*2)
hex.Encode(txHex, tx)
b.ResetTimer()
for i := 0; i < b.N; i++ {
updateTx(tx, txHex, txNumber)
paramsJSON, err := json.Marshal(map[string]interface{}{"tx": txHex})
if err != nil {
fmt.Printf("failed to encode params: %v\n", err)
os.Exit(1)
}
_ = json.RawMessage(paramsJSON)
_ = now.Add(sendTimeout)
if err != nil {
err = errors.Wrap(err,
fmt.Sprintf("txs send failed on connection #%d", connIndex))
logger.Error(err.Error())
return
}
// Cache the now operations
if i%5 == 0 {
now = time.Now()
if now.After(endTime) {
break
}
}
txNumber++
}
}