Menu

[r1477]: / advanced / src / cpp / test / test.cpp  Maximize  Restore  History

Download this file

641 lines (547 with data), 20.8 kB

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
#include <string>
#include <iostream>
#include <iomanip>
#include <vector>
#include <sstream>
#include <memory>
#include <time.h>
#include "xmlrpc-c/girerr.hpp"
using girerr::error;
#include "transport_config.h"
#include "xmlrpc-c/base.hpp"
#include "xmlrpc-c/oldcppwrapper.hpp"
#include "xmlrpc-c/registry.hpp"
#include "testclient.hpp"
#include "registry.hpp"
#include "server_abyss.hpp"
#include "server_pstream.hpp"
#include "tools.hpp"
using namespace xmlrpc_c;
using namespace std;
//=========================================================================
// Test Harness
//=========================================================================
//
// There are two styles of test in here. The older ones are vaguely
// inspired by Kent Beck's book on eXtreme Programming (XP) and use
// the TEST...() macros.
//
// But this style is not really appropriate for C++. It's based on
// code that explicitly tests for errors, as one would do in C. In C++,
// it is cumbersome to catch exceptions on every call, so we don't in
// the new style.
// And there's not much point in trying to count test successes and
// failures. Any failure is a problem, so in the new style, we just
// quit after we recognize one (again, more in line with regular exception
// throwing). With exception throwing, you can't count what _didn't_
// cause an exception, so there's no meaningful count of test successes.
//
// To run the tests, type './cpptest'.
// To check for memory leaks, install RedHat's 'memprof' utility, and
// type 'memprof cpptest'.
//
// If you add new tests to this file, please deallocate any data
// structures you use in the appropriate fashion. This allows us to test
// various destructor code for memory leaks.
//=========================================================================
// Test Suites
//=========================================================================
void
test_fault (void) {
// Create a new fault and perform basic operations.
XmlRpcFault fault1 = XmlRpcFault(6, "Sample fault");
TEST(fault1.getFaultCode() == 6);
TEST(fault1.getFaultString() == "Sample fault");
// Extract and examine the underlying xmlrpc_env struct.
xmlrpc_env *env1 = fault1.getFaultEnv();
TEST(env1 != NULL);
TEST(env1->fault_occurred);
TEST(env1->fault_code == 6);
TEST(strcmp(env1->fault_string, "Sample fault") == 0);
// Test our copy constructor.
XmlRpcFault fault2 = fault1;
TEST(fault2.getFaultCode() == 6);
TEST(fault2.getFaultString() == "Sample fault");
// Construct a fault from a pre-existing xmlrpc_env structure.
xmlrpc_env env3;
xmlrpc_env_init(&env3);
xmlrpc_env_set_fault(&env3, 7, "Another fault");
XmlRpcFault fault3 = XmlRpcFault(&env3);
xmlrpc_env_clean(&env3);
TEST(fault3.getFaultCode() == 7);
TEST(fault3.getFaultString() == "Another fault");
// Attempt to construct a fault from a fault-free xmlrpc_env.
xmlrpc_env env4;
xmlrpc_env_init(&env4);
try {
XmlRpcFault fault4 = XmlRpcFault(&env4);
TEST_FAILED("Constructed invalid XmlRpcFault");
} catch (XmlRpcFault const& fault) {
TEST_PASSED();
TEST(fault.getFaultCode() == XMLRPC_INTERNAL_ERROR);
}
xmlrpc_env_clean(&env4);
}
void test_env (void) {
// Declare these here to prevent silly compiler warnings about
// potentially uninitialized variables.
XmlRpcEnv env1;
XmlRpcEnv env2;
// Perform simple environment tests.
TEST(!env1.hasFaultOccurred());
xmlrpc_env_set_fault(env1, 8, "Fault 8");
TEST(env1.hasFaultOccurred());
XmlRpcFault fault1 = env1.getFault();
TEST(fault1.getFaultCode() == 8);
TEST(fault1.getFaultString() == "Fault 8");
// Test throwIfFaultOccurred.
try {
env2.throwIfFaultOccurred();
TEST_PASSED();
} catch (XmlRpcFault const&) {
TEST_FAILED("We threw a fault when one hadn't occurred");
}
xmlrpc_env_set_fault(env2, 9, "Fault 9");
try {
env2.throwIfFaultOccurred();
TEST_FAILED("A fault occurred, and we didn't throw it");
} catch (XmlRpcFault const& fault) {
TEST_PASSED();
TEST(fault.getFaultCode() == 9);
TEST(fault.getFaultString() == "Fault 9");
}
// Make sure we can't get a fault if one hasn't occurred.
XmlRpcEnv env3;
try {
XmlRpcFault fault3 = env3.getFault();
TEST_FAILED("We retrieved a non-existant fault");
} catch (XmlRpcFault const& fault) {
TEST_PASSED();
TEST(fault.getFaultCode() == XMLRPC_INTERNAL_ERROR);
}
}
void test_value (void) {
XmlRpcEnv env;
// Test basic reference counting behavior.
xmlrpc_value *v = xmlrpc_build_value(env, "i", (xmlrpc_int32) 1);
env.throwIfFaultOccurred();
XmlRpcValue val1 = XmlRpcValue(v, XmlRpcValue::CONSUME_REFERENCE);
v = xmlrpc_build_value(env, "i", (xmlrpc_int32) 2);
env.throwIfFaultOccurred();
XmlRpcValue val2 = v;
xmlrpc_DECREF(v);
// Borrow a reference.
v = xmlrpc_build_value(env, "i", (xmlrpc_int32) 3);
env.throwIfFaultOccurred();
XmlRpcValue val3 = XmlRpcValue(v, XmlRpcValue::CONSUME_REFERENCE);
xmlrpc_value *borrowed = val3.borrowReference();
TEST(borrowed == v);
// Make a reference.
v = xmlrpc_build_value(env, "i", (xmlrpc_int32) 4);
env.throwIfFaultOccurred();
XmlRpcValue val4 = XmlRpcValue(v, XmlRpcValue::CONSUME_REFERENCE);
xmlrpc_value *made = val4.makeReference();
TEST(made == v);
xmlrpc_DECREF(made);
// Test our default constructor.
XmlRpcValue val5;
TEST(val5.getBool() == false);
// Test our type introspection.
TEST(XmlRpcValue::makeInt(0).getType() == XMLRPC_TYPE_INT);
// Test our basic data types.
TEST(XmlRpcValue::makeInt(30).getInt() == 30);
TEST(XmlRpcValue::makeInt(-30).getInt() == -30);
TEST(XmlRpcValue::makeBool(true).getBool() == true);
TEST(XmlRpcValue::makeBool(false).getBool() == false);
TEST(XmlRpcValue::makeDateTime("19980717T14:08:55").getRawDateTime() ==
"19980717T14:08:55");
TEST(XmlRpcValue::makeString("foo").getString() == "foo");
TEST(XmlRpcValue::makeString("bar", 3).getString() == "bar");
TEST(XmlRpcValue::makeString("bar", 3).getString() == "bar");
TEST(XmlRpcValue::makeString("a\0b").getString() == string("a\0b"));
XmlRpcValue::makeArray().getArray();
XmlRpcValue::makeStruct().getStruct();
// Test Base64 values.
const unsigned char *b64_data;
size_t b64_len;
XmlRpcValue val6 = XmlRpcValue::makeBase64((unsigned char*) "a\0\0b", 4);
val6.getBase64(b64_data, b64_len);
TEST(b64_len == 4);
TEST(memcmp(b64_data, "a\0\0b", 4) == 0);
// Test arrays.
XmlRpcValue array = XmlRpcValue::makeArray();
TEST(array.arraySize() == 0);
array.arrayAppendItem(XmlRpcValue::makeString("foo"));
TEST(array.arraySize() == 1);
array.arrayAppendItem(XmlRpcValue::makeString("bar"));
TEST(array.arraySize() == 2);
TEST(array.arrayGetItem(0).getString() == "foo");
TEST(array.arrayGetItem(1).getString() == "bar");
// Test structs.
XmlRpcValue strct = XmlRpcValue::makeStruct();
TEST(strct.structSize() == 0);
strct.structSetValue("foo", XmlRpcValue::makeString("fooval"));
TEST(strct.structSize() == 1);
strct.structSetValue("bar", XmlRpcValue::makeString("barval"));
TEST(strct.structSize() == 2);
TEST(strct.structHasKey("bar"));
TEST(!strct.structHasKey("nosuch"));
for (size_t i = 0; i < strct.structSize(); i++) {
string key;
XmlRpcValue value;
strct.structGetKeyAndValue(i, key, value);
TEST(key + "val" == value.getString());
}
}
static void
testXmlRpcCpp() {
/*----------------------------------------------------------------------------
Test the legacy XmlRpcCpp.cpp library
-----------------------------------------------------------------------------*/
cout << "Testing XmlRpcCpp library..." << endl;
test_fault();
test_env();
test_value();
}
class intTestSuite : public testSuite {
public:
virtual string suiteName() {
return "intTestSuite";
}
virtual void runtests(unsigned int const) {
value_int int1(7);
TEST(static_cast<int>(int1) == 7);
value_int int2(-7);
TEST(static_cast<int>(int2) == -7);
value val1(int1);
TEST(val1.type() == value::TYPE_INT);
value_int int3(val1);
TEST(static_cast<int>(int3) == 7);
try {
value_int int4(value_double(3.7));
TEST_FAILED("invalid cast double-int suceeded");
} catch (error) {}
}
};
class doubleTestSuite : public testSuite {
public:
virtual string suiteName() {
return "doubleTestSuite";
}
virtual void runtests(unsigned int const) {
value_double double1(3.14);
TEST(static_cast<double>(double1) == 3.14);
value val1(double1);
TEST(val1.type() == value::TYPE_DOUBLE);
value_double double2(val1);
TEST(static_cast<double>(double2) == 3.14);
try {
value_double double4(value_int(4));
TEST_FAILED("invalid cast int-double suceeded");
} catch (error) {}
}
};
class booleanTestSuite : public testSuite {
public:
virtual string suiteName() {
return "booleanTestSuite";
}
virtual void runtests(unsigned int const) {
value_boolean boolean1(true);
TEST(static_cast<bool>(boolean1) == true);
value_boolean boolean2(false);
TEST(static_cast<bool>(boolean2) == false);
value val1(boolean1);
TEST(val1.type() == value::TYPE_BOOLEAN);
value_boolean boolean3(val1);
TEST(static_cast<bool>(boolean3) == true);
try {
value_boolean boolean4(value_int(4));
TEST_FAILED("invalid cast int-boolean suceeded");
} catch (error) {}
}
};
class datetimeTestSuite : public testSuite {
public:
virtual string suiteName() {
return "datetimeTestSuite";
}
virtual void runtests(unsigned int const) {
time_t const testTime(900684535);
value_datetime datetime1("19980717T14:08:55");
TEST(static_cast<time_t>(datetime1) == testTime);
value_datetime datetime2(testTime);
TEST(static_cast<time_t>(datetime2) == testTime);
value val1(datetime1);
TEST(val1.type() == value::TYPE_DATETIME);
value_datetime datetime3(val1);
TEST(static_cast<time_t>(datetime3) == testTime);
try {
value_datetime datetime4(value_int(4));
TEST_FAILED("invalid cast int-datetime suceeded");
} catch (error) {}
}
};
class stringTestSuite : public testSuite {
public:
virtual string suiteName() {
return "stringTestSuite";
}
virtual void runtests(unsigned int const) {
value_string string1("hello world");
TEST(static_cast<string>(string1) == "hello world");
value_string string2("embedded\0null");
TEST(static_cast<string>(string2) == "embedded\0null");
value val1(string1);
TEST(val1.type() == value::TYPE_STRING);
value_string string3(val1);
TEST(static_cast<string>(string3) == "hello world");
try {
value_string string4(value_int(4));
TEST_FAILED("invalid cast int-string succeeded");
} catch (error) {}
value_string string5("hello world", value_string::nlCode_all);
TEST(static_cast<string>(string5) == "hello world");
value_string string6("hello\nthere\rworld\r\n\n",
value_string::nlCode_all);
TEST(static_cast<string>(string6) == "hello\nthere\nworld\n\n");
TEST(string6.crlfValue() == "hello\r\nthere\r\nworld\r\n\r\n");
value_string string7("hello\nthere\rworld\r\n\n",
value_string::nlCode_lf);
TEST(static_cast<string>(string7) == "hello\nthere\rworld\r\n\n");
}
};
class bytestringTestSuite : public testSuite {
public:
virtual string suiteName() {
return "bytestringTestSuite";
}
virtual void runtests(unsigned int const) {
unsigned char bytestringArray[] = {0x10, 0x11, 0x12, 0x13, 0x14};
vector<unsigned char>
bytestringData(&bytestringArray[0], &bytestringArray[4]);
value_bytestring bytestring1(bytestringData);
vector<unsigned char> const dataReadBack1(
bytestring1.vectorUcharValue());
TEST(dataReadBack1 == bytestringData);
value val1(bytestring1);
TEST(val1.type() == value::TYPE_BYTESTRING);
value_bytestring bytestring2(val1);
vector<unsigned char> const dataReadBack2(
bytestring2.vectorUcharValue());
TEST(dataReadBack2 == bytestringData);
try {
value_bytestring bytestring4(value_int(4));
TEST_FAILED("invalid cast int-bytestring suceeded");
} catch (error) {}
}
};
class nilTestSuite : public testSuite {
public:
virtual string suiteName() {
return "nilTestSuite";
}
virtual void runtests(unsigned int const) {
value_nil nil1;
value val1(nil1);
TEST(val1.type() == value::TYPE_NIL);
value_nil nil2(val1);
try {
value_nil nil4(value_int(4));
TEST_FAILED("invalid cast int-nil suceeded");
} catch (error) {}
}
};
class i8TestSuite : public testSuite {
public:
virtual string suiteName() {
return "i8TestSuite";
}
virtual void runtests(unsigned int const) {
value_i8 int1(7);
TEST(static_cast<long long>(int1) == 7);
value_i8 int2(-7);
TEST(static_cast<long long>(int2) == -7);
value_i8 int5(1ull << 40);
TEST(static_cast<long long>(int5) == (1ull << 40));
value val1(int1);
TEST(val1.type() == value::TYPE_I8);
value_i8 int3(val1);
TEST(static_cast<long long>(int3) == 7);
try {
value_i8 int4(value_double(3.7));
TEST_FAILED("invalid cast double-i8 suceeded");
} catch (error) {}
}
};
class structTestSuite : public testSuite {
public:
virtual string suiteName() {
return "structTestSuite";
}
virtual void runtests(unsigned int const) {
map<string, value> structData;
pair<string, value> member("the_integer", value_int(9));
structData.insert(member);
value_struct struct1(structData);
map<string, value> dataReadBack(struct1);
TEST(static_cast<int>(value_int(dataReadBack["the_integer"])) == 9);
value val1(struct1);
TEST(val1.type() == value::TYPE_STRUCT);
value_struct struct2(val1);
try {
value_struct struct4(value_int(4));
TEST_FAILED("invalid cast int-struct suceeded");
} catch (error) {}
}
};
class arrayTestSuite : public testSuite {
public:
virtual string suiteName() {
return "arrayTestSuite";
}
virtual void runtests(unsigned int const) {
vector<value> arrayData;
arrayData.push_back(value_int(7));
arrayData.push_back(value_double(2.78));
arrayData.push_back(value_string("hello world"));
value_array array1(arrayData);
TEST(array1.size() == 3);
vector<value> dataReadBack1(array1.vectorValueValue());
TEST(dataReadBack1[0].type() == value::TYPE_INT);
TEST(static_cast<int>(value_int(dataReadBack1[0])) == 7);
TEST(dataReadBack1[1].type() == value::TYPE_DOUBLE);
TEST(static_cast<double>(value_double(dataReadBack1[1])) == 2.78);
TEST(dataReadBack1[2].type() == value::TYPE_STRING);
TEST(static_cast<string>(value_string(dataReadBack1[2])) ==
"hello world");
value val1(array1);
TEST(val1.type() == value::TYPE_ARRAY);
value_array array2(val1);
TEST(array2.size() == 3);
try {
value_array array4(value_int(4));
TEST_FAILED("invalid cast int-array suceeded");
} catch (error) {}
}
};
class valueTestSuite : public testSuite {
public:
virtual string suiteName() {
return "valueTestSuite";
}
virtual void runtests(unsigned int const indentation) {
intTestSuite().run(indentation+1);
doubleTestSuite().run(indentation+1);
booleanTestSuite().run(indentation+1);
datetimeTestSuite().run(indentation+1);
stringTestSuite().run(indentation+1);
bytestringTestSuite().run(indentation+1);
nilTestSuite().run(indentation+1);
i8TestSuite().run(indentation+1);
structTestSuite().run(indentation+1);
arrayTestSuite().run(indentation+1);
}
};
class paramListTestSuite : public testSuite {
public:
virtual string suiteName() {
return "paramListTestSuite";
}
virtual void runtests(unsigned int const) {
paramList paramList1;
TEST(paramList1.size() == 0);
paramList1.add(value_int(7));
paramList1.add(value_boolean(true));
paramList1.add(value_double(3.14));
time_t const timeZero(0);
paramList1.add(value_datetime(timeZero));
time_t const timeFuture(time(NULL)+100);
paramList1.add(value_datetime(timeFuture));
paramList1.add(value_string("hello world"));
unsigned char bytestringArray[] = {0x10, 0x11, 0x12, 0x13, 0x14};
vector<unsigned char>
bytestringData(&bytestringArray[0], &bytestringArray[4]);
paramList1.add(value_bytestring(bytestringData));
vector<value> arrayData;
arrayData.push_back(value_int(7));
arrayData.push_back(value_double(2.78));
arrayData.push_back(value_string("hello world"));
paramList1.add(value_array(arrayData));
map<string, value> structData;
pair<string, value> member("the_integer", value_int(9));
structData.insert(member);
paramList1.add(value_struct(structData));
paramList1.add(value_nil());
paramList1.add(value_i8((long long)UINT_MAX + 1));
TEST(paramList1.size() == 11);
TEST(paramList1.getInt(0) == 7);
TEST(paramList1.getInt(0, 7) == 7);
TEST(paramList1.getInt(0, -5, 7) == 7);
TEST(paramList1.getBoolean(1) == true);
TEST(paramList1.getDouble(2) == 3.14);
TEST(paramList1.getDouble(2, 1) == 3.14);
TEST(paramList1.getDouble(2, 1, 4) == 3.14);
TEST(paramList1.getDatetime_sec(3) == 0);
TEST(paramList1.getDatetime_sec(3, paramList::TC_ANY) == timeZero);
TEST(paramList1.getDatetime_sec(3, paramList::TC_NO_FUTURE)
== timeZero);
TEST(paramList1.getDatetime_sec(4, paramList::TC_NO_PAST)
== timeFuture);
TEST(paramList1.getString(5) == "hello world");
TEST(paramList1.getBytestring(6)[0] == 0x10);
TEST(paramList1.getArray(7).size() == 3);
TEST(paramList1.getArray(7, 3).size() == 3);
TEST(paramList1.getArray(7, 1, 3).size() == 3);
paramList1.getStruct(8)["the_integer"];
paramList1.getNil(9);
TEST(paramList1.getI8(10) == (long long)UINT_MAX + 1);
paramList1.verifyEnd(11);
paramList paramList2(5);
TEST(paramList2.size() == 0);
}
};
//=========================================================================
// Test Driver
//=========================================================================
int
main(int argc, char**) {
int retval;
if (argc-1 > 0) {
cout << "Program takes no arguments" << endl;
exit(1);
}
bool testsPassed;
try {
// Add your test suites here.
valueTestSuite().run(0);
paramListTestSuite().run(0);
registryTestSuite().run(0);
serverAbyssTestSuite().run(0);
#ifndef WIN32
serverPstreamTestSuite().run(0);
#endif
clientTestSuite().run(0);
testXmlRpcCpp();
testsPassed = true;
} catch (error const& error) {
cout << "Unexpected error thrown: " << error.what() << endl;
testsPassed = false;
} catch (XmlRpcFault const& fault) {
cout << "Unexpected XML-RPC fault when running test suites." << endl
<< "Fault #" << fault.getFaultCode()
<< ": " << fault.getFaultString() << endl;
testsPassed = false;
} catch (...) {
cout << "Unexpected exception when running test suites." << endl;
testsPassed = false;
}
if (testsPassed) {
cout << "PASSED" << endl;
retval = 0;
} else {
cout << "FAILED" << endl;
retval = 1;
}
return retval;
}
Want the latest updates on software, tech news, and AI?
Get latest updates about software, tech news, and AI from SourceForge directly in your inbox once a month.