func TestMain(m *testing.M) {
security.SetReadFileFn(securitytest.Asset)
randutil.SeedForTests()
serverutils.InitTestServerFactory(server.TestServerFactory)
serverutils.InitTestClusterFactory(testcluster.TestClusterFactory)
os.Exit(m.Run())
}
func main() {
// Seed the random number generator for non-determinism across
// multiple runs.
randutil.SeedForTests()
if f := flag.Lookup("alsologtostderr"); f != nil {
fmt.Println("Starting simulation. Add -alsologtostderr to see progress.")
}
flag.Parse()
dirName, err := ioutil.TempDir("", "gossip-simulation-")
if err != nil {
log.Fatalf(context.TODO(), "could not create temporary directory for gossip simulation output: %s", err)
}
// Simulation callbacks to run the simulation for cycleCount
// cycles. At each cycle % outputEvery, a dot file showing the
// state of the network graph is output.
nodeCount := 3
switch *size {
case "tiny":
// Use default parameters.
case "small":
nodeCount = 10
case "medium":
nodeCount = 25
case "large":
nodeCount = 50
case "huge":
nodeCount = 100
case "ginormous":
nodeCount = 250
default:
log.Fatalf(context.TODO(), "unknown simulation size: %s", *size)
}
edgeSet := make(map[string]edge)
stopper := stop.NewStopper()
defer stopper.Stop()
n := simulation.NewNetwork(stopper, nodeCount, true)
n.SimulateNetwork(
func(cycle int, network *simulation.Network) bool {
// Output dot graph.
dotFN := fmt.Sprintf("%s/sim-cycle-%03d.dot", dirName, cycle)
_, quiescent := outputDotFile(dotFN, cycle, network, edgeSet)
// Run until network has quiesced.
return !quiescent
},
)
// Output instructions for viewing graphs.
fmt.Printf("To view simulation graph output run (you must install graphviz):\n\nfor f in %s/*.dot ; do circo $f -Tpng -o $f.png ; echo $f.png ; done\n", dirName)
}
func TestMain(m *testing.M) {
randutil.SeedForTests()
serverutils.InitTestServerFactory(server.TestServerFactory)
serverutils.InitTestClusterFactory(testcluster.TestClusterFactory)
// Create a set of all protos we believe to be marshalled downstream of raft.
// After the tests are run, we'll subtract the encountered protos from this
// set.
notBelowRaftProtos := make(map[reflect.Type]struct{}, len(belowRaftGoldenProtos))
for typ := range belowRaftGoldenProtos {
notBelowRaftProtos[typ] = struct{}{}
}
// Before running the tests, enable instrumentation that tracks protos which
// are marshalled downstream of raft.
stopTrackingAndGetTypes := storage.TrackRaftProtos()
code := m.Run()
// Only do this verification if the associated test was run. Without this
// condition, the verification here would spuriously fail when running a
// small subset of tests e.g. as we often do with `stress`.
if verifyBelowRaftProtos {
failed := false
// Retrieve all the observed downstream-of-raft protos and confirm that they
// are all present in our expected set.
for _, typ := range stopTrackingAndGetTypes() {
if _, ok := belowRaftGoldenProtos[typ]; ok {
delete(notBelowRaftProtos, typ)
} else {
failed = true
fmt.Printf("%s: missing fixture!\n", typ)
}
}
// Confirm that our expected set is now empty; we don't want to cement any
// protos needlessly.
for typ := range notBelowRaftProtos {
failed = true
fmt.Printf("%s: not observed below raft!\n", typ)
}
// Make sure our error messages make it out.
if failed && code == 0 {
code = 1
}
}
os.Exit(code)
}
func runTests(m *testing.M) {
randutil.SeedForTests()
go func() {
// Shut down tests when interrupted (for example CTRL+C).
sig := make(chan os.Signal, 1)
signal.Notify(sig, os.Interrupt)
<-sig
select {
case <-stopper:
default:
// There is a very tiny race here: the cluster might be closing
// the stopper simultaneously.
close(stopper)
}
}()
os.Exit(m.Run())
}
func TestRandomBinaryDecimal(t *testing.T) {
defer leaktest.AfterTest(t)()
if *generateBinaryCmd == "" {
t.Skip("disabled")
}
fields := strings.Fields(*generateBinaryCmd)
if len(fields) < 1 {
t.Fatal("expected generate-binary arguments")
}
name, args := fields[0], fields[1:]
var tests []binaryTest
randutil.SeedForTests()
for {
var b bytes.Buffer
for n := rand.Intn(50); n >= 0; n-- {
fmt.Fprint(&b, rand.Intn(10))
}
v := b.String()
{
z := strings.Repeat("0", rand.Intn(10))
pos := rand.Intn(len(v) + 1)
v = v[:pos] + z + v[pos:]
}
if rand.Intn(2) == 0 {
pos := rand.Intn(len(v) + 1)
v = v[:pos] + "." + v[pos:]
}
cmdargs := append(args, `"`+v+`"`)
out, err := exec.Command(name, cmdargs...).CombinedOutput()
if err != nil {
t.Log(string(out))
t.Fatal(err)
}
if err := json.Unmarshal(out, &tests); err != nil {
t.Fatal(err)
}
if len(tests) != 1 {
t.Fatal("expected 1 test")
}
test := tests[0]
buf := writeBuffer{bytecount: metric.NewCounter(metric.Metadata{})}
dec := new(parser.DDecimal)
if _, ok := dec.SetString(test.In); !ok {
t.Fatalf("could not set %q on decimal", test.In)
}
buf.writeBinaryDatum(dec, time.UTC)
if buf.err != nil {
t.Fatal(buf.err)
}
if got := buf.wrapped.Bytes(); !bytes.Equal(got, test.Expect) {
t.Errorf("%q:\n\t%v found,\n\t%v expected", test.In, got, test.Expect)
} else if datum, err := decodeOidDatum(oid.T_numeric, formatBinary, got[4:]); err != nil {
t.Errorf("%q: unable to decode %v: %s", test.In, got[4:], err)
} else if dec.Compare(datum) != 0 {
t.Errorf("%q: expected %s, got %s", test.In, dec, datum)
}
}
}
func TestMain(m *testing.M) {
randutil.SeedForTests()
os.Exit(m.Run())
}