[Gnash-commit] gnash ChangeLog testsuite/server/StreamTest.cpp

[Sandro Santilli]

CVSROOT:        /sources/gnash
Module name:    gnash
Changes by:     Sandro Santilli <strk>  07/12/05 10:13:44

Modified files:
        .              : ChangeLog 
        testsuite/server: StreamTest.cpp 

Log message:
        add tests for stream::get_position()

CVSWeb URLs:
http://cvs.savannah.gnu.org/viewcvs/gnash/ChangeLog?cvsroot=gnash&r1=1.5089&r2=1.5090
http://cvs.savannah.gnu.org/viewcvs/gnash/testsuite/server/StreamTest.cpp?cvsroot=gnash&r1=1.5&r2=1.6

Patches:
Index: ChangeLog
===================================================================
RCS file: /sources/gnash/gnash/ChangeLog,v
retrieving revision 1.5089
retrieving revision 1.5090
diff -u -b -r1.5089 -r1.5090
--- ChangeLog   5 Dec 2007 08:24:36 -0000       1.5089
+++ ChangeLog   5 Dec 2007 10:13:44 -0000       1.5090
@@ -1,5 +1,7 @@
 2007-12-05 Sandro Santilli <address@hidden>
 
+       * testsuite/server/StreamTest.cpp: add tests for
+         stream::get_position()
        * server/parser/shape_character_def.cpp (read):
          fix format strings for SHAPE_LOG builds.
 

Index: testsuite/server/StreamTest.cpp
===================================================================
RCS file: /sources/gnash/gnash/testsuite/server/StreamTest.cpp,v
retrieving revision 1.5
retrieving revision 1.6
diff -u -b -r1.5 -r1.6
--- testsuite/server/StreamTest.cpp     4 Dec 2007 11:45:35 -0000       1.5
+++ testsuite/server/StreamTest.cpp     5 Dec 2007 10:13:44 -0000       1.6
@@ -51,10 +51,12 @@
 struct ByteReader
 {
        unsigned char b;
+       unsigned int pos;
 
        ByteReader(unsigned char by)
                :
-               b(by)
+               b(by),
+               pos(0)
        {}
 
        void setByte(unsigned char by)
@@ -72,7 +74,21 @@
                        memcpy(ptr+i, &(br->b), sizeof(unsigned char));
                }
 
-               return 1;
+               br->pos += bytes;
+               return bytes;
+       }
+
+       static int tellFunc(void* appdata)
+       {
+               ByteReader* br = (ByteReader*) appdata;
+               return br->pos;
+       }
+
+       static int seekFunc(int newPos, void* appdata)
+       {
+               ByteReader* br = (ByteReader*) appdata;
+               br->pos=newPos;
+               return 0; // ok, no error (urgh)
        }
 };
 
@@ -85,9 +101,9 @@
                &br,
                ByteReader::readFunc,
                0, // write_func wf,
-               0, //seek_func sf,
+               ByteReader::seekFunc, // seek_func sf,
                0, //seek_to_end_func ef,
-               0, //tell_func tf,
+               ByteReader::tellFunc, // tell_func tf,
                0, //get_eof_func gef,
                0, //get_err_func ger
                0, // get_stream_size_func gss,
@@ -100,162 +116,260 @@
 
        /// bits: 10101010 (0xAA)
 
+       check_equals(s.get_position(), 0);
        s.align();
+       check_equals(s.get_position(), 0);
        ret = s.read_uint(1); check_equals(ret, 1);
+       check_equals(s.get_position(), 1);
        ret = s.read_uint(1); check_equals(ret, 0);
+       check_equals(s.get_position(), 1);
        ret = s.read_uint(1); check_equals(ret, 1);
+       check_equals(s.get_position(), 1);
        ret = s.read_uint(1); check_equals(ret, 0);
+       check_equals(s.get_position(), 1);
        ret = s.read_uint(1); check_equals(ret, 1);
+       check_equals(s.get_position(), 1);
        ret = s.read_uint(1); check_equals(ret, 0);
+       check_equals(s.get_position(), 1);
        ret = s.read_uint(1); check_equals(ret, 1);
+       check_equals(s.get_position(), 1);
        ret = s.read_uint(1); check_equals(ret, 0);
+       check_equals(s.get_position(), 1);
 
        /// bits: 10101010 (0xAA)
 
        s.align();
+       // align just marks all bits in current byte as used, but doesn't read 
more
+       check_equals(s.get_position(), 1);
        ret = s.read_uint(2); check_equals(ret, 2);
+       check_equals(s.get_position(), 2);
        ret = s.read_uint(2); check_equals(ret, 2);
+       check_equals(s.get_position(), 2);
        ret = s.read_uint(2); check_equals(ret, 2);
+       check_equals(s.get_position(), 2);
        ret = s.read_uint(2); check_equals(ret, 2);
+       check_equals(s.get_position(), 2);
 
        /// bits: 10101010 (0xAA)
 
        s.align();
+       // align just marks all bits in current byte as used, but doesn't read 
more
+       check_equals(s.get_position(), 2);
        ret = s.read_uint(3); check_equals(ret, 5);
+       check_equals(s.get_position(), 3);
        ret = s.read_uint(3); check_equals(ret, 2);
+       check_equals(s.get_position(), 3);
        ret = s.read_uint(2); check_equals(ret, 2);
+       check_equals(s.get_position(), 3);
 
        /// bits: 10101010 (0xAA)
 
        s.align();
+       check_equals(s.get_position(), 3);
        ret = s.read_uint(3); check_equals(ret, 5);
+       check_equals(s.get_position(), 4);
        ret = s.read_uint(2); check_equals(ret, 1);
+       check_equals(s.get_position(), 4);
        ret = s.read_uint(3); check_equals(ret, 2);
+       check_equals(s.get_position(), 4);
 
        /// bits: 10101010 (0xAA)
 
        s.align();
+       check_equals(s.get_position(), 4);
        ret = s.read_uint(2); check_equals(ret, 2);
+       check_equals(s.get_position(), 5);
        ret = s.read_uint(3); check_equals(ret, 5);
+       check_equals(s.get_position(), 5);
        ret = s.read_uint(3); check_equals(ret, 2);
+       check_equals(s.get_position(), 5);
 
        /// bits: 10101010 (0xAA)
 
        s.align();
+       check_equals(s.get_position(), 5);
        ret = s.read_uint(4); check_equals(ret, 10);
+       check_equals(s.get_position(), 6);
        ret = s.read_uint(4); check_equals(ret, 10);
+       check_equals(s.get_position(), 6);
 
        /// bits: 10101010 (0xAA)
 
        s.align();
+       check_equals(s.get_position(), 6);
        ret = s.read_uint(5); check_equals(ret, 21);
+       check_equals(s.get_position(), 7);
        ret = s.read_uint(3); check_equals(ret, 2);
+       check_equals(s.get_position(), 7);
 
        /// bits: 10101010 (0xAA)
 
        s.align();
+       check_equals(s.get_position(), 7);
        ret = s.read_uint(3); check_equals(ret, 5);
+       check_equals(s.get_position(), 8);
        ret = s.read_uint(5); check_equals(ret, 10);
+       check_equals(s.get_position(), 8);
 
        /// bits: 10101010 (0xAA)
 
        s.align();
+       check_equals(s.get_position(), 8);
        ret = s.read_uint(6); check_equals(ret, 42);
+       check_equals(s.get_position(), 9);
        ret = s.read_uint(2); check_equals(ret, 2);
+       check_equals(s.get_position(), 9);
 
        /// bits: 10101010 (0xAA)
 
        s.align();
+       check_equals(s.get_position(), 9);
        ret = s.read_uint(2); check_equals(ret, 2);
+       check_equals(s.get_position(), 10);
        ret = s.read_uint(6); check_equals(ret, 42);
+       check_equals(s.get_position(), 10);
 
        /// bits: 10101010 (0xAA)
 
        s.align();
+       check_equals(s.get_position(), 10);
        ret = s.read_uint(7); check_equals(ret, 85);
+       check_equals(s.get_position(), 11);
        ret = s.read_uint(1); check_equals(ret, 0);
+       check_equals(s.get_position(), 11);
 
        /// bits: 10101010 (0xAA)
 
        s.align();
+       check_equals(s.get_position(), 11);
        ret = s.read_uint(1); check_equals(ret, 1);
+       check_equals(s.get_position(), 12);
        ret = s.read_uint(7); check_equals(ret, 42);
+       check_equals(s.get_position(), 12);
 
        /// bits: 10101010 (0xAA)
 
        s.align();
+       check_equals(s.get_position(), 12);
        ret = s.read_uint(8); check_equals(ret, 170);
+       check_equals(s.get_position(), 13);
 
        /// bits: 10101 01010 10101 0 (0xAAAA)
 
        s.align();
+       check_equals(s.get_position(), 13);
        ret = s.read_uint(5); check_equals(ret, 21);
+       check_equals(s.get_position(), 14);
        ret = s.read_uint(5); check_equals(ret, 10);
+       check_equals(s.get_position(), 15);
        ret = s.read_uint(5); check_equals(ret, 21);
+       check_equals(s.get_position(), 15);
 
        /// bits: 101010 101 0101010 (0xAAAA)
 
        s.align();
+       check_equals(s.get_position(), 15);
        ret = s.read_uint(6); check_equals(ret, 42);
+       check_equals(s.get_position(), 16);
        ret = s.read_uint(3); check_equals(ret, 5);
+       check_equals(s.get_position(), 17);
        ret = s.read_uint(7); check_equals(ret, 42);
+       check_equals(s.get_position(), 17);
 
        /// bits: 1010101010101010 (0xAAAA)
 
        s.align();
+       check_equals(s.get_position(), 17);
        ret = s.read_uint(16); check_equals(ret, 43690);
+       check_equals(s.get_position(), 19);
 
        /// bits: 101010 10101010101010 1010 (0xAAAAAA)
 
        s.align();
+       check_equals(s.get_position(), 19);
        ret = s.read_uint(6); check_equals(ret, 42);
+       check_equals(s.get_position(), 20);
        ret = s.read_uint(14); check_equals(ret, 10922);
+       check_equals(s.get_position(), 22);
        ret = s.read_uint(4); check_equals(ret, 10);
+       check_equals(s.get_position(), 22);
 
        /// bits: 101010101010101010101010 (0xAAAAAA)
 
        s.align();
+       check_equals(s.get_position(), 22);
        ret = s.read_uint(24); check_equals(ret, 11184810);
+       check_equals(s.get_position(), 25);
 
        /// bits: 1010101010101010 (0xAAAA)
 
        s.align();
+       check_equals(s.get_position(), 25);
        ret = s.read_bit(); check_equals(ret, 1);
+       check_equals(s.get_position(), 26);
        ret = s.read_bit(); check_equals(ret, 0);
+       check_equals(s.get_position(), 26);
        ret = s.read_bit(); check_equals(ret, 1);
+       check_equals(s.get_position(), 26);
        ret = s.read_bit(); check_equals(ret, 0);
+       check_equals(s.get_position(), 26);
        ret = s.read_bit(); check_equals(ret, 1);
+       check_equals(s.get_position(), 26);
        ret = s.read_bit(); check_equals(ret, 0);
+       check_equals(s.get_position(), 26);
        ret = s.read_bit(); check_equals(ret, 1);
+       check_equals(s.get_position(), 26);
        ret = s.read_bit(); check_equals(ret, 0);
+       check_equals(s.get_position(), 26);
        ret = s.read_bit(); check_equals(ret, 1);
+       check_equals(s.get_position(), 27);
        ret = s.read_bit(); check_equals(ret, 0);
+       check_equals(s.get_position(), 27);
        ret = s.read_bit(); check_equals(ret, 1);
+       check_equals(s.get_position(), 27);
        ret = s.read_bit(); check_equals(ret, 0);
+       check_equals(s.get_position(), 27);
        ret = s.read_bit(); check_equals(ret, 1);
+       check_equals(s.get_position(), 27);
        ret = s.read_bit(); check_equals(ret, 0);
+       check_equals(s.get_position(), 27);
        ret = s.read_bit(); check_equals(ret, 1);
+       check_equals(s.get_position(), 27);
        ret = s.read_bit(); check_equals(ret, 0);
+       check_equals(s.get_position(), 27);
 
        /// bits: 10011001 (0x99)
 
        br.setByte(0x99);
        s.align();
+       check_equals(s.get_position(), 27);
        ret = s.read_bit(); check_equals(ret, 1);
+       check_equals(s.get_position(), 28);
        ret = s.read_bit(); check_equals(ret, 0);
+       check_equals(s.get_position(), 28);
        ret = s.read_bit(); check_equals(ret, 0);
+       check_equals(s.get_position(), 28);
        ret = s.read_bit(); check_equals(ret, 1);
+       check_equals(s.get_position(), 28);
        ret = s.read_bit(); check_equals(ret, 1);
+       check_equals(s.get_position(), 28);
        ret = s.read_bit(); check_equals(ret, 0);
+       check_equals(s.get_position(), 28);
        ret = s.read_bit(); check_equals(ret, 0);
+       check_equals(s.get_position(), 28);
        ret = s.read_bit(); check_equals(ret, 1);
+       check_equals(s.get_position(), 28);
 
        /// bits: 10011001 10011001 (0x999999)
 
        boost::int16_t s16 = s.read_s16(); check_equals(s16, 
(boost::int16_t)0x9999);
+       check_equals(s.get_position(), 30);
        boost::uint16_t u16 = s.read_u16(); check_equals(u16, 
(boost::uint16_t)0x9999);
+       check_equals(s.get_position(), 32);
        boost::int32_t s32 = s.read_s32(); check_equals(s32, 
(boost::int32_t)0x99999999);
+       check_equals(s.get_position(), 36);
        boost::uint32_t u32 = s.read_u32(); check_equals(u32, 
(boost::uint32_t)0x99999999);
+       check_equals(s.get_position(), 40);
 
        /// bits: 10011001 10011001 10011001 10011001 (0x99999999)
        ///       -
@@ -263,9 +377,13 @@
        ///                           --------
 
        s.align();
+       check_equals(s.get_position(), 40);
        ret = s.read_bit(); check_equals(ret, 1);
+       check_equals(s.get_position(), 41);
        u16 = s.read_uint(17); check_equals(u16, 26214);
+       check_equals(s.get_position(), 43);
        u16 = s.read_uint(7); check_equals(u16, 51);
+       check_equals(s.get_position(), 44);
 
        /// bits: 10011001 10011001 10011001 10011001 (0x99999999)
        ///       -
@@ -273,9 +391,13 @@
        ///                         ----------
 
        s.align();
+       check_equals(s.get_position(), 44);
        ret = s.read_bit(); check_equals(ret, 1);
+       check_equals(s.get_position(), 45);
        u16 = s.read_uint(15); check_equals(u16, 6553);
+       check_equals(s.get_position(), 46);
        u16 = s.read_uint(9); check_equals(u16, 307);
+       check_equals(s.get_position(), 48);
 
        /// bits: 10011001 10011001 10011001 10011001 (0x99999999)
        ///       -
@@ -284,10 +406,15 @@
        ///                                       ---
 
        s.align();
+       check_equals(s.get_position(), 48);
        ret = s.read_bit(); check_equals(ret, 1);
+       check_equals(s.get_position(), 49);
        u32 = s.read_uint(18); check_equals(u32, 52428);
+       check_equals(s.get_position(), 51);
        u16 = s.read_uint(10); check_equals(u16, 819);
+       check_equals(s.get_position(), 52);
        u16 = s.read_uint(3); check_equals(u16, 1);
+       check_equals(s.get_position(), 52);
 
        return 0;
 }