Go to the documentation of this file.
00001 /*
00002  * This file provides test cases for the tcpip package, that can be executed by MiniCppUnit
00003  *
00004  * Author: Axel Wegener
00005  */
00006 
00007 #ifdef UNITTESTS
00008 
00009 #include "MiniCppUnit.hxx"
00010 #include "storage.h"
00011 //#include "socket.h"
00012 #include <math.h>
00013 
00014 
00015 class tcpipUnitTests : public TestFixture<tcpipUnitTests>
00016 {
00017 public:
00018     TEST_FIXTURE( tcpipUnitTests )
00019     {
00020         TEST_CASE( testStorageChar );
00021         TEST_CASE( testStorageByte );
00022         TEST_CASE( testStorageString );
00023         TEST_CASE( testStorageShort );
00024         TEST_CASE( testStorageInt );
00025         TEST_CASE( testStorageFloat );
00026         TEST_CASE( testStorageDouble );
00027         TEST_CASE( testStorageMixed );
00028         TEST_CASE( testStorageReset );
00029         TEST_CASE( testStorageValidPos );
00030         TEST_CASE( testStorageLoadCharArray );
00031         TEST_CASE( testStorageCharToInt );
00032         TEST_CASE( testStorageByteShortInt );
00033     }
00034     
00035     void testStorageChar()
00036     {
00037         tcpip::Storage s1;
00038 
00039         s1.writeChar('\0');
00040         s1.writeChar('�');
00041         s1.writeChar('\n');
00042 
00043         ASSERT_EQUALS( true, s1.valid_pos() );
00044         ASSERT( s1.readChar() == '\0' ); 
00045         ASSERT( (char) s1.readChar() == '�' ); 
00046         ASSERT( s1.readChar() == '\n' ); 
00047         ASSERT_EQUALS( false, s1.valid_pos() );
00048     }
00049 
00050     void testStorageByte()
00051     {
00052         tcpip::Storage s1;
00053        
00054         s1.writeByte(0);
00055         s1.writeByte(-128);
00056         s1.writeByte(127);
00057 /*
00058         bool err = false;
00059         try
00060         {
00061             s1.writeByte(128);
00062         }
00063         catch (std::invalid_argument e)
00064         {
00065             err = true;
00066         }
00067         catch ( ... ) {}
00068         if (!err) FAIL("Storage::writeByte allowed an input value of 128");
00069         
00070         err = false;
00071         try
00072         {
00073             s1.writeByte(-129);
00074         }
00075         catch (std::invalid_argument e)
00076         {
00077             err = true;
00078         }
00079         if (!err) FAIL("Storage::writeByte allowed an input value of -129");
00080 */      
00081         ASSERT_EQUALS( true, s1.valid_pos() );
00082         ASSERT_EQUALS( 0, s1.readByte() ); 
00083         ASSERT_EQUALS( -128, s1.readByte() ); 
00084         ASSERT_EQUALS( 127, s1.readByte() );
00085         ASSERT_EQUALS( false, s1.valid_pos() );
00086     }
00087 
00088     void testStorageString()
00089     {
00090         tcpip::Storage s1;
00091        
00092         s1.writeString("Dies ist ein TestString");
00093         s1.writeString("");
00094         s1.writeString("2. Text mit Sonderzeichen � � � \n\0");
00095 
00096         ASSERT_EQUALS( true, s1.valid_pos() );
00097         ASSERT_EQUALS( "Dies ist ein TestString", s1.readString() ); 
00098         ASSERT_EQUALS( "", s1.readString() ); 
00099         ASSERT_EQUALS( "2. Text mit Sonderzeichen � � � \n\0", s1.readString() ); 
00100         ASSERT_EQUALS( false, s1.valid_pos() );
00101     }
00102 
00103     void testStorageShort()
00104     {
00105         tcpip::Storage s1;
00106        
00107         s1.writeShort(0);
00108         s1.writeShort(32767);
00109         s1.writeShort(-32768);
00110 
00111         ASSERT_EQUALS( true, s1.valid_pos() );
00112         ASSERT_EQUALS( 0, s1.readShort() ); 
00113         ASSERT_EQUALS( 32767, s1.readShort() );
00114         ASSERT_EQUALS( -32768, s1.readShort() ); 
00115         ASSERT_EQUALS( false, s1.valid_pos() );
00116     }
00117 
00118     void testStorageInt()
00119     {
00120         tcpip::Storage s1;
00121        
00122         s1.writeInt(0);
00123         s1.writeInt(-32768);
00124         s1.writeInt(32767);
00125         s1.writeInt(INT_MIN);
00126         s1.writeInt(INT_MAX);
00127 
00128         ASSERT_EQUALS( true, s1.valid_pos() );
00129         ASSERT_EQUALS( 0, s1.readInt() ); 
00130         ASSERT_EQUALS( -32768, s1.readInt() ); 
00131         ASSERT_EQUALS( 32767, s1.readInt() );
00132         ASSERT_EQUALS( INT_MIN, s1.readInt() );
00133         ASSERT_EQUALS( INT_MAX, s1.readInt() );
00134         ASSERT_EQUALS( false, s1.valid_pos() );
00135     }
00136 
00137     void testStorageFloat()
00138     {
00139         tcpip::Storage s1;
00140        
00141         float f1 = (float) 0.000002;
00142         float f2 = (float) 0.000001;
00143 
00144         s1.writeFloat(0.0);
00145         s1.writeFloat(f1);
00146         s1.writeFloat(f2);
00147 
00148         ASSERT_EQUALS( true, s1.valid_pos() );
00149         ASSERT_EQUALS( (float) 0.0, s1.readFloat() ); 
00150         ASSERT_EQUALS( f1, s1.readFloat() ); 
00151         ASSERT_EQUALS( f2, s1.readFloat() );
00152         ASSERT_EQUALS( false, s1.valid_pos() );
00153     }
00154 
00155     void testStorageDouble()
00156     {
00157         tcpip::Storage s1;
00158        
00159         double d1 = 0.000002;
00160         double d2 = 0.000001;
00161 
00162         s1.writeDouble(0.0);
00163         s1.writeDouble(d1);
00164         s1.writeDouble(d2);
00165 
00166         ASSERT_EQUALS( true, s1.valid_pos() );
00167         ASSERT_EQUALS( 0.0, s1.readDouble() ); 
00168         ASSERT_EQUALS( d1, s1.readDouble() ); 
00169         ASSERT_EQUALS( d2, s1.readDouble() );
00170         ASSERT_EQUALS( false, s1.valid_pos() );
00171     }   
00172 
00173     void testStorageMixed()
00174     {
00175         tcpip::Storage s1;
00176        
00177         double d1 = 0.000002;
00178 
00179         s1.writeFloat(0.0);
00180         s1.writeDouble(d1);
00181         s1.writeString("\0");
00182         s1.writeShort(42);
00183 
00184         ASSERT_EQUALS( true, s1.valid_pos() );
00185         ASSERT_EQUALS( (float) 0.0, s1.readFloat() ); 
00186         ASSERT_EQUALS( d1, s1.readDouble() ); 
00187         ASSERT_EQUALS( "\0", s1.readString() );
00188         ASSERT_EQUALS( 42, s1.readShort() ); 
00189         ASSERT_EQUALS( false, s1.valid_pos() );
00190     }
00191 
00192     void testStorageReset()
00193     {
00194         tcpip::Storage s1;
00195        
00196         double d1 = 0.000002;
00197 
00198         s1.reset();
00199         ASSERT_EQUALS( false, s1.valid_pos() );
00200 
00201         s1.writeFloat(0.0);
00202         s1.writeDouble(d1);
00203         s1.writeString("\0");
00204         s1.writeShort(42);
00205 
00206         ASSERT_EQUALS( true, s1.valid_pos() );
00207         s1.reset();
00208         ASSERT_EQUALS( false, s1.valid_pos() );
00209 
00210         s1.writeString("Test");
00211 
00212         ASSERT_EQUALS( true, s1.valid_pos() );
00213         ASSERT_EQUALS( "Test", s1.readString() ); 
00214         ASSERT_EQUALS( false, s1.valid_pos() );
00215 
00216         s1.reset();
00217         ASSERT( 0 == s1.size() );
00218     }
00219 
00220     void testSocketConnect()
00221     {
00222         
00223     }
00224 
00225     void testStorageValidPos()
00226     {
00227         tcpip::Storage s1;
00228         ASSERT_EQUALS( false, s1.valid_pos() );
00229 
00230         tcpip::Storage s2;
00231         s2.writeFloat(1.0);
00232         ASSERT_EQUALS( true, s2.valid_pos() );
00233         
00234         s2.reset();
00235         ASSERT_EQUALS( false, s2.valid_pos() );
00236     }
00237     
00238   void testStorageLoadCharArray()
00239   {
00240     tcpip::Storage sHallo;
00241     sHallo.writeString("Hallo du!");
00242 
00243     unsigned char cBuffer[100];
00244     unsigned int i=0;
00245     while ( sHallo.valid_pos() && i < sizeof(cBuffer) )
00246     {
00247       cBuffer[i] = sHallo.readChar();
00248       i++;
00249     }
00250 
00251         tcpip::Storage s1(cBuffer, i);
00252 
00253         ASSERT_EQUALS( "Hallo du!", s1.readString() );
00254 
00255   }
00256   void testStorageCharToInt()
00257   {
00258     tcpip::Storage s;
00259     
00260     ASSERT_EQUALS(0, (int)s.position());
00261     ASSERT_EQUALS(0, (int)s.size());
00262 
00263     s.writeChar(0);
00264     ASSERT_EQUALS(0, (int)s.position());
00265     ASSERT_EQUALS(1, (int)s.size());
00266 
00267     s.writeChar(0);
00268     ASSERT_EQUALS(0, (int)s.position());
00269     ASSERT_EQUALS(2, (int)s.size());
00270 
00271     s.writeChar(0);
00272     ASSERT_EQUALS(0, (int)s.position());
00273     ASSERT_EQUALS(3, (int)s.size());
00274 
00275     s.writeChar(4);
00276     ASSERT_EQUALS(0, (int)s.position());
00277     ASSERT_EQUALS(4, (int)s.size());
00278     
00279     int n = s.readInt();
00280     
00281     ASSERT_EQUALS(4, (int)s.position());
00282     ASSERT_EQUALS(4, (int)s.size());
00283     ASSERT_EQUALS(4, n);
00284     
00285     s.reset();
00286 
00287     ASSERT_EQUALS(0, (int)s.position());
00288     ASSERT_EQUALS(0, (int)s.size());
00289 
00290     s.writeChar(0);
00291     ASSERT_EQUALS(0, (int)s.position());
00292     ASSERT_EQUALS(1, (int)s.size());
00293 
00294     s.writeChar(0);
00295     ASSERT_EQUALS(0, (int)s.position());
00296     ASSERT_EQUALS(2, (int)s.size());
00297 
00298     s.writeChar(0);
00299     ASSERT_EQUALS(0, (int)s.position());
00300     ASSERT_EQUALS(3, (int)s.size());
00301 
00302     s.writeChar(4);
00303     ASSERT_EQUALS(0, (int)s.position());
00304     ASSERT_EQUALS(4, (int)s.size());
00305     
00306     n = s.readInt();
00307     
00308     ASSERT_EQUALS(4, (int)s.position());
00309     ASSERT_EQUALS(4, (int)s.size());
00310     ASSERT_EQUALS(4, n);
00311 
00312   }
00313   
00314   void testStorageByteShortInt()
00315   {
00316     tcpip::Storage s;
00317     return;
00318     try {
00319 //  s.writeByte(-128);
00320     s.writeByte(127);
00321     
00322 //  ASSERT_EQUALS(-128, s.readByte());
00323     ASSERT_EQUALS(127, s.readByte());
00324     
00325     }
00326     catch (std::string s)
00327     {
00328         std::cerr << s << std::endl;
00329     }
00330 
00331     /*  int max = 255;
00332     int min = 0;
00333     
00334     byte b;
00335     int i;
00336     
00337     b = (byte) min;
00338     i = b;
00339     ASSERT_EQUALS(0, i);
00340 
00341     b = (byte) max;
00342     i = b;
00343     ASSERT_EQUALS(255, i);
00344   */
00345   }
00346 };
00347 
00348 REGISTER_FIXTURE( tcpipUnitTests );
00349 
00350 #endif
tcpipUnitTests.cpp
