root/trunk/libfreebob/src/bebob/bebob_unittests.cpp

Revision 359, 8.2 kB (checked in by wagi, 17 years ago)

serializing interface fixed for 64 bit machines

Line 
1 /* bebob_unittests.cpp
2  * Copyright (C) 2006 by Daniel Wagner
3  *
4  * This file is part of FreeBoB.
5  *
6  * FreeBoB is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  * FreeBoB is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with FreeBoB; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
18  * MA 02111-1307 USA.
19  */
20
21 #include "bebob_serialize.h"
22 #include <libraw1394/raw1394.h>
23
24 #include <stdio.h>
25
26 using namespace BeBoB;
27
28 ///////////////////////////////////////
29
30 class U0_SerializeMe {
31 public:
32     U0_SerializeMe();
33
34     bool operator == ( const U0_SerializeMe& rhs );
35
36     bool serialize( IOSerialize& ser );
37     bool deserialize( IODeserialize& deser );
38
39     byte_t m_byte;
40     quadlet_t m_quadlet;
41 };
42
43 U0_SerializeMe::U0_SerializeMe()
44     : m_byte( 0 )
45     , m_quadlet( 0 )
46 {
47 }
48
49
50 //--------------------------
51 bool
52 U0_SerializeMe::operator == ( const U0_SerializeMe& rhs )
53 {
54     return    ( m_byte == rhs.m_byte )
55            && ( m_quadlet == rhs.m_quadlet );
56 }
57
58 bool
59 U0_SerializeMe::serialize( IOSerialize& ser )
60 {
61     bool result;
62     result  = ser.write( "SerializeMe/m_byte", m_byte );
63     result &= ser.write( "SerializeMe/m_quadlet", m_quadlet );
64     return result;
65 }
66
67 bool
68 U0_SerializeMe::deserialize( IODeserialize& deser )
69 {
70     bool result;
71     result  = deser.read( "SerializeMe/m_byte", m_byte );
72     result &= deser.read( "SerializeMe/m_quadlet", m_quadlet );
73     return result;
74 }
75
76 static bool
77 testU0()
78 {
79     U0_SerializeMe sme1;
80
81     sme1.m_byte = 0x12;
82     sme1.m_quadlet = 0x12345678;
83
84     {
85         XMLSerialize xmlSerialize( "unittest_u0.xml" );
86         if ( !sme1.serialize( xmlSerialize ) ) {
87             printf( "(serializing failed)" );
88             return false;
89         }
90     }
91
92     U0_SerializeMe sme2;
93
94     {
95         XMLDeserialize xmlDeserialize( "unittest_u0.xml" );
96         if ( !sme2.deserialize( xmlDeserialize ) ) {
97             printf( "(deserializing failed)" );
98             return false;
99         }
100     }
101
102     bool result = sme1 == sme2;
103     if ( !result ) {
104         printf( "(wrong values)" );
105     }
106     return result;
107 }
108
109
110 ///////////////////////////////////////
111
112 class U1_SerializeMe {
113 public:
114     U1_SerializeMe();
115
116     bool operator == ( const U1_SerializeMe& rhs );
117
118     bool serialize( IOSerialize& ser );
119     bool deserialize( IODeserialize& deser );
120
121     quadlet_t m_quadlet0;
122     quadlet_t m_quadlet1;
123     quadlet_t m_quadlet2;
124 };
125
126 U1_SerializeMe::U1_SerializeMe()
127     : m_quadlet0( 0 )
128     , m_quadlet1( 0 )
129     , m_quadlet2( 0 )
130 {
131 }
132
133
134 //--------------------------
135 bool
136 U1_SerializeMe::operator == ( const U1_SerializeMe& rhs )
137 {
138     return    ( m_quadlet0 == rhs.m_quadlet0 )
139            && ( m_quadlet1 == rhs.m_quadlet1)
140            && ( m_quadlet2 == rhs.m_quadlet2);
141 }
142
143 bool
144 U1_SerializeMe::serialize( IOSerialize& ser )
145 {
146     bool result;
147     result  = ser.write( "here/and/not/there/m_quadlet0", m_quadlet0 );
148     result &= ser.write( "here/and/not/m_quadlet1", m_quadlet1 );
149     result &= ser.write( "here/and/m_quadlet2", m_quadlet2 );
150     return result;
151 }
152
153 bool
154 U1_SerializeMe::deserialize( IODeserialize& deser )
155 {
156     bool result;
157     result  = deser.read( "here/and/not/there/m_quadlet0", m_quadlet0 );
158     result &= deser.read( "here/and/not/m_quadlet1", m_quadlet1 );
159     result &= deser.read( "here/and/m_quadlet2", m_quadlet2 );
160     return result;
161 }
162
163 static bool
164 testU1()
165 {
166     U1_SerializeMe sme1;
167
168     sme1.m_quadlet0 = 0;
169     sme1.m_quadlet1 = 1;
170     sme1.m_quadlet2 = 2;
171
172     {
173         XMLSerialize xmlSerialize( "unittest_u1.xml" );
174         if ( !sme1.serialize( xmlSerialize ) ) {
175             printf( "(serializing failed)" );
176             return false;
177         }
178     }
179
180     U1_SerializeMe sme2;
181
182     {
183         XMLDeserialize xmlDeserialize( "unittest_u1.xml" );
184         if ( !sme2.deserialize( xmlDeserialize ) ) {
185             printf( "(deserializing failed)" );
186             return false;
187         }
188     }
189
190     bool result = sme1 == sme2;
191     if ( !result ) {
192         printf( "(wrong values)" );
193     }
194     return result;
195 }
196
197 ///////////////////////////////////////
198
199 class U2_SerializeMe {
200 public:
201     U2_SerializeMe();
202
203     bool operator == ( const U2_SerializeMe& rhs );
204
205     bool serialize( IOSerialize& ser );
206     bool deserialize( IODeserialize& deser );
207
208     char             m_char;
209     unsigned char    m_unsigned_char;
210     short            m_short;
211     unsigned short   m_unsigned_short;
212     int              m_int;
213     unsigned int     m_unsigned_int;
214 };
215
216 U2_SerializeMe::U2_SerializeMe()
217     : m_char( 0 )
218     , m_unsigned_char( 0 )
219     , m_short( 0 )
220     , m_unsigned_short( 0 )
221     , m_int( 0 )
222     , m_unsigned_int( 0 )
223 {
224 }
225
226 //--------------------------
227
228 bool
229 U2_SerializeMe::operator == ( const U2_SerializeMe& rhs )
230 {
231     return    ( m_char == rhs.m_char )
232            && ( m_unsigned_char == rhs.m_unsigned_char )
233            && ( m_short == rhs.m_short )
234            && ( m_unsigned_short == rhs.m_unsigned_short )
235            && ( m_int == rhs.m_int )
236            && ( m_unsigned_int == rhs.m_unsigned_int );
237 }
238
239 bool
240 U2_SerializeMe::serialize( IOSerialize& ser )
241 {
242     bool result;
243     result  = ser.write( "m_char", m_char );
244     result &= ser.write( "m_unsigned_char", m_unsigned_char );
245     result &= ser.write( "m_short", m_short );
246     result &= ser.write( "m_unsigned_short", m_unsigned_short );
247     result &= ser.write( "m_int", m_int );
248     result &= ser.write( "m_unsigned_int", m_unsigned_int );
249     return result;
250 }
251
252 bool
253 U2_SerializeMe::deserialize( IODeserialize& deser )
254 {
255     bool result;
256     result  = deser.read( "m_char", m_char );
257     result &= deser.read( "m_unsigned_char", m_unsigned_char );
258     result &= deser.read( "m_short", m_short );
259     result &= deser.read( "m_unsigned_short", m_unsigned_short );
260     result &= deser.read( "m_int", m_int );
261     result &= deser.read( "m_unsigned_int", m_unsigned_int );
262     return result;
263 }
264
265 static bool
266 testU2execute( U2_SerializeMe& sme1 )
267 {
268     {
269         XMLSerialize xmlSerialize( "unittest_u2.xml" );
270         if ( !sme1.serialize( xmlSerialize ) ) {
271             printf( "(serializing failed)" );
272             return false;
273         }
274     }
275
276     U2_SerializeMe sme2;
277
278     {
279         XMLDeserialize xmlDeserialize( "unittest_u2.xml" );
280         if ( !sme2.deserialize( xmlDeserialize ) ) {
281             printf( "(deserializing failed)" );
282             return false;
283         }
284     }
285
286     bool result = sme1 == sme2;
287     if ( !result ) {
288         printf( "(wrong values)" );
289     }
290
291     return result;
292 }
293
294 static bool
295 testU2()
296 {
297     U2_SerializeMe sme1;
298
299     sme1.m_char = 0;
300     sme1.m_unsigned_char = 1;
301     sme1.m_short = 2;
302     sme1.m_unsigned_short = 3;
303     sme1.m_int = 4;
304     sme1.m_unsigned_int = 5;
305
306     bool result;
307     result  = testU2execute( sme1 );
308
309     sme1.m_char = 0xff;
310     sme1.m_unsigned_char = 0xff;
311     sme1.m_short = 0xffff;
312     sme1.m_unsigned_short = 0xffff;
313     sme1.m_int = 0xffffffff;
314     sme1.m_unsigned_int = 0xffffffff;
315
316     result &= testU2execute( sme1 );
317
318     return result;
319 }
320
321 /////////////////////////////////////
322 /////////////////////////////////////
323 /////////////////////////////////////
324
325
326 typedef bool ( *test_func ) ();
327 struct TestEntry {
328     const char* m_pName;
329     test_func m_pFunc;
330 };
331
332 TestEntry TestTable[] = {
333     { "serialize 0",  testU0 },
334     { "serialize 1",  testU1 },
335     { "serialize 2",  testU2 },
336 };
337
338 int
339 main( int argc,  char** argv )
340 {
341     int iNrOfPassedTests = 0;
342     int iNrOfFailedTests = 0;
343     int iNrOfTests = sizeof( TestTable )/sizeof( TestTable[0] );
344
345     for ( int i = 0; i < iNrOfTests ; ++i ) {
346         TestEntry* pEntry = &TestTable[i];
347
348         printf( "Test \"%s\"... ", pEntry->m_pName );
349         if ( pEntry->m_pFunc() ) {
350             puts( " passed" );
351             iNrOfPassedTests++;
352         } else {
353             puts( " failed" );
354             iNrOfFailedTests++;
355         }
356     }
357
358     printf( "passed: %d\n", iNrOfPassedTests );
359     printf( "failed: %d\n", iNrOfFailedTests );
360     printf( "total:  %d\n", iNrOfTests );
361
362     return 0;
363 }
Note: See TracBrowser for help on using the browser.