// Tests a 2-node system
func TestBroadcast(t *testing.T) {
for _, nbrNodes := range []int{3, 10, 14} {
local := onet.NewLocalTest()
_, _, tree := local.GenTree(nbrNodes, false)
pi, err := local.CreateProtocol("Broadcast", tree)
if err != nil {
t.Fatal("Couldn't start protocol:", err)
}
protocol := pi.(*manage.Broadcast)
done := make(chan bool)
protocol.RegisterOnDone(func() {
done <- true
})
protocol.Start()
timeout := network.WaitRetry * time.Duration(network.MaxRetryConnect*nbrNodes*2) * time.Millisecond
select {
case <-done:
log.Lvl2("Done with connecting everybody")
case <-time.After(timeout):
t.Fatal("Didn't finish in time")
}
local.CloseAll()
log.AfterTest(t)
}
}
func TestServiceCosi(t *testing.T) {
defer log.AfterTest(t)
log.TestOutput(testing.Verbose(), 4)
local := onet.NewTCPTest()
// generate 5 hosts, they don't connect, they process messages, and they
// don't register the tree or entitylist
hosts, el, _ := local.GenTree(5, false)
defer local.CloseAll()
// Send a request to the service
client := NewTestClient(local)
msg := []byte("hello cosi service")
log.Lvl1("Sending request to service...")
res, err := client.SignatureRequest(el, msg)
log.ErrFatal(err, "Couldn't send")
// verify the response still
assert.Nil(t, cosi.VerifySignature(hosts[0].Suite(), el.Publics(),
msg, res.Signature))
}
// Tests a 2-node system
func TestCloseAll(t *testing.T) {
local := onet.NewLocalTest()
defer log.AfterTest(t)
nbrNodes := 2
_, _, tree := local.GenTree(nbrNodes, true)
defer local.CloseAll()
pi, err := local.CreateProtocol("CloseAll", tree)
if err != nil {
t.Fatal("Couldn't start protocol:", err)
}
done := make(chan bool)
go func() {
pi.Start()
done <- true
}()
select {
case <-done:
case <-time.After(10 * time.Second):
t.Fatal("Didn't finish in 10 seconds")
}
}
// Tests an n-node system
func TestPropagate(t *testing.T) {
for _, nbrNodes := range []int{3, 10, 14} {
local := onet.NewLocalTest()
conodes, el, _ := local.GenTree(nbrNodes, true)
var i int
var iMut sync.Mutex
msg := &PropagateMsg{[]byte("propagate")}
propFuncs := make([]PropagationFunc, nbrNodes)
var err error
for n, conode := range conodes {
pc := &PC{conode, local.Overlays[conode.ServerIdentity.ID]}
propFuncs[n], err = NewPropagationFunc(pc,
"Propagate",
func(m network.Body) {
if bytes.Equal(msg.Data, m.(*PropagateMsg).Data) {
iMut.Lock()
i++
iMut.Unlock()
} else {
t.Error("Didn't receive correct data")
}
})
log.ErrFatal(err)
}
log.Lvl2("Starting to propagate", reflect.TypeOf(msg))
children, err := propFuncs[0](el, msg, 1000)
log.ErrFatal(err)
if i != nbrNodes {
t.Fatal("Didn't get data-request")
}
if children != nbrNodes {
t.Fatal("Not all nodes replied")
}
local.CloseAll()
log.AfterTest(t)
}
}
