LRAUV  revA
Str_Test.h
Go to the documentation of this file.
1 
9 #ifndef _STR_TEST_H_
10 #define _STR_TEST_H_
11 
12 #include "utils/Str.h"
13 
14 #include <cxxtest/TestSuite.h>
15 
21 class Str_Test : public CxxTest::TestSuite
22 {
23 public:
24 
26  void testConstructorCharStar( void )
27  {
28  Str str( "1234" );
29  TS_ASSERT_EQUALS( str.length(), 4U );
30  TS_ASSERT_SAME_DATA( str.cStr(), "1234", 5 );
31 
32  Str str3( "1234", 3 );
33  TS_ASSERT_EQUALS( str3.length(), 3U );
34  TS_ASSERT_SAME_DATA( str3.cStr(), "123", 4 );
35 
36  Str str0( "1234", 0 );
37  TS_ASSERT_EQUALS( str0.length(), 0U );
38  TS_ASSERT_EQUALS( str0, Str::EMPTY_STR );
39  TS_ASSERT_SAME_DATA( str0.cStr(), "", 1 );
40 
41  Str strEmpty128( ( char* )NULL, 128 );
42  TS_ASSERT_EQUALS( strEmpty128.length(), 128U );
43  TS_ASSERT_DIFFERS( strEmpty128, Str::EMPTY_STR );
44  TS_ASSERT_SAME_DATA( strEmpty128.cStr(), "", 1 );
45  }
46 
48  void testCopyConstructor( void )
49  {
50  Str str( "1234" );
51 
52  Str strCopy( str );
53  TS_ASSERT_EQUALS( strCopy, str );
54  TS_ASSERT_EQUALS( strCopy.length(), 4U );
55  TS_ASSERT_SAME_DATA( strCopy.cStr(), "1234", 5 );
56 
57  Str strCopy0( str, 0 );
58  TS_ASSERT_EQUALS( strCopy0, str );
59  TS_ASSERT_EQUALS( strCopy0.length(), 4U );
60  TS_ASSERT_SAME_DATA( strCopy0.cStr(), "1234", 5 );
61 
62  Str strCopy1( str, 1 );
63  TS_ASSERT_EQUALS( strCopy1.length(), 3U );
64  TS_ASSERT_SAME_DATA( strCopy1.cStr(), "234", 4 );
65 
66  Str strCopyMax( str, Str::MAX_LEN );
67  TS_ASSERT_EQUALS( strCopyMax.length(), 0U );
68  TS_ASSERT_SAME_DATA( strCopyMax.cStr(), "", 1 );
69 
70  Str strCopy04( str, 0, 4 );
71  TS_ASSERT_EQUALS( strCopy04, str );
72  TS_ASSERT_EQUALS( strCopy04.length(), 4U );
73  TS_ASSERT_SAME_DATA( strCopy04.cStr(), "1234", 5 );
74 
75  Str strCopy0Max( str, 0, Str::MAX_LEN );
76  TS_ASSERT_EQUALS( strCopy0Max, str );
77  TS_ASSERT_EQUALS( strCopy0Max.length(), 4U );
78  TS_ASSERT_SAME_DATA( strCopy0Max.cStr(), "1234", 5 );
79 
80  Str strCopy00( str, 0, 0 );
81  TS_ASSERT_EQUALS( strCopy00.length(), 0U );
82  TS_ASSERT_SAME_DATA( strCopy00.cStr(), "", 1 );
83 
84  Str strCopy02( str, 0, 2 );
85  TS_ASSERT_EQUALS( strCopy02.length(), 2U );
86  TS_ASSERT_SAME_DATA( strCopy02.cStr(), "12", 3 );
87 
88  Str strCopy10( str, 1, 0 );
89  TS_ASSERT_EQUALS( strCopy10.length(), 0U );
90  TS_ASSERT_SAME_DATA( strCopy10.cStr(), "", 1 );
91 
92  Str strCopy12( str, 1, 2 );
93  TS_ASSERT_EQUALS( strCopy12.length(), 2U );
94  TS_ASSERT_SAME_DATA( strCopy12.cStr(), "23", 3 );
95 
96  Str strCopy1Max( str, 1, Str::MAX_LEN );
97  TS_ASSERT_EQUALS( strCopy1Max.length(), 3U );
98  TS_ASSERT_SAME_DATA( strCopy1Max.cStr(), "234", 4 );
99 
100  }
101 
103  void testBoolConstructor( void )
104  {
105  Str strTrue( true );
106  TS_ASSERT_EQUALS( strTrue.length(), 1U );
107  TS_ASSERT_SAME_DATA( strTrue.cStr(), "1", 2 );
108 
109  Str strFalse( false );
110  TS_ASSERT_EQUALS( strFalse.length(), 1U );
111  TS_ASSERT_SAME_DATA( strFalse.cStr(), "0", 2 );
112  }
113 
115  void testDoubleConstructor( void )
116  {
117  Str str0( 1234.0, 0 );
118  TS_ASSERT_EQUALS( str0.length(), 4U );
119  TS_ASSERT_SAME_DATA( str0.cStr(), "1234", 4 );
120  Str str1( 1234.0, 1 );
121  TS_ASSERT_EQUALS( str1.length(), 6U );
122  TS_ASSERT_SAME_DATA( str1.cStr(), "1234.0", 6 );
123  Str str2( 1234.0, 4 );
124  TS_ASSERT_EQUALS( str2.length(), 9U );
125  TS_ASSERT_SAME_DATA( str2.cStr(), "1234.0000", 5 );
126  Str str3( 1234.567, 3 );
127  TS_ASSERT_EQUALS( str3.length(), 8U );
128  TS_ASSERT_SAME_DATA( str3.cStr(), "1234.567", 9 );
129  Str str4( -1234.567, 3 );
130  TS_ASSERT_EQUALS( str4.length(), 9U );
131  TS_ASSERT_SAME_DATA( str4.cStr(), "-1234.567", 10 );
132  }
133 
135  void testIntConstructor( void )
136  {
137  Str str0( 1234 );
138  TS_ASSERT_EQUALS( str0.length(), 4U );
139  TS_ASSERT_SAME_DATA( str0.cStr(), "1234", 5 );
140  Str str1( 1234, 16 );
141  TS_ASSERT_EQUALS( str1.length(), 3U );
142  TS_ASSERT_SAME_DATA( str1.cStr(), "4D2", 4 );
143  Str str2( 1234, 8 );
144  TS_ASSERT_EQUALS( str2.length(), 4U );
145  TS_ASSERT_SAME_DATA( str2.cStr(), "2322", 5 );
146  Str str3( 1234, 2 );
147  TS_ASSERT_EQUALS( str3.length(), 11U );
148  TS_ASSERT_SAME_DATA( str3.cStr(), "10011010010", 12 );
149  Str str4( 1234, 0 );
150  TS_ASSERT_EQUALS( str4.length(), 4U );
151  TS_ASSERT_SAME_DATA( str4.cStr(), "1234", 5 );
152  Str str5( 1234, 1 );
153  TS_ASSERT_EQUALS( str5.length(), 11U );
154  TS_ASSERT_SAME_DATA( str5.cStr(), "10011010010", 12 );
155  Str str6( -1234 );
156  TS_ASSERT_EQUALS( str6.length(), 5U );
157  TS_ASSERT_SAME_DATA( str6.cStr(), "-1234", 6 );
158  Str str7( -1234, 2 );
159  TS_ASSERT_EQUALS( str7.length(), 12U );
160  TS_ASSERT_SAME_DATA( str7.cStr(), "-10011010010", 13 );
161  }
162 
164  void testSizeTConstructor( void )
165  {
166  const size_t val = 1234;
167  Str str0( val );
168  TS_ASSERT_EQUALS( str0.length(), 3U );
169  TS_ASSERT_SAME_DATA( str0.cStr(), "4D2", 4 );
170  Str str1( val, 10 );
171  TS_ASSERT_EQUALS( str1.length(), 4U );
172  TS_ASSERT_SAME_DATA( str1.cStr(), "1234", 4 );
173  Str str2( val, 8 );
174  TS_ASSERT_EQUALS( str2.length(), 4U );
175  TS_ASSERT_SAME_DATA( str2.cStr(), "2322", 5 );
176  Str str3( val, 2 );
177  TS_ASSERT_EQUALS( str3.length(), 11U );
178  TS_ASSERT_SAME_DATA( str3.cStr(), "10011010010", 12 );
179  Str str4( val, 0 );
180  TS_ASSERT_EQUALS( str4.length(), 4U );
181  TS_ASSERT_SAME_DATA( str4.cStr(), "1234", 5 );
182  Str str5( val, 1 );
183  TS_ASSERT_EQUALS( str5.length(), 11U );
184  TS_ASSERT_SAME_DATA( str5.cStr(), "10011010010", 12 );
185  }
186 
188  void testIntToAscii( void )
189  {
190  int i, len;
191  char buffer[34];
192  i = 0;
193  len = Str::IntToAscii( i, buffer, 10, 34 );
194  TS_ASSERT_SAME_DATA( buffer, "0", len + 1 );
195  i = 5;
196  len = Str::IntToAscii( i, buffer, 10, 34 );
197  TS_ASSERT_SAME_DATA( buffer, "5", len + 1 );
198  i = 10;
199  len = Str::IntToAscii( i, buffer, 10, 34 );
200  TS_ASSERT_SAME_DATA( buffer, "10", len + 1 );
201  i = -10;
202  len = Str::IntToAscii( i, buffer, 10, 34 );
203  TS_ASSERT_SAME_DATA( buffer, "-10", len + 1 );
204  i = 100;
205  len = Str::IntToAscii( i, buffer, 10, 34 );
206  TS_ASSERT_SAME_DATA( buffer, "100", len + 1 );
207  i = -100;
208  len = Str::IntToAscii( i, buffer, 10, 34 );
209  TS_ASSERT_SAME_DATA( buffer, "-100", len + 1 );
210  i = 0x7FFFFFFF;
211  len = Str::IntToAscii( i, buffer, 10, 34 );
212  TS_ASSERT_SAME_DATA( buffer, "2147483647", len + 1 );
213  i = -0x80000000;
214  len = Str::IntToAscii( i, buffer, 10, 34 );
215  TS_ASSERT_SAME_DATA( buffer, "-2147483648", len + 1 );
216  i = 0x7FFFFFFF;
217  len = Str::IntToAscii( i, buffer, 2, 34 );
218  TS_ASSERT_SAME_DATA( buffer, "1111111111111111111111111111111", len + 1 );
219  i = -0x80000000;
220  len = Str::IntToAscii( i, buffer, 2, 34 );
221  TS_ASSERT_SAME_DATA( buffer, "-10000000000000000000000000000000", len + 1 );
222  i = -0x7FFFFFFF;
223  len = Str::IntToAscii( i, buffer, 2, 34 );
224  TS_ASSERT_SAME_DATA( buffer, "-1111111111111111111111111111111", len + 1 );
225  i = 1;
226  len = Str::IntToAscii( i, buffer, 2, 34 );
227  TS_ASSERT_SAME_DATA( buffer, "1", len + 1 );
228  i = 0x7FFFFFFF;
229  len = Str::IntToAscii( i, buffer, 16, 34 );
230  TS_ASSERT_SAME_DATA( buffer, "7FFFFFFF", len + 1 );
231  i = -0x80000000;
232  len = Str::IntToAscii( i, buffer, 16, 34 );
233  TS_ASSERT_SAME_DATA( buffer, "-80000000", len + 1 );
234  i = -0x7FFFFFFF;
235  len = Str::IntToAscii( i, buffer, 16, 34 );
236  TS_ASSERT_SAME_DATA( buffer, "-7FFFFFFF", len + 1 );
237  i = 0xF;
238  len = Str::IntToAscii( i, buffer, 16, 34 );
239  TS_ASSERT_SAME_DATA( buffer, "F", len + 1 );
240  }
241 
243  void testIntToAsciiWithOffset( void )
244  {
245  int i, len;
246  char buffer[34];
247  i = 0;
248  len = Str::IntToAscii( i, buffer, 10, 34, 10 );
249  TS_ASSERT_SAME_DATA( buffer, "A", len + 1 );
250  i = 5;
251  len = Str::IntToAscii( i, buffer, 26, 34, 10 );
252  TS_ASSERT_SAME_DATA( buffer, "F", len + 1 );
253  i = 10;
254  len = Str::IntToAscii( i, buffer, 26, 34, 10 );
255  TS_ASSERT_SAME_DATA( buffer, "K", len + 1 );
256  i = -10;
257  len = Str::IntToAscii( i, buffer, 26, 34, 10 );
258  TS_ASSERT_SAME_DATA( buffer, "-K", len + 1 );
259  i = 100;
260  len = Str::IntToAscii( i, buffer, 26, 34, 10 );
261  TS_ASSERT_SAME_DATA( buffer, "DV", len + 1 );
262  i = -100;
263  len = Str::IntToAscii( i, buffer, 26, 34, 10 );
264  TS_ASSERT_SAME_DATA( buffer, "-DV", len + 1 );
265  }
266 
267  void testFindLastOf()
268  {
269  Str testStr = "0123456789";
270  TS_ASSERT_EQUALS( testStr.findLastOf( '8' ), ( size_t )8 );
271  TS_ASSERT_EQUALS( testStr.findLastOf( "67" ), ( size_t )6 );
272  TS_ASSERT_EQUALS( testStr.findLastOf( "679" ), Str::NO_POS );
273  }
274 
275  void testSplit()
276  {
277  Str testStr = "1++22+333";
278  int num;
279  Str* split = testStr.split( num, "+" );
280  TS_ASSERT_EQUALS( num, 4 );
281  TS_ASSERT_SAME_DATA( split[0].cStr(), "1", 2 );
282  TS_ASSERT_SAME_DATA( split[1].cStr(), "", 1 );
283  TS_ASSERT_SAME_DATA( split[2].cStr(), "22", 3 );
284  TS_ASSERT_SAME_DATA( split[3].cStr(), "333", 4 );
285  delete[] split;
286  }
287 
288  void testAsHex()
289  {
290  const char chars1[] = { 0x00, 0x79 };
291  Str str1( chars1, sizeof( chars1 ) );
292  Str strHex1 = str1.asHex();
293  TS_ASSERT_EQUALS( strHex1.length(), 4U );
294  TS_ASSERT_SAME_DATA( strHex1.cStr(), "0079", 5 );
295  }
296 };
297 
298 #endif // _STR_TEST_H
Str_Test::testBoolConstructor
void testBoolConstructor(void)
Units tests for Str( const bool var );
Definition: Str_Test.h:103
Str::MAX_LEN
static const size_t MAX_LEN
Definition: Str.h:18
Str::asHex
Str asHex() const
Return a new Str, with a hex representation of each character of this string.
Definition: Str.cpp:467
Str::length
size_t length() const
Definition: Str.h:196
Str::NO_POS
static const size_t NO_POS
static constants
Definition: Str.h:17
Str_Test::testAsHex
void testAsHex()
Definition: Str_Test.h:288
Str_Test::testIntConstructor
void testIntConstructor(void)
Units tests for Str( const int var, size_t radix = 10 )
Definition: Str_Test.h:135
Str_Test::testCopyConstructor
void testCopyConstructor(void)
Units tests for Str( const Str& str, const size_t offset = 0, size_t count = NO_POS ); ...
Definition: Str_Test.h:48
Str_Test::testIntToAsciiWithOffset
void testIntToAsciiWithOffset(void)
Str::IntToAscii Unit Tests.
Definition: Str_Test.h:243
Str
Replacement for standard template class string.
Definition: Str.h:12
Str::findLastOf
size_t findLastOf(const unsigned char str) const
returns the position of the specified character in the string, looking from the end of the string tow...
Definition: Str.cpp:247
Str_Test::testSizeTConstructor
void testSizeTConstructor(void)
Units tests for Str( const unsigned int var, size_t radix = 16 )
Definition: Str_Test.h:164
Str_Test::testIntToAscii
void testIntToAscii(void)
Str::IntToAscii Unit Tests.
Definition: Str_Test.h:188
Str_Test
Units tests for class Str
Definition: Str_Test.h:21
Str::cStr
const char * cStr() const
Definition: Str.h:188
Str_Test::testConstructorCharStar
void testConstructorCharStar(void)
Units tests for Str( const char* str = NULL, size_t length = NO_POS );
Definition: Str_Test.h:26
Str::EMPTY_STR
static const Str EMPTY_STR
Definition: Str.h:19
Str_Test::testFindLastOf
void testFindLastOf()
Definition: Str_Test.h:267
Str_Test::testDoubleConstructor
void testDoubleConstructor(void)
Units tests for Str( const double var, size_t precision = 10 )
Definition: Str_Test.h:115
Str::split
Str * split(int &num, const char *splitSpec, size_t length=NO_POS) const
Definition: Str.cpp:429
Str::IntToAscii
static unsigned int IntToAscii(int value, char *str, unsigned int base, unsigned int bufSize, unsigned int baseOffset=0)
convert an integer to a string, returns the length of the string Unit tests in Str_Test.testIntToAscii
Definition: Str.cpp:371
Str_Test::testSplit
void testSplit()
Definition: Str_Test.h:275