예제 #1
0
func TestConversion(t *testing.T) {
	buf := make([]byte, 8)
	message.Uint64ToByteArray(buf, testId)
	id := message.ByteArrayToUint64(buf)
	assert.Equal(t, testId, id, "uint64 conversion is wrong!")

	buf = make([]byte, 4)
	message.Uint32ToByteArray(buf, testNum)
	n := message.ByteArrayToUint32(buf)
	assert.Equal(t, testNum, n, "uint32 conversion is wrong!")

	a1 := message.Uint64ArrayToByteArray(nil)
	a2 := message.Uint64ArrayToByteArray(make([]uint64, 0))
	a3 := message.Uint64ArrayToByteArray(testList)

	assert.Nil(t, a1, "Should return nil with nil as input")
	assert.Len(t, a2, 0, "Should give empty byte list")
	assert.Len(t, a3, len(testList)*8, "One element takes 8 bytes of space")

	l1 := message.ByteArrayToUint64Array(nil)
	l2 := message.ByteArrayToUint64Array(make([]byte, 7))
	l3 := message.ByteArrayToUint64Array(make([]byte, 0))
	l4 := message.ByteArrayToUint64Array(a3)

	assert.Nil(t, l1, "Should return nil with nil as input")
	assert.Nil(t, l2, "Should return nil with incorrect length")
	assert.Len(t, l3, 0, "Should give empty byte list")
	assert.Nil(t, testutils.CompareList(l4, testList), "Lists should be the same")
}
예제 #2
0
func TestRelayTwo(t *testing.T) {

	if len(allCliId) < 2 {
		return
	}

	val, _ := climap.Get(allCliId[0])
	c1 := val.(*client.Client)
	val, _ = climap.Get(allCliId[1])
	c2 := val.(*client.Client)

	var wg sync.WaitGroup
	wg.Add(MessagesPerCLient)
	var counter int

	req := message.NewRelayRequest([]uint64{c2.Id()}, testBody)
	buf := make([]byte, 8)
	for i := 0; i < MessagesPerCLient; i++ {

		message.Uint64ToByteArray(buf, uint64(i))
		req.Body = buf
		c1.Send(req)
	}

	for i := 0; i < MessagesPerCLient; i++ {

		counter++
		wg.Done()
	}

	wg.Wait()
	assert.Equal(t, MessagesPerCLient, counter, "Client2 should have received all messages")

}
예제 #3
0
func convertSetList(list []interface{}) []byte {

	out := make([]byte, 0, len(list)*8)

	//temporary container for conversion uint64 --> [8]byte
	buff := make([]byte, 8, 8)

	//one by one convert the receiver ID into bytearray and append it to the byte message
	for _, el := range list {

		//BigEndian implementation ensures a 8-byte conversion
		message.Uint64ToByteArray(buff, el.(uint64))
		out = append(out, buff...)
	}

	return out

}