]> git.saurik.com Git - wxWidgets.git/blob - tests/base64/base64.cpp
Try native method first in LoadFile() and SaveFile()
[wxWidgets.git] / tests / base64 / base64.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: tests/base64/base64.cpp
3 // Purpose: wxBase64Encode/Decode unit test
4 // Author: Charles Reimers
5 // Created: 2007-06-22
6 ///////////////////////////////////////////////////////////////////////////////
7
8 // ----------------------------------------------------------------------------
9 // headers
10 // ----------------------------------------------------------------------------
11
12 #include "testprec.h"
13
14 #ifdef __BORLANDC__
15 #pragma hdrstop
16 #endif
17
18 #ifndef WX_PRECOMP
19 #include "wx/wx.h"
20 #endif // WX_PRECOMP
21
22 #if wxUSE_BASE64
23
24 #include "wx/base64.h"
25
26 static const char encoded0to255[] =
27 "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIj"
28 "JCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZH"
29 "SElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWpr"
30 "bG1ub3BxcnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6P"
31 "kJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKz"
32 "tLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX"
33 "2Nna29zd3t/g4eLj5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7"
34 "/P3+/w==";
35
36 static void
37 generatePatternedData(void* buff, size_t len, unsigned char startVal,
38 unsigned char addVal, unsigned char multVal = 1,
39 unsigned char xorMask = 0, unsigned char andMask = 255)
40 {
41 unsigned char *cbuff = (unsigned char *)buff;
42 unsigned char curval = startVal;
43 while(len--)
44 {
45 *(cbuff++) = curval;
46 curval = (((curval + addVal) * multVal) ^ xorMask) & andMask;
47 }
48 }
49
50 static void generateRandomData(void* buff, size_t len)
51 {
52 unsigned char *cbuff = (unsigned char *)buff;
53 while(len--)
54 {
55 *(cbuff++) = (unsigned char)(((rand() * 255) / RAND_MAX));
56 }
57 }
58
59 static void generateGibberish(void* buff, size_t len)
60 {
61 static const unsigned char cb64[] =
62 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
63
64 unsigned char *cbuff = (unsigned char *)buff;
65 while(len--)
66 {
67 *(cbuff++) = cb64[((rand() * 64) / RAND_MAX)];
68 }
69 }
70
71 // --------------------------------------------------------------------------
72 // test class
73 // --------------------------------------------------------------------------
74
75 class Base64TestCase : public CppUnit::TestCase
76 {
77 public:
78 Base64TestCase() { }
79
80 private:
81 CPPUNIT_TEST_SUITE( Base64TestCase );
82 CPPUNIT_TEST( EncodeDecodeEmpty );
83 CPPUNIT_TEST( EncodeDecodeA );
84 CPPUNIT_TEST( EncodeDecodeAB );
85 CPPUNIT_TEST( EncodeDecodeABC );
86 CPPUNIT_TEST( EncodeDecodeABCD );
87 CPPUNIT_TEST( EncodeDecode0to255 );
88 CPPUNIT_TEST( EncodeDecodePatternA );
89 CPPUNIT_TEST( EncodeDecodePatternB );
90 CPPUNIT_TEST( EncodeDecodePatternC );
91 CPPUNIT_TEST( EncodeDecodeRandom );
92 CPPUNIT_TEST( DecodeInvalid );
93 CPPUNIT_TEST_SUITE_END();
94
95 void EncodeDecodeEmpty();
96 void EncodeDecodeA();
97 void EncodeDecodeAB();
98 void EncodeDecodeABC();
99 void EncodeDecodeABCD();
100 void EncodeDecode0to255();
101 void EncodeDecodePatternA();
102 void EncodeDecodePatternB();
103 void EncodeDecodePatternC();
104 void EncodeDecodeRandom();
105 void DecodeInvalid();
106
107 DECLARE_NO_COPY_CLASS(Base64TestCase)
108 };
109
110 // register in the unnamed registry so that these tests are run by default
111 CPPUNIT_TEST_SUITE_REGISTRATION( Base64TestCase );
112
113 // also include in its own registry so that these tests can be run alone
114 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( Base64TestCase, "Base64TestCase" );
115
116 void Base64TestCase::EncodeDecodeEmpty()
117 {
118 char shouldBeEmpty[10];
119 shouldBeEmpty[0] = '\0';
120 size_t len = 10;
121
122 CPPUNIT_ASSERT(wxBase64Encode(shouldBeEmpty, len, "", 0) != wxCONV_FAILED);
123 CPPUNIT_ASSERT_EQUAL('\0', shouldBeEmpty[0]);
124
125 CPPUNIT_ASSERT(wxBase64Decode(shouldBeEmpty, len, "") != wxCONV_FAILED);
126 CPPUNIT_ASSERT_EQUAL('\0', shouldBeEmpty[0]);
127
128 wxMemoryBuffer bufmt;
129 wxString resultEmpty = wxBase64Encode(bufmt);
130 CPPUNIT_ASSERT(resultEmpty.empty());
131
132 bufmt = wxBase64Decode(resultEmpty);
133 CPPUNIT_ASSERT_EQUAL(0, bufmt.GetDataLen());
134 }
135
136 void Base64TestCase::EncodeDecodeA()
137 {
138 const wxString str = wxBase64Encode("A", 1);
139 CPPUNIT_ASSERT_EQUAL(wxString("QQ=="), str);
140
141 wxMemoryBuffer buf = wxBase64Decode(str);
142 CPPUNIT_ASSERT_EQUAL(1, buf.GetDataLen());
143 CPPUNIT_ASSERT_EQUAL('A', *(char *)buf.GetData());
144
145 char cbuf[10];
146 memset(cbuf, (char)-1, sizeof(cbuf));
147 CPPUNIT_ASSERT_EQUAL( 1, wxBase64Decode(cbuf, 1, str) );
148 CPPUNIT_ASSERT_EQUAL( 'A', cbuf[0] );
149 CPPUNIT_ASSERT_EQUAL( (char)-1, cbuf[1] );
150 CPPUNIT_ASSERT_EQUAL( (char)-1, cbuf[2] );
151 }
152
153 void Base64TestCase::EncodeDecodeAB()
154 {
155 const wxString str = wxBase64Encode("AB", 2);
156 CPPUNIT_ASSERT_EQUAL(wxString("QUI="), str);
157
158 wxMemoryBuffer buf = wxBase64Decode(str);
159 CPPUNIT_ASSERT_EQUAL(2, buf.GetDataLen());
160 CPPUNIT_ASSERT_EQUAL('A', buf[0]);
161 CPPUNIT_ASSERT_EQUAL('B', buf[1]);
162
163 char cbuf[10];
164 memset(cbuf, (char)-1, sizeof(cbuf));
165 CPPUNIT_ASSERT_EQUAL( wxCONV_FAILED, wxBase64Decode(cbuf, 1, str) );
166 CPPUNIT_ASSERT_EQUAL( 2, wxBase64Decode(cbuf, 2, str) );
167 CPPUNIT_ASSERT_EQUAL( 'A', cbuf[0] );
168 CPPUNIT_ASSERT_EQUAL( 'B', cbuf[1] );
169 CPPUNIT_ASSERT_EQUAL( (char)-1, cbuf[2] );
170 CPPUNIT_ASSERT_EQUAL( (char)-1, cbuf[3] );
171 }
172
173 void Base64TestCase::EncodeDecodeABC()
174 {
175 const wxString str = wxBase64Encode("ABC", 3);
176 CPPUNIT_ASSERT_EQUAL(wxString("QUJD"), str);
177
178 wxMemoryBuffer buf = wxBase64Decode(str);
179 CPPUNIT_ASSERT_EQUAL(3, buf.GetDataLen());
180 CPPUNIT_ASSERT_EQUAL('A', buf[0]);
181 CPPUNIT_ASSERT_EQUAL('B', buf[1]);
182 CPPUNIT_ASSERT_EQUAL('C', buf[2]);
183
184 char cbuf[10];
185 memset(cbuf, (char)-1, sizeof(cbuf));
186 CPPUNIT_ASSERT_EQUAL( wxCONV_FAILED, wxBase64Decode(cbuf, 2, str) );
187 CPPUNIT_ASSERT_EQUAL( 3, wxBase64Decode(cbuf, 3, str) );
188 CPPUNIT_ASSERT_EQUAL( 'A', cbuf[0] );
189 CPPUNIT_ASSERT_EQUAL( 'B', cbuf[1] );
190 CPPUNIT_ASSERT_EQUAL( 'C', cbuf[2] );
191 CPPUNIT_ASSERT_EQUAL( (char)-1, cbuf[3] );
192 CPPUNIT_ASSERT_EQUAL( (char)-1, cbuf[4] );
193 }
194
195 void Base64TestCase::EncodeDecodeABCD()
196 {
197 const wxString str = wxBase64Encode("ABCD", 4);
198 CPPUNIT_ASSERT_EQUAL(wxString("QUJDRA=="), str);
199
200 wxMemoryBuffer buf = wxBase64Decode(str);
201 CPPUNIT_ASSERT_EQUAL(4, buf.GetDataLen());
202 CPPUNIT_ASSERT_EQUAL('A', buf[0]);
203 CPPUNIT_ASSERT_EQUAL('B', buf[1]);
204 CPPUNIT_ASSERT_EQUAL('C', buf[2]);
205 CPPUNIT_ASSERT_EQUAL('D', buf[3]);
206
207 char cbuf[10];
208 memset(cbuf, (char)-1, sizeof(cbuf));
209 CPPUNIT_ASSERT_EQUAL( wxCONV_FAILED, wxBase64Decode(cbuf, 3, str) );
210 CPPUNIT_ASSERT_EQUAL( 4, wxBase64Decode(cbuf, 4, str) );
211 CPPUNIT_ASSERT_EQUAL( 'A', cbuf[0] );
212 CPPUNIT_ASSERT_EQUAL( 'B', cbuf[1] );
213 CPPUNIT_ASSERT_EQUAL( 'C', cbuf[2] );
214 CPPUNIT_ASSERT_EQUAL( 'D', cbuf[3] );
215 CPPUNIT_ASSERT_EQUAL( (char)-1, cbuf[4] );
216 CPPUNIT_ASSERT_EQUAL( (char)-1, cbuf[5] );
217 }
218
219 void Base64TestCase::EncodeDecode0to255()
220 {
221 unsigned char buff[256];
222 generatePatternedData(buff, 256, 0, 1);
223 wxString str = wxBase64Encode(buff, 256);
224 wxMemoryBuffer mbuff = wxBase64Decode(str);
225 CPPUNIT_ASSERT(memcmp(mbuff.GetData(), buff, mbuff.GetDataLen()) == 0);
226
227 mbuff = wxBase64Decode(encoded0to255);
228 CPPUNIT_ASSERT(memcmp(mbuff.GetData(), buff, mbuff.GetDataLen()) == 0);
229 }
230
231 void Base64TestCase::EncodeDecodePatternA()
232 {
233 unsigned char buff[350];
234 generatePatternedData(buff, 350, 24, 5, 3);
235 wxString str = wxBase64Encode(buff, 350);
236 wxMemoryBuffer mbuff = wxBase64Decode(str);
237 CPPUNIT_ASSERT(memcmp(mbuff.GetData(), buff, mbuff.GetDataLen()) == 0);
238 }
239
240 void Base64TestCase::EncodeDecodePatternB()
241 {
242 unsigned char buff[350];
243 generatePatternedData(buff, 350, 0, 1, 1, 0xAA);
244 wxString str = wxBase64Encode(buff, 350);
245 wxMemoryBuffer mbuff = wxBase64Decode(str);
246 CPPUNIT_ASSERT(memcmp(mbuff.GetData(), buff, mbuff.GetDataLen()) == 0);
247 }
248
249 void Base64TestCase::EncodeDecodePatternC()
250 {
251 unsigned char buff[11];
252 generatePatternedData(buff, 11, 1, 0, 2);
253 wxString str = wxBase64Encode(buff, 11);
254 wxMemoryBuffer mbuff = wxBase64Decode(str);
255 CPPUNIT_ASSERT(memcmp(mbuff.GetData(), buff, mbuff.GetDataLen()) == 0);
256 }
257
258 void Base64TestCase::EncodeDecodeRandom()
259 {
260 size_t size = rand() * 3000 / RAND_MAX + 11;
261 unsigned char *buff = new unsigned char[size];
262 generateRandomData(buff, size);
263 wxString str = wxBase64Encode(buff, size);
264 wxMemoryBuffer mbuff = wxBase64Decode(str);
265 CPPUNIT_ASSERT(memcmp(mbuff.GetData(), buff, mbuff.GetDataLen()) == 0);
266
267 generateGibberish(buff, size);
268 char *buff2 = new char[size];
269 size_t realsize = size;
270 CPPUNIT_ASSERT(wxBase64Decode(buff2, realsize, (char *)buff, size));
271 CPPUNIT_ASSERT(wxBase64Encode(buff2, size, buff2, realsize));
272 }
273
274 void Base64TestCase::DecodeInvalid()
275 {
276 size_t rc, posErr;
277 rc = wxBase64Decode(NULL, 0, "one two!", wxNO_LEN,
278 wxBase64DecodeMode_Strict, &posErr);
279 CPPUNIT_ASSERT_EQUAL( wxCONV_FAILED, rc);
280 CPPUNIT_ASSERT_EQUAL( 3, posErr );
281
282 rc = wxBase64Decode(NULL, 0, "one two!", wxNO_LEN,
283 wxBase64DecodeMode_SkipWS, &posErr);
284 CPPUNIT_ASSERT_EQUAL( wxCONV_FAILED, rc);
285 CPPUNIT_ASSERT_EQUAL( 7, posErr );
286
287 rc = wxBase64Decode(NULL, 0, "? QQ==", wxNO_LEN,
288 wxBase64DecodeMode_SkipWS, &posErr);
289 CPPUNIT_ASSERT_EQUAL( wxCONV_FAILED, rc);
290 CPPUNIT_ASSERT_EQUAL( 0, posErr );
291
292 posErr = (size_t)-1;
293 rc = wxBase64Decode(NULL, 0, " QQ==", wxNO_LEN,
294 wxBase64DecodeMode_SkipWS, &posErr);
295 CPPUNIT_ASSERT_EQUAL( 1, rc );
296 CPPUNIT_ASSERT_EQUAL( -1, posErr );
297
298 rc = wxBase64Decode(NULL, 0, "? QQ==", wxNO_LEN,
299 wxBase64DecodeMode_Relaxed, &posErr);
300 CPPUNIT_ASSERT_EQUAL( 1, rc );
301 CPPUNIT_ASSERT_EQUAL( -1, posErr );
302
303 CPPUNIT_ASSERT( !wxBase64Decode("wxGetApp()").GetDataLen() );
304 }
305
306 #endif // wxUSE_BASE64