2018-07-16 18:25:15 -07:00
|
|
|
package simulation
|
2018-07-16 18:15:50 -07:00
|
|
|
|
|
|
|
import (
|
2018-07-17 16:27:51 -07:00
|
|
|
"fmt"
|
2018-07-16 18:15:50 -07:00
|
|
|
"math/rand"
|
2018-09-11 02:18:58 -07:00
|
|
|
"os"
|
2018-08-16 08:36:15 -07:00
|
|
|
"sort"
|
2018-09-09 08:34:09 -07:00
|
|
|
"strings"
|
|
|
|
"testing"
|
2018-09-11 02:18:58 -07:00
|
|
|
"time"
|
2018-07-18 23:47:54 -07:00
|
|
|
|
2018-10-26 04:42:53 -07:00
|
|
|
abci "github.com/tendermint/tendermint/abci/types"
|
2018-09-22 20:20:53 -07:00
|
|
|
"github.com/tendermint/tendermint/crypto/ed25519"
|
|
|
|
"github.com/tendermint/tendermint/crypto/secp256k1"
|
2018-07-18 23:47:54 -07:00
|
|
|
|
2018-09-09 08:34:09 -07:00
|
|
|
"github.com/cosmos/cosmos-sdk/baseapp"
|
2018-07-18 23:47:54 -07:00
|
|
|
sdk "github.com/cosmos/cosmos-sdk/types"
|
2018-09-22 20:20:53 -07:00
|
|
|
"github.com/cosmos/cosmos-sdk/x/mock"
|
2018-07-16 18:15:50 -07:00
|
|
|
)
|
|
|
|
|
|
|
|
// shamelessly copied from https://stackoverflow.com/questions/22892120/how-to-generate-a-random-string-of-a-fixed-length-in-golang#31832326
|
2018-07-17 22:37:38 -07:00
|
|
|
// TODO we should probably move this to tendermint/libs/common/random.go
|
2018-07-16 18:15:50 -07:00
|
|
|
|
|
|
|
const letterBytes = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
|
|
|
|
const (
|
|
|
|
letterIdxBits = 6 // 6 bits to represent a letter index
|
|
|
|
letterIdxMask = 1<<letterIdxBits - 1 // All 1-bits, as many as letterIdxBits
|
|
|
|
letterIdxMax = 63 / letterIdxBits // # of letter indices fitting in 63 bits
|
|
|
|
)
|
|
|
|
|
2018-07-17 22:50:04 -07:00
|
|
|
// Generate a random string of a particular length
|
2018-07-16 18:15:50 -07:00
|
|
|
func RandStringOfLength(r *rand.Rand, n int) string {
|
|
|
|
b := make([]byte, n)
|
|
|
|
// A src.Int63() generates 63 random bits, enough for letterIdxMax characters!
|
|
|
|
for i, cache, remain := n-1, r.Int63(), letterIdxMax; i >= 0; {
|
|
|
|
if remain == 0 {
|
|
|
|
cache, remain = r.Int63(), letterIdxMax
|
|
|
|
}
|
|
|
|
if idx := int(cache & letterIdxMask); idx < len(letterBytes) {
|
|
|
|
b[i] = letterBytes[idx]
|
|
|
|
i--
|
|
|
|
}
|
|
|
|
cache >>= letterIdxBits
|
|
|
|
remain--
|
|
|
|
}
|
|
|
|
return string(b)
|
|
|
|
}
|
2018-07-17 16:27:51 -07:00
|
|
|
|
2018-07-17 22:50:04 -07:00
|
|
|
// Pretty-print events as a table
|
2018-07-17 16:27:51 -07:00
|
|
|
func DisplayEvents(events map[string]uint) {
|
2018-08-16 08:36:15 -07:00
|
|
|
var keys []string
|
|
|
|
for key := range events {
|
|
|
|
keys = append(keys, key)
|
|
|
|
}
|
|
|
|
sort.Strings(keys)
|
|
|
|
fmt.Printf("Event statistics: \n")
|
|
|
|
for _, key := range keys {
|
|
|
|
fmt.Printf(" % 60s => %d\n", key, events[key])
|
|
|
|
}
|
2018-07-17 16:27:51 -07:00
|
|
|
}
|
2018-07-18 23:47:54 -07:00
|
|
|
|
2018-09-22 20:20:53 -07:00
|
|
|
// RandomAcc pick a random account from an array
|
|
|
|
func RandomAcc(r *rand.Rand, accs []Account) Account {
|
|
|
|
return accs[r.Intn(
|
|
|
|
len(accs),
|
2018-07-18 23:47:54 -07:00
|
|
|
)]
|
|
|
|
}
|
|
|
|
|
|
|
|
// Generate a random amount
|
|
|
|
func RandomAmount(r *rand.Rand, max sdk.Int) sdk.Int {
|
|
|
|
return sdk.NewInt(int64(r.Intn(int(max.Int64()))))
|
|
|
|
}
|
2018-09-09 08:34:09 -07:00
|
|
|
|
2018-09-22 20:20:53 -07:00
|
|
|
// RandomAccounts generates n random accounts
|
|
|
|
func RandomAccounts(r *rand.Rand, n int) []Account {
|
|
|
|
accs := make([]Account, n)
|
|
|
|
for i := 0; i < n; i++ {
|
|
|
|
// don't need that much entropy for simulation
|
|
|
|
privkeySeed := make([]byte, 15)
|
|
|
|
r.Read(privkeySeed)
|
|
|
|
useSecp := r.Int63()%2 == 0
|
|
|
|
if useSecp {
|
|
|
|
accs[i].PrivKey = secp256k1.GenPrivKeySecp256k1(privkeySeed)
|
|
|
|
} else {
|
|
|
|
accs[i].PrivKey = ed25519.GenPrivKeyFromSecret(privkeySeed)
|
|
|
|
}
|
|
|
|
accs[i].PubKey = accs[i].PrivKey.PubKey()
|
|
|
|
accs[i].Address = sdk.AccAddress(accs[i].PubKey.Address())
|
|
|
|
}
|
|
|
|
return accs
|
|
|
|
}
|
|
|
|
|
2018-09-09 08:34:09 -07:00
|
|
|
// Builds a function to add logs for this particular block
|
|
|
|
func addLogMessage(testingmode bool, blockLogBuilders []*strings.Builder, height int) func(string) {
|
|
|
|
if testingmode {
|
|
|
|
blockLogBuilders[height] = &strings.Builder{}
|
|
|
|
return func(x string) {
|
|
|
|
(*blockLogBuilders[height]).WriteString(x)
|
|
|
|
(*blockLogBuilders[height]).WriteString("\n")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return func(x string) {}
|
|
|
|
}
|
|
|
|
|
|
|
|
// assertAllInvariants asserts a list of provided invariants against application state
|
2018-10-26 04:42:53 -07:00
|
|
|
func assertAllInvariants(t *testing.T, app *baseapp.BaseApp, header abci.Header,
|
|
|
|
invariants []Invariant, where string, displayLogs func()) {
|
|
|
|
|
2018-09-09 08:34:09 -07:00
|
|
|
for i := 0; i < len(invariants); i++ {
|
2018-10-26 04:42:53 -07:00
|
|
|
err := invariants[i](app, header)
|
2018-09-09 08:34:09 -07:00
|
|
|
if err != nil {
|
2018-10-18 18:55:14 -07:00
|
|
|
fmt.Printf("Invariants broken after %s\n", where)
|
2018-09-09 08:34:09 -07:00
|
|
|
fmt.Println(err.Error())
|
|
|
|
displayLogs()
|
|
|
|
t.Fatal()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-09-22 20:20:53 -07:00
|
|
|
// RandomSetGenesis wraps mock.RandomSetGenesis, but using simulation accounts
|
|
|
|
func RandomSetGenesis(r *rand.Rand, app *mock.App, accs []Account, denoms []string) {
|
|
|
|
addrs := make([]sdk.AccAddress, len(accs))
|
|
|
|
for i := 0; i < len(accs); i++ {
|
|
|
|
addrs[i] = accs[i].Address
|
|
|
|
}
|
|
|
|
mock.RandomSetGenesis(r, app, addrs, denoms)
|
|
|
|
}
|
|
|
|
|
2018-09-09 08:34:09 -07:00
|
|
|
// Creates a function to print out the logs
|
|
|
|
func logPrinter(testingmode bool, logs []*strings.Builder) func() {
|
|
|
|
if testingmode {
|
|
|
|
return func() {
|
2018-09-11 02:18:58 -07:00
|
|
|
numLoggers := 0
|
2018-09-09 08:34:09 -07:00
|
|
|
for i := 0; i < len(logs); i++ {
|
|
|
|
// We're passed the last created block
|
|
|
|
if logs[i] == nil {
|
2018-09-11 02:18:58 -07:00
|
|
|
numLoggers = i - 1
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
var f *os.File
|
|
|
|
if numLoggers > 10 {
|
|
|
|
fileName := fmt.Sprintf("simulation_log_%s.txt", time.Now().Format("2006-01-02 15:04:05"))
|
|
|
|
fmt.Printf("Too many logs to display, instead writing to %s\n", fileName)
|
|
|
|
f, _ = os.Create(fileName)
|
|
|
|
}
|
|
|
|
for i := 0; i < numLoggers; i++ {
|
|
|
|
if f != nil {
|
|
|
|
_, err := f.WriteString(fmt.Sprintf("Begin block %d\n", i))
|
|
|
|
if err != nil {
|
|
|
|
panic("Failed to write logs to file")
|
|
|
|
}
|
|
|
|
_, err = f.WriteString((*logs[i]).String())
|
|
|
|
if err != nil {
|
|
|
|
panic("Failed to write logs to file")
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
fmt.Printf("Begin block %d\n", i)
|
|
|
|
fmt.Println((*logs[i]).String())
|
2018-09-09 08:34:09 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return func() {}
|
|
|
|
}
|