messages test improved

src/network/Message.cpp

@@ -1,12 +1,10 @@
 #include <cassert>
 #include <cstring>
 
-#include "MathUtils.h"
 #include "Message.h"
 
 namespace crown
 {
-  
 namespace network
 {
   
@@ -15,11 +13,15 @@ Message::Message() : w_data(NULL), r_data(NULL), max_size(0), cur_size(0), write
   
 }
 
+//---------------------------------------------------------------------------------------------
+
 Message::~Message()
 {
   
 }
 
+//---------------------------------------------------------------------------------------------
+
 uint8_t* Message::get_byte_space(int32_t len)
 {
 	uint8_t *ptr;
@@ -42,6 +44,8 @@ uint8_t* Message::get_byte_space(int32_t len)
 	return ptr;  
 }
 
+//---------------------------------------------------------------------------------------------
+
 bool Message::check_overflow(int32_t num_bits)
 {
 	assert( num_bits >= 0 );
@@ -60,6 +64,8 @@ bool Message::check_overflow(int32_t num_bits)
 	return false;  
 }
 
+//---------------------------------------------------------------------------------------------
+
 void Message::init(uint8_t *data, int32_t len)
 {
 	w_data = data;
@@ -67,6 +73,8 @@ void Message::init(uint8_t *data, int32_t len)
 	max_size = len;
 }
 
+//---------------------------------------------------------------------------------------------
+
 void Message::init(const uint8_t *data, int32_t len)
 {
 	w_data = NULL;
@@ -74,32 +82,43 @@ void Message::init(const uint8_t *data, int32_t len)
 	max_size = len;
 }
 
+//---------------------------------------------------------------------------------------------
+
 uint8_t* Message::get_data()
 {
 	return w_data;
 }
 
+//---------------------------------------------------------------------------------------------
+
 const uint8_t* Message::get_data() const
 {
 	return r_data;
 }
 
+//---------------------------------------------------------------------------------------------
+
 int32_t Message::get_max_size() const
 {
 	return max_size;
 }
 
+//---------------------------------------------------------------------------------------------
+
 bool Message::is_overflowed()
 {
 	return overflowed;
 }
 
+//---------------------------------------------------------------------------------------------
 
 int32_t Message::get_size() const
 {
 	return cur_size;
 }
 
+//---------------------------------------------------------------------------------------------
+
 void Message::set_size(int32_t size)
 {
 	if (size > max_size)
@@ -112,11 +131,15 @@ void Message::set_size(int32_t size)
 	}
 }
 
+//---------------------------------------------------------------------------------------------
+
 int32_t Message::get_write_bit() const
 {
 	return write_bit;
 }
 
+//---------------------------------------------------------------------------------------------
+
 void Message::set_write_bit(int32_t bit)
 {
 	write_bit = bit & 7;
@@ -126,22 +149,30 @@ void Message::set_write_bit(int32_t bit)
 	}
 }
 
+//---------------------------------------------------------------------------------------------
+
 int32_t Message::get_num_bits_written() const
 {
 	return ((cur_size << 3) - ((8 - write_bit) & 7));  
 }
-  
+
+//---------------------------------------------------------------------------------------------
+
 int32_t Message::get_remaining_write_bits() const
 {
 	return (max_size << 3) - get_num_bits_written(); 
 }
 
+//---------------------------------------------------------------------------------------------
+
 void Message::save_write_state(int32_t& s,int32_t& b) const
 {
 	s = cur_size;
 	b = write_bit;
 }
 
+//---------------------------------------------------------------------------------------------
+
 void Message::restore_write_state(int32_t s,int32_t b)
 {
 	cur_size = s;
@@ -153,48 +184,66 @@ void Message::restore_write_state(int32_t s,int32_t b)
 	}  
 }
 
+//---------------------------------------------------------------------------------------------
+
 int32_t Message::get_read_count() const
 {
 	return read_count;
 }
 
+//---------------------------------------------------------------------------------------------
+
 void Message::set_read_count(int32_t bytes)
 {
 	read_count = bytes;
 }
 
+//---------------------------------------------------------------------------------------------
+
 int32_t Message::get_read_bit() const
 {
 	return read_bit;
 }
 
+//---------------------------------------------------------------------------------------------
+
 void Message::set_read_bit(int32_t bit)
 {
 	read_bit = bit & 7;
 }
 
+//---------------------------------------------------------------------------------------------
+
 int32_t Message::get_num_bits_read() const
 {
 	return ((read_count << 3) - ((8 - read_bit) & 7));  
 }
 
+//---------------------------------------------------------------------------------------------
+
 int32_t Message::get_remaining_read_bits() const
 {
 	return (cur_size << 3) - get_num_bits_read();
 }
 
+//---------------------------------------------------------------------------------------------
+
 void Message::save_read_state(int32_t& c, int32_t& b) const
 {
 	c = read_count;
 	b = read_bit;
 }
 
+//---------------------------------------------------------------------------------------------
+
 void Message::restore_read_state(int32_t c, int32_t b)
 {
 	read_count = c;
 	read_bit = b & 7;
 }
 
+//---------------------------------------------------------------------------------------------
+
 void Message::begin_writing()
 {
 	cur_size = 0;
@@ -202,16 +251,22 @@ void Message::begin_writing()
 	overflowed = false;
 }
 
+//---------------------------------------------------------------------------------------------
+
 int32_t Message::get_remaining_space() const
 {
 	return max_size - cur_size;
 }
 
+//---------------------------------------------------------------------------------------------
+
 void Message::write_byte_align()
 {
 	write_bit = 0;
 }
 
+//---------------------------------------------------------------------------------------------
+
 void Message::write_bits(int32_t value, int32_t num_bits)
 {
 	int32_t		put;
@@ -292,41 +347,57 @@ void Message::write_bits(int32_t value, int32_t num_bits)
 	}
 }
 
+//---------------------------------------------------------------------------------------------
+
 void Message::write_int8(int32_t c)
 {
 	write_bits(c, -8);
 }
 
+//---------------------------------------------------------------------------------------------
+
 void Message::write_uint8(int32_t c)
 {
 	write_bits(c, 8);  
 }
 
+//---------------------------------------------------------------------------------------------
+
 void Message::write_int16(int32_t c)
 {
 	write_bits(c, -16);  
 }
 
+//---------------------------------------------------------------------------------------------
+
 void Message::write_uint16(int32_t c)
 {
 	write_bits(c, 16);
 }
 
-void Message::write_int64(int32_t c)
+//---------------------------------------------------------------------------------------------
+
+void Message::write_int32(int32_t c)
 {
 	write_bits(c, 32);
 }
 
+//---------------------------------------------------------------------------------------------
+
 void Message::write_real(real f)
 {
 	write_bits(*reinterpret_cast<int32_t *>(&f), 32);  
 }
 
+//---------------------------------------------------------------------------------------------
+
 void Message::write_vec3(const Vec3& v, int32_t num_bits)
 {
 	write_bits(vec3_to_bits(v, num_bits), num_bits);
 }
 
+//---------------------------------------------------------------------------------------------
+
 void Message::write_string(const char* s, int32_t max_len, bool make_7_bit)
 {
 	if (!s) 
@@ -376,11 +447,15 @@ void Message::write_string(const char* s, int32_t max_len, bool make_7_bit)
 	}  
 }
 
+//---------------------------------------------------------------------------------------------
+
 void Message::write_data(const void* data, int32_t length)
 {
 	memcpy(get_byte_space(length), data, length);
 }
 
+//---------------------------------------------------------------------------------------------
+
 void Message::write_ipv4addr(const os::IPv4Address addr)
 {
 	uint8_t* ptr;
@@ -390,22 +465,30 @@ void Message::write_ipv4addr(const os::IPv4Address addr)
 	write_uint16(addr.port);
 }
 
+//---------------------------------------------------------------------------------------------
+
 void Message::begin_reading() const
 {
 	read_count = 0;
 	read_bit = 0;
 }
 
+//---------------------------------------------------------------------------------------------
+
 int32_t Message::get_remaing_data() const
 {
 	cur_size - read_count;
 }
 
+//---------------------------------------------------------------------------------------------
+
 void Message::read_byte_align() const
 {
 	read_bit = 0;
 }
 
+//---------------------------------------------------------------------------------------------
+
 int32_t Message::read_bits(int32_t num_bits) const
 {
 	int32_t		value;
@@ -479,32 +562,44 @@ int32_t Message::read_bits(int32_t num_bits) const
 	return value;  
 }
 
+//---------------------------------------------------------------------------------------------
+
 int32_t Message::read_int8() const
 {
 	return (int32_t)read_bits(-8);
 }
 
+//---------------------------------------------------------------------------------------------
+
 int32_t Message::read_uint8() const
 {
   	return (int32_t)read_bits(8);
 
 }
 
+//---------------------------------------------------------------------------------------------
+
 int32_t Message::read_int16() const
 {
 	return (int32_t)read_bits(-16);  
 }
 
+//---------------------------------------------------------------------------------------------
+
 int32_t Message::read_uint16() const
 {
 	return (int32_t)read_bits(16);  
 }
 
-int32_t Message::read_int64() const
+//---------------------------------------------------------------------------------------------
+
+int32_t Message::read_int32() const
 {
 	return (int32_t)read_bits(32);
 }
 
+//---------------------------------------------------------------------------------------------
+
 real Message::read_real() const
 {
 	float value;
@@ -512,16 +607,20 @@ real Message::read_real() const
 	return value;  
 }
 
+//---------------------------------------------------------------------------------------------
+
 Vec3 Message::read_vec3(int32_t num_bits) const
 {
 	return bits_to_vec3(read_bits(num_bits), num_bits);
 }
 
+//---------------------------------------------------------------------------------------------
+
 int32_t Message::read_string(char* buffer, int32_t buffer_size) const
 {
 	int	l = 0;
 	int c;
-	
+
 	read_byte_align();
 	
 	while(1) 
@@ -551,6 +650,8 @@ int32_t Message::read_string(char* buffer, int32_t buffer_size) const
 	return l;  
 }
 
+//---------------------------------------------------------------------------------------------
+
 int32_t Message::read_data(void* data, int32_t length) const
 {
 	int count;
@@ -579,6 +680,8 @@ int32_t Message::read_data(void* data, int32_t length) const
 	return (read_count - count);  
 }
 
+//---------------------------------------------------------------------------------------------
+
 void Message::read_ipv4addr(os::IPv4Address* addr) const
 {
 
@@ -590,6 +693,8 @@ void Message::read_ipv4addr(os::IPv4Address* addr) const
 	addr->port = read_uint16();  
 }
 
+//---------------------------------------------------------------------------------------------
+
 int32_t Message::vec3_to_bits(const Vec3& v, int32_t num_bits)
 {
 	assert(num_bits >= 6 && num_bits <= 32);
@@ -613,6 +718,8 @@ int32_t Message::vec3_to_bits(const Vec3& v, int32_t num_bits)
 	return bits;  
 }
 
+//---------------------------------------------------------------------------------------------
+
 Vec3 Message::bits_to_vec3(int32_t bits, int32_t num_bits)
 {
 	assert(num_bits >= 6 && num_bits <= 32);
@@ -634,5 +741,7 @@ Vec3 Message::bits_to_vec3(int32_t bits, int32_t num_bits)
 	return v;
 }
 
-}
-}
+//---------------------------------------------------------------------------------------------
+
+}	//namespace network
+}	//namespace crown

src/network/Message.h

@@ -20,41 +20,40 @@ namespace network
 
 		void			init(uint8_t *data, int32_t len);
 		void			init(const uint8_t *data, int32_t len);
-		uint8_t*		get_data();								// get data for writing
-		const uint8_t*	get_data() const;						// get data for reading
-		int32_t			get_max_size() const;					// get the maximum message size
-		bool 			is_overflowed();						// get overflowed flag
+		uint8_t*		get_data();										// get data for writing
+		const uint8_t*	get_data() const;								// get data for reading
+		int32_t			get_max_size() const;							// get the maximum message size
+		bool 			is_overflowed();								// get overflowed flag
 
 
-		int32_t			get_size() const;						// size of the message in bytes
-		void			set_size(int32_t size);						// set the message size
-		int32_t			get_write_bit() const;					// get current write bit
-		void			set_write_bit(int32_t bit);					// set current write bit
-		int32_t			get_num_bits_written() const;			// returns number of bits written
-		int32_t			get_remaining_write_bits() const;		// space left in bits for writing
+		int32_t			get_size() const;								// size of the message in bytes
+		void			set_size(int32_t size);							// set the message size
+		int32_t			get_write_bit() const;							// get current write bit
+		void			set_write_bit(int32_t bit);						// set current write bit
+		int32_t			get_num_bits_written() const;					// returns number of bits written
+		int32_t			get_remaining_write_bits() const;				// space left in bits for writing
 		void			save_write_state(int32_t& s,int32_t& b) const;	// save the write state
 		void			restore_write_state(int32_t s,int32_t b);		// restore the write state
 
-		int32_t			get_read_count() const;					// bytes read so far
-		void			set_read_count(int32_t bytes);				// set the number of bytes and bits read
-		int32_t			get_read_bit() const;					// get current read bit
-		void			set_read_bit(int32_t bit);					// set current read bit
-		int32_t			get_num_bits_read() const;				// returns number of bits read
-		int32_t			get_remaining_read_bits() const;		// number of bits left to read
+		int32_t			get_read_count() const;							// bytes read so far
+		void			set_read_count(int32_t bytes);					// set the number of bytes and bits read
+		int32_t			get_read_bit() const;							// get current read bit
+		void			set_read_bit(int32_t bit);						// set current read bit
+		int32_t			get_num_bits_read() const;						// returns number of bits read
+		int32_t			get_remaining_read_bits() const;				// number of bits left to read
 		void			save_read_state(int32_t& c, int32_t& b) const;	// save the read state
 		void			restore_read_state(int32_t c, int32_t b);		// restore the read state
 
-		void			begin_writing();						// begin writing
-		int32_t			get_remaining_space() const;			// space left in bytes
-		void			write_byte_align();						// write up to the next byte boundary
+		void			begin_writing();								// begin writing
+		int32_t			get_remaining_space() const;					// space left in bytes
+		void			write_byte_align();								// write up to the next byte boundary
 		void			write_bits(int32_t value, int32_t num_bits);	// write the specified number of bits
 		void			write_int8(int32_t c);
 		void			write_uint8(int32_t c);
 		void			write_int16(int32_t c);
 		void			write_uint16(int32_t c);
-		void			write_int64(int32_t c);
+		void			write_int32(int32_t c);
 		void			write_real(real f);
-		void			write_real(real f, int32_t exp_bits, int32_t mant_bits);
 		void			write_vec3(const Vec3& v, int32_t num_bits);
 		void			write_string(const char* s, int32_t max_len = -1, bool make_7_bit = true);
 		void			write_data(const void* data, int32_t length);
@@ -68,9 +67,8 @@ namespace network
 		int32_t			read_uint8() const;
 		int32_t			read_int16() const;
 		int32_t			read_uint16() const;
-		int32_t			read_int64() const;
+		int32_t			read_int32() const;
 		real			read_real() const;
-		real			read_real(int32_t exp_bits, int32_t mant_bits) const;
 		Vec3			read_vec3(int32_t num_bits) const;
 		int32_t			read_string(char* buffer, int32_t buffer_size) const;
 		int32_t			read_data(void* data, int32_t length) const;

tests/messages.cpp

@@ -1,18 +1,53 @@
 #include <cstdio>
 
+#include "Vec3.h"
+#include "OS.h"
 #include "Message.h"
 
 using namespace crown;
 
-int main()
+void test_int8()
 {
-
 	uint32_t bits_written;
 	uint32_t rem_write_bits;
 	uint32_t bits_read;
-	uint32_t rem_read_bits;
+	uint32_t rem_read_bits; 
+	
+  	network::Message m = network::Message();
+	
+	uint8_t tmp[4];
+	int8_t res;
+	
+	m.init(tmp, 4);
+	m.begin_writing();
+	m.write_int8(-56);
+	bits_written = m.get_num_bits_written();
+	rem_write_bits = m.get_remaining_write_bits();
 
-//------------------------------------------------------------------
+	res = m.read_int8();
+	bits_read = m.get_num_bits_read();
+	rem_read_bits = m.get_remaining_read_bits();
+	
+	printf("\n-----------------------------\n");
+	printf("start write and read for UINT8\n");
+	printf("value = %d\n", res);
+	printf("bits written = %d\n", bits_written);
+	printf("remaining write bits = %d\n", rem_write_bits);
+	printf("bits read = %d\n", bits_read);
+	printf("remaining read bits = %d\n", rem_read_bits);
+	printf("-----------------------------\n");
+
+	printf("\n");	
+
+}
+
+void test_uint8()
+{
+	uint32_t bits_written;
+	uint32_t rem_write_bits;
+	uint32_t bits_read;
+	uint32_t rem_read_bits; 
+	
   	network::Message m = network::Message();
 
 	uint8_t tmp[4];
@@ -24,7 +59,7 @@ int main()
 	bits_written = m.get_num_bits_written();
 	rem_write_bits = m.get_remaining_write_bits();
 
-	res = m.read_int8();
+	res = m.read_uint8();
 	bits_read = m.get_num_bits_read();
 	rem_read_bits = m.get_remaining_read_bits();
 	
@@ -38,63 +73,250 @@ int main()
 	printf("-----------------------------\n");
 
 	printf("\n");
+}
+
+void test_int16()
+{
+	uint32_t bits_written;
+	uint32_t rem_write_bits;
+	uint32_t bits_read;
+	uint32_t rem_read_bits; 
+	
+  	network::Message m = network::Message();  
 	
-//------------------------------------------------------------------	
+	uint8_t tmp[4];
+	int16_t res;
+	
+	m.init(tmp, 4);
+	m.write_int16(-5555);
+	bits_written = m.get_num_bits_written();
+	rem_write_bits = m.get_remaining_write_bits();
+
+	res = m.read_int16();
+	bits_read = m.get_num_bits_read();
+	rem_read_bits = m.get_remaining_read_bits();
 	
-  	network::Message m1 = network::Message();
+	printf("-----------------------------\n");
+	printf("start write and read for INT16\n");
+	printf("value = %d\n", res);
+	printf("bits written = %d\n", bits_written);
+	printf("remaining write bits = %d\n", rem_write_bits);
+	printf("bits read = %d\n", bits_read);
+	printf("remaining read bits = %d\n", rem_read_bits);
+	printf("-----------------------------\n");
+	printf("\n");
+}
+
+void test_uint16()
+{
+  	uint32_t bits_written;
+	uint32_t rem_write_bits;
+	uint32_t bits_read;
+	uint32_t rem_read_bits; 
 	
-	uint8_t tmp1[4];
-	int8_t res1;
+  	network::Message m = network::Message();
 
-	m1.init(tmp1, 4);
-	m1.write_int8(-56);
-	bits_written = m1.get_num_bits_written();
-	rem_write_bits = m1.get_remaining_write_bits();
+	uint8_t tmp[4];
+	uint16_t res;
+	
+	m.init(tmp, 4);
+	m.write_uint16(5555);
+	bits_written = m.get_num_bits_written();
+	rem_write_bits = m.get_remaining_write_bits();
 
-	res1 = m1.read_int8();
-	bits_read = m1.get_num_bits_read();
-	rem_read_bits = m1.get_remaining_read_bits();
+	res = m.read_uint16();
+	bits_read = m.get_num_bits_read();
+	rem_read_bits = m.get_remaining_read_bits();
 	
 	printf("-----------------------------\n");
-	printf("start write and read for INT8\n");
-	printf("value = %d\n", res1);
+	printf("start write and read for UINT16\n");
+	printf("value = %d\n", res);
 	printf("bits written = %d\n", bits_written);
 	printf("remaining write bits = %d\n", rem_write_bits);
 	printf("bits read = %d\n", bits_read);
 	printf("remaining read bits = %d\n", rem_read_bits);
 	printf("-----------------------------\n");
+	printf("\n");
+}
 
+void test_int32()
+{
+  	uint32_t bits_written;
+	uint32_t rem_write_bits;
+	uint32_t bits_read;
+	uint32_t rem_read_bits; 
+	
+  	network::Message m = network::Message();
+	
+	uint8_t tmp[4];
+	int32_t res;
+	
+	m.init(tmp, 4);
+	m.write_int32(4000000);
+	bits_written = m.get_num_bits_written();
+	rem_write_bits = m.get_remaining_write_bits();
+	
+	res = m.read_int32();
+	bits_read = m.get_num_bits_read();
+	rem_read_bits = m.get_remaining_read_bits();
+	
+	printf("-----------------------------\n");
+	printf("start write and read for INT32\n");
+	printf("value = %d\n", res);
+	printf("bits written = %d\n", bits_written);
+	printf("remaining write bits = %d\n", rem_write_bits);
+	printf("bits read = %d\n", bits_read);
+	printf("remaining read bits = %d\n", rem_read_bits);
+	printf("-----------------------------\n");
 	printf("\n");
 	
-//------------------------------------------------------------------	
+}
 
-	network::Message m2 = network::Message();
+void test_real()
+{
+  	uint32_t bits_written;
+	uint32_t rem_write_bits;
+	uint32_t bits_read;
+	uint32_t rem_read_bits; 
+	
+  	network::Message m = network::Message();
+
+	uint8_t tmp[4];
+	real res;
 	
-	uint8_t tmp2[4];
-	int16_t res2;
+	m.init(tmp, 4);
+	m.write_real(4.5342f);
+	bits_written = m.get_num_bits_written();
+	rem_write_bits = m.get_remaining_write_bits();
+	
+	res = m.read_real();
+	bits_read = m.get_num_bits_read();
+	rem_read_bits = m.get_remaining_read_bits();
+	
+	printf("-----------------------------\n");
+	printf("start write and read for REAL\n");
+	printf("value = %f\n", res);
+	printf("bits written = %d\n", bits_written);
+	printf("remaining write bits = %d\n", rem_write_bits);
+	printf("bits read = %d\n", bits_read);
+	printf("remaining read bits = %d\n", rem_read_bits);
+	printf("-----------------------------\n");
+	printf("\n");	
 	
-	m2.init(tmp2, 4);
-	m2.write_int16(5555);
-	bits_written = m2.get_num_bits_written();
-	rem_write_bits = m2.get_remaining_write_bits();
 
-	res1 = m2.read_int16();
-	bits_read = m2.get_num_bits_read();
-	rem_read_bits = m2.get_remaining_read_bits();
+}
+
+void test_vec3()
+{
+  	uint32_t bits_written;
+	uint32_t rem_write_bits;
+	uint32_t bits_read;
+	uint32_t rem_read_bits; 
+	
+  	network::Message m = network::Message();
+	
+	
+	uint8_t tmp[4];
+	Vec3 v(0.0f, 0.0f, 1.0f);
+	Vec3 res;
+	
+	m.init(tmp, 4);
+	m.write_vec3(v, 32);
+	bits_written = m.get_num_bits_written();
+	rem_write_bits = m.get_remaining_write_bits();
+	
+	res = m.read_vec3(32);
+	bits_read = m.get_num_bits_read();
+	rem_read_bits = m.get_remaining_read_bits();
 	
 	printf("-----------------------------\n");
-	printf("start write and read for INT16\n");
-	printf("value = %d\n", res2);
+	printf("start write and read for VEC_3\n");
+	printf("x = %f, y = %f, z = %f\n", res.x, res.y, res.z);
 	printf("bits written = %d\n", bits_written);
 	printf("remaining write bits = %d\n", rem_write_bits);
 	printf("bits read = %d\n", bits_read);
 	printf("remaining read bits = %d\n", rem_read_bits);
 	printf("-----------------------------\n");
+	printf("\n");	
+}
 
-	printf("\n");
+void test_string()
+{
+  	uint32_t bits_written;
+	uint32_t rem_write_bits;
+	uint32_t bits_read;
+	uint32_t rem_read_bits; 
+	
+  	network::Message m = network::Message();
+	
+	uint8_t tmp[16];
+	char res[16];
+
+	char s[] = "test";
+	
+	m.init(tmp, 16);
+
+	m.write_string(s, sizeof(s), true);
+ 	bits_written = m.get_num_bits_written();
+  	rem_write_bits = m.get_remaining_write_bits();	
+	
+	m.read_string(res, 6);
+	bits_read = m.get_num_bits_read();
+	rem_read_bits = m.get_remaining_read_bits();
+
+	printf("-----------------------------\n");
+	printf("start write and read for STRING\n");
+ 	printf("string = %s\n", res);
+	printf("bits written = %d\n", bits_written);
+	printf("remaining write bits = %d\n", rem_write_bits);
+	printf("bits read = %d\n", bits_read);
+	printf("remaining read bits = %d\n", rem_read_bits);
+	printf("-----------------------------\n");
+	printf("\n");	
+
+}
+
+void test_data()
+{/*
+  	uint32_t bits_written;
+	uint32_t rem_write_bits;
+	uint32_t bits_read;
+	uint32_t rem_read_bits; 
+	
+  	network::Message m = network::Message();*/
+	printf("-----------------------------\n");
+	printf("start write and read for GENERIC\n");
+	printf("-----------------------------\n");
+
+
+}
+
+void test_net_address()
+{/*
+  	uint32_t bits_written;
+	uint32_t rem_write_bits;
+	uint32_t bits_read;
+	uint32_t rem_read_bits; 
 	
+  	network::Message m = network::Message();*/
+  	printf("-----------------------------\n");
+	printf("start write and read for NET_ADDRESS\n");
+	printf("-----------------------------\n");
+}
 
+int main()
+{
 	
+	test_int8();
+	test_uint8();
+	test_int16();
+	test_uint16();
+	test_int32();
+	test_real();
+	test_vec3();
+	test_string();
+	test_data();
+	test_net_address();
 	
 	return 0;
 }