Fennel: /home/pub/open/dev/fennel/calctest/SqlStringTestAscii.cpp Source File (original) (raw)
00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #include "fennel/common/CommonPreamble.h"
00024 #include "fennel/test/TestBase.h"
00025 #include "fennel/calc/SqlString.h"
00026 #include "fennel/common/TraceSource.h"
00027
00028 #include <boost/test/test_tools.hpp>
00029 #include <boost/scoped_array.hpp>
00030 #include
00031 #include
00032
00033 using namespace fennel;
00034 using namespace std;
00035
00036
00037 const int MAXLEN = 8;
00038 const int MAXRANDOM = 5;
00039 const int MAXCMPLEN = 8;
00040 const int BUMPERLEN = 3;
00041 const char BUMPERCH = '@';
00042
00043
00044
00045 class SqlStringTestGen
00046 {
00047 public:
00048 SqlStringTestGen(
00049 int storage,
00050 int size,
00051 int leftpad = 0,
00052 int rightpad = 0,
00053 char text = 'x',
00054 char pad = ' ',
00055 int leftBumper = BUMPERLEN,
00056 int rightBumper = BUMPERLEN)
00057 : mStorage(storage),
00058 mSize(size),
00059 mLeftPad(leftpad),
00060 mRightPad(rightpad),
00061 mLeftBump(leftBumper),
00062 mRightBump(rightBumper),
00063 mTotal(storage + leftBumper + rightBumper),
00064 mS(mTotal, BUMPERCH)
00065 {
00066 assert(leftBumper > 0);
00067 assert(rightBumper > 0);
00068 assert(storage == size + leftpad + rightpad);
00069
00070 mLeftP = const_cast<char *>(mS.c_str());
00071 mStr = mLeftP + mLeftBump;
00072 mRightP = mStr + mStorage;
00073
00074 string padS(mStorage, pad);
00075 string textS(size, text);
00076
00077 mS.replace(mLeftBump, mStorage, padS, 0, mStorage);
00078 mS.replace(mLeftBump + mLeftPad, mSize, textS, 0, mSize);
00079 }
00080
00081 bool
00082 verify()
00083 {
00084 string verS(mTotal, BUMPERCH);
00085 if (mS.compare(0, mLeftBump, verS, 0, mLeftBump)) {
00086 return false;
00087 }
00088 if (mS.compare(
00089 mLeftBump + mLeftPad + mSize + mRightPad,
00090 mRightBump, verS, 0, mRightBump))
00091 {
00092 return false;
00093 }
00094 return true;
00095 }
00096
00097 void
00098 randomize(
00099 unsigned char start = 'A',
00100 unsigned char lower = ' ',
00101 unsigned char upper = '')
00102 {
00103 patternfill(start, lower, upper);
00104 string r(mStr, mSize);
00105 random_shuffle(r.begin(), r.end());
00106 mS.replace(mLeftBump + mLeftPad, mSize, r);
00107 }
00108
00109 void
00110 patternfill(
00111 unsigned char start = 'A',
00112 unsigned char lower = ' ',
00113 unsigned char upper = '')
00114 {
00115 uint c;
00116 int toGen = mSize;
00117
00118 string r;
00119
00120 c = start;
00121 while (toGen) {
00122 r.push_back(static_cast(c));
00123 toGen--;
00124 if (++c > upper) {
00125 c = lower;
00126 }
00127 }
00128 mS.replace(mLeftBump + mLeftPad, mSize, r);
00129 }
00130
00131
00132 char * mStr;
00133 char * mRightP;
00134 char * mLeftP;
00135 const int mStorage;
00136 const int mSize;
00137 const int mLeftPad;
00138 const int mRightPad;
00139 const int mLeftBump;
00140 const int mRightBump;
00141 const int mTotal;
00142 string mS;
00143
00144 private:
00145
00146 string
00147 vectortostring(vector &v)
00148 {
00149 string s;
00150 vector::iterator i = v.begin();
00151 while (i != v.end()) {
00152 s.push_back(*i);
00153 i++;
00154 }
00155 return s;
00156 }
00157 };
00158
00159
00160 class SqlStringTest : virtual public TestBase, public TraceSource
00161 {
00162 void testSqlStringClass();
00163
00164 void testSqlStringAsciiCatF();
00165 void testSqlStringAsciiCatV();
00166 void testSqlStringAsciiCatV2();
00167 void testSqlStringAsciiCmpFDiffLen();
00168 void testSqlStringAsciiCmpFEqLen();
00169 void testSqlStringAsciiCmpVDiffLen();
00170 void testSqlStringAsciiCmpVEqLen();
00171 void testSqlStringAsciiLenBit();
00172 void testSqlStringAsciiLenChar();
00173 void testSqlStringAsciiLenOct();
00174 void testSqlStringAsciiOverlay();
00175 void testSqlStringAsciiPos();
00176 void testSqlStringAsciiSubStr();
00177 void testSqlStringAsciiToLower();
00178 void testSqlStringAsciiToUpper();
00179 void testSqlStringAsciiTrim();
00180
00181 void testSqlStringAsciiCmpVHelper(
00182 SqlStringTestGen &src1,
00183 int src1_len,
00184 SqlStringTestGen &src2,
00185 int src2_len);
00186 void testSqlStringAsciiCmpFHelper(
00187 SqlStringTestGen &src1,
00188 int src1_storage,
00189 int src1_len,
00190 SqlStringTestGen &src2,
00191 int src2_storage,
00192 int src2_len);
00193 int testSqlStringNormalizeLexicalCmp(int v);
00194
00195 public:
00196 explicit SqlStringTest()
00197 : TraceSource(shared_from_this(),"SqlStringTest")
00198 {
00199 srand(time(NULL));
00200 FENNEL_UNIT_TEST_CASE(SqlStringTest, testSqlStringClass);
00201 FENNEL_UNIT_TEST_CASE(SqlStringTest, testSqlStringAsciiCatF);
00202 FENNEL_UNIT_TEST_CASE(SqlStringTest, testSqlStringAsciiCatV2);
00203 FENNEL_UNIT_TEST_CASE(SqlStringTest, testSqlStringAsciiCatV);
00204 FENNEL_UNIT_TEST_CASE(SqlStringTest, testSqlStringAsciiCmpFDiffLen);
00205 FENNEL_UNIT_TEST_CASE(SqlStringTest, testSqlStringAsciiCmpFEqLen);
00206 FENNEL_UNIT_TEST_CASE(SqlStringTest, testSqlStringAsciiCmpVDiffLen);
00207 FENNEL_UNIT_TEST_CASE(SqlStringTest, testSqlStringAsciiCmpVEqLen);
00208 FENNEL_UNIT_TEST_CASE(SqlStringTest, testSqlStringAsciiLenBit);
00209 FENNEL_UNIT_TEST_CASE(SqlStringTest, testSqlStringAsciiLenChar);
00210 FENNEL_UNIT_TEST_CASE(SqlStringTest, testSqlStringAsciiLenOct);
00211 FENNEL_UNIT_TEST_CASE(SqlStringTest, testSqlStringAsciiOverlay);
00212 FENNEL_UNIT_TEST_CASE(SqlStringTest, testSqlStringAsciiPos);
00213 FENNEL_UNIT_TEST_CASE(SqlStringTest, testSqlStringAsciiSubStr);
00214 FENNEL_UNIT_TEST_CASE(SqlStringTest, testSqlStringAsciiToLower);
00215 FENNEL_UNIT_TEST_CASE(SqlStringTest, testSqlStringAsciiToUpper);
00216 FENNEL_UNIT_TEST_CASE(SqlStringTest, testSqlStringAsciiTrim);
00217 }
00218
00219 virtual ~SqlStringTest()
00220 {
00221 }
00222 };
00223
00224 void
00225 SqlStringTest::testSqlStringClass()
00226 {
00227 int storage, size, leftpad, rightpad;
00228 int leftbump = 2;
00229 int rightbump = 2;
00230 int k;
00231
00232 for (storage = 0; storage <= 5; storage++) {
00233 for (size = 0; size <= storage; size++) {
00234 for (leftpad = 0; leftpad <= storage - size; leftpad++) {
00235 rightpad = (storage - size) - leftpad;
00236
00237 SqlStringTestGen t(
00238 storage, size,
00239 leftpad, rightpad,
00240 'x', ' ',
00241 leftbump, rightbump);
00242
00243 BOOST_CHECK_EQUAL(t.mStorage, storage);
00244 BOOST_CHECK_EQUAL(t.mSize, size);
00245 BOOST_CHECK_EQUAL(t.mLeftPad, leftpad);
00246 BOOST_CHECK_EQUAL(t.mRightPad, rightpad);
00247 BOOST_CHECK_EQUAL(
00248 static_cast(t.mS.size()),
00249 storage + leftbump + rightbump);
00250
00251 BOOST_CHECK(t.verify());
00252
00253 char *p = t.mLeftP;
00254
00255 for (k = 0; k < leftbump; k++) {
00256 BOOST_CHECK_EQUAL(*(p++), BUMPERCH);
00257 }
00258 BOOST_CHECK(p == t.mStr);
00259
00260 for (k = 0; k < leftpad; k++) {
00261 BOOST_CHECK_EQUAL(*(p++), ' ');
00262 }
00263
00264 for (k = 0; k < size; k++) {
00265 BOOST_CHECK_EQUAL(*(p++), 'x');
00266 }
00267
00268 for (k = 0; k < rightpad; k++) {
00269 BOOST_CHECK_EQUAL(*(p++), ' ');
00270 }
00271 BOOST_CHECK(p == t.mRightP);
00272
00273 for (k = 0; k < rightbump; k++) {
00274 BOOST_CHECK_EQUAL(*(p++), BUMPERCH);
00275 }
00276 BOOST_CHECK_EQUAL(
00277 static_cast(p - t.mLeftP),
00278 storage + leftbump + rightbump);
00279
00280 BOOST_CHECK(t.verify());
00281
00282 for (k = 0; k < size; k++) {
00283 *(t.mStr + k) = '0' + (k % 10);
00284 }
00285 BOOST_CHECK(t.verify());
00286
00287 *(t.mLeftP) = 'X';
00288 BOOST_CHECK(!t.verify());
00289 *(t.mLeftP) = BUMPERCH;
00290 BOOST_CHECK(t.verify());
00291
00292 *(t.mStr - 1) = 'X';
00293 BOOST_CHECK(!t.verify());
00294 *(t.mStr - 1) = BUMPERCH;
00295 BOOST_CHECK(t.verify());
00296
00297 *(t.mRightP) = 'X';
00298 BOOST_CHECK(!t.verify());
00299 *(t.mRightP) = BUMPERCH;
00300 BOOST_CHECK(t.verify());
00301
00302 *(t.mRightP + t.mRightBump - 1) = 'X';
00303 BOOST_CHECK(!t.verify());
00304 *(t.mRightP + t.mRightBump - 1) = BUMPERCH;
00305 BOOST_CHECK(t.verify());
00306
00307 t.randomize();
00308 BOOST_CHECK(t.verify());
00309 }
00310 }
00311 }
00312 }
00313
00314
00315
00316 void
00317 SqlStringTest::testSqlStringAsciiCatF()
00318 {
00319 int src1_storage, src2_storage, src3_storage, dst_storage;
00320 int src1_len, src2_len, src3_len;
00321 bool caught;
00322 int newlen;
00323
00324 for (dst_storage = 0; dst_storage < MAXLEN; dst_storage++) {
00325 for (src1_storage = 0; src1_storage < MAXLEN; src1_storage++) {
00326 for (src1_len = 0; src1_len <= src1_storage; src1_len++) {
00327 for (src2_storage = 0; src2_storage < MAXLEN; src2_storage++) {
00328 for (src2_len = 0; src2_len <= src2_storage; src2_len++) {
00329 for (src3_storage = 0; src3_storage < MAXLEN;
00330 src3_storage++)
00331 {
00332 for (src3_len = 0; src3_len <= src3_storage;
00333 src3_len++)
00334 {
00335 SqlStringTestGen dst(
00336 dst_storage, 0,
00337 0, dst_storage,
00338 'd', ' ');
00339 SqlStringTestGen src1(
00340 src1_storage, src1_len,
00341 0, src1_storage - src1_len,
00342 '1', ' ');
00343 SqlStringTestGen src2(
00344 src2_storage, src2_len,
00345 0, src2_storage - src2_len,
00346 '2', ' ');
00347 SqlStringTestGen src3(
00348 src3_storage, src3_len,
00349 0, src3_storage - src3_len,
00350 '3', ' ');
00351
00352 caught = false;
00353 try {
00354 newlen = SqlStrAsciiCat(
00355 dst.mStr, dst_storage,
00356 src1.mStr, src1_storage,
00357 src2.mStr, src2_storage);
00358 } catch (const char *str) {
00359 caught = true;
00360 BOOST_CHECK_EQUAL(strcmp(str, "22001"), 0);
00361 BOOST_CHECK(
00362 src1_storage + src2_storage
00363 > dst_storage);
00364 BOOST_CHECK(dst.verify());
00365 BOOST_CHECK(src1.verify());
00366 BOOST_CHECK(src2.verify());
00367 } catch (...) {
00368 BOOST_CHECK(false);
00369 }
00370 if (!caught) {
00371 BOOST_CHECK(
00372 src1_storage + src2_storage
00373 <= dst_storage);
00374 BOOST_CHECK(dst.verify());
00375 BOOST_CHECK(src1.verify());
00376 BOOST_CHECK(src2.verify());
00377
00378 caught = false;
00379 try {
00380 newlen = SqlStrAsciiCat(
00381 dst.mStr,
00382 dst_storage,
00383 newlen,
00384 src3.mStr,
00385 src3_storage);
00386 } catch (const char *str) {
00387 caught = true;
00388 BOOST_CHECK_EQUAL(
00389 strcmp(str, "22001"),
00390 0);
00391 BOOST_CHECK(
00392 (src1_storage +
00393 src2_storage +
00394 src3_storage)
00395 > dst_storage);
00396 BOOST_CHECK(dst.verify());
00397 BOOST_CHECK(src1.verify());
00398 BOOST_CHECK(src2.verify());
00399 BOOST_CHECK(src3.verify());
00400 } catch (...) {
00401 BOOST_CHECK(false);
00402 }
00403 if (!caught) {
00404 BOOST_CHECK(dst.verify());
00405 BOOST_CHECK(src1.verify());
00406 BOOST_CHECK(src2.verify());
00407 BOOST_CHECK(src3.verify());
00408 BOOST_CHECK_EQUAL(
00409 newlen,
00410 (src1_storage +
00411 src2_storage +
00412 src3_storage));
00413
00414 string result(dst.mStr, newlen);
00415 string expect(src1.mStr, src1_storage);
00416 expect.append(src2.mStr, src2_storage);
00417 expect.append(src3.mStr, src3_storage);
00418
00419 BOOST_CHECK(!result.compare(expect));
00420 }
00421 }
00422 }
00423 }
00424 }
00425 }
00426 }
00427 }
00428 }
00429
00430 }
00431
00432
00433 void
00434 SqlStringTest::testSqlStringAsciiCatV2()
00435 {
00436 int src1_storage, src2_storage, dst_storage, src1_len, src2_len;
00437 int newlen;
00438 bool caught;
00439
00440 for (dst_storage = 0; dst_storage < MAXLEN; dst_storage++) {
00441 for (src1_storage = 0; src1_storage < MAXLEN; src1_storage++) {
00442 for (src1_len = 0; src1_len <= src1_storage; src1_len++) {
00443 for (src2_storage = 0; src2_storage < MAXLEN; src2_storage++) {
00444 for (src2_len = 0; src2_len <= src2_storage; src2_len++) {
00445 SqlStringTestGen dst(
00446 dst_storage, 0,
00447 0, dst_storage,
00448 'd', ' ');
00449 SqlStringTestGen src1(
00450 src1_storage, src1_len,
00451 0, src1_storage - src1_len,
00452 's', ' ');
00453 SqlStringTestGen src2(
00454 src2_storage, src2_len,
00455 0, src2_storage - src2_len,
00456 'S', ' ');
00457
00458 caught = false;
00459 try {
00460 newlen = SqlStrAsciiCat(
00461 dst.mStr,
00462 dst_storage,
00463 src1.mStr,
00464 src1_len,
00465 src2.mStr,
00466 src2_len);
00467 } catch (const char *str) {
00468 caught = true;
00469 BOOST_CHECK_EQUAL(strcmp(str, "22001"), 0);
00470 BOOST_CHECK(src1_len + src2_len > dst_storage);
00471 } catch (...) {
00472 BOOST_CHECK(false);
00473 }
00474 if (!caught) {
00475 BOOST_CHECK(src1_len + src2_len <= dst_storage);
00476 BOOST_CHECK_EQUAL(newlen, src1_len + src2_len);
00477
00478 string expect;
00479 expect.append(src1_len, 's');
00480 expect.append(src2_len, 'S');
00481
00482 string result(dst.mStr, newlen);
00483
00484 BOOST_CHECK(!result.compare(expect));
00485 BOOST_CHECK(!expect.compare(result));
00486 }
00487 BOOST_CHECK(dst.verify());
00488 BOOST_CHECK(src1.verify());
00489 BOOST_CHECK(src2.verify());
00490 }
00491 }
00492 }
00493 }
00494 }
00495 }
00496
00497
00498 void
00499 SqlStringTest::testSqlStringAsciiCatV()
00500 {
00501 int src_storage, dst_storage, src_len, dst_len;
00502 int newlen;
00503 bool caught;
00504
00505 for (dst_storage = 0; dst_storage < MAXLEN; dst_storage++) {
00506 for (dst_len = 0; dst_len <= dst_storage; dst_len++) {
00507 for (src_storage = 0; src_storage < MAXLEN; src_storage++) {
00508 for (src_len = 0; src_len <= src_storage; src_len++) {
00509 SqlStringTestGen dst(
00510 dst_storage, dst_len,
00511 0, dst_storage - dst_len,
00512 'd', ' ');
00513 SqlStringTestGen src(
00514 src_storage, src_len,
00515 0, src_storage - src_len,
00516 's', ' ');
00517 caught = false;
00518 try {
00519 newlen = SqlStrAsciiCat(
00520 dst.mStr,
00521 dst_storage,
00522 dst_len,
00523 src.mStr,
00524 src_len);
00525 } catch (const char *str) {
00526 caught = true;
00527 BOOST_CHECK_EQUAL(strcmp(str, "22001"), 0);
00528 BOOST_CHECK(src_len + dst_len > dst_storage);
00529 } catch (...) {
00530 BOOST_CHECK(false);
00531 }
00532 if (!caught) {
00533 BOOST_CHECK(src_len + dst_len <= dst_storage);
00534 BOOST_CHECK_EQUAL(newlen, src_len + dst_len);
00535
00536 string expect;
00537 expect.append(dst_len, 'd');
00538 expect.append(src_len, 's');
00539
00540 string result(dst.mStr, newlen);
00541
00542 BOOST_CHECK(!result.compare(expect));
00543 BOOST_CHECK(!expect.compare(result));
00544 }
00545 BOOST_CHECK(dst.verify());
00546 BOOST_CHECK(src.verify());
00547 }
00548 }
00549 }
00550 }
00551 }
00552
00553 int
00554 SqlStringTest::testSqlStringNormalizeLexicalCmp(int v)
00555 {
00556 if (v < 0) {
00557 return -1;
00558 }
00559 if (v > 0) {
00560 return 1;
00561 }
00562 return 0;
00563 }
00564
00565
00566
00567 void
00568 SqlStringTest::testSqlStringAsciiCmpFHelper(
00569 SqlStringTestGen &src1,
00570 int src1_storage,
00571 int src1_len,
00572 SqlStringTestGen &src2,
00573 int src2_storage,
00574 int src2_len)
00575 {
00576 int result;
00577
00578 string s1(src1.mStr, src1_len);
00579 string s2(src2.mStr, src2_len);
00580
00581
00582 s1.erase(s1.find_last_not_of(" ") + 1);
00583 s2.erase(s2.find_last_not_of(" ") + 1);
00584
00585 int expected = testSqlStringNormalizeLexicalCmp(s1.compare(s2));
00586 char const * const s1p = s1.c_str();
00587 char const * const s2p = s2.c_str();
00588 int expected2 = testSqlStringNormalizeLexicalCmp(strcmp(s1p, s2p));
00589 BOOST_CHECK_EQUAL(expected, expected2);
00590
00591 result = SqlStrAsciiCmpF(
00592 src1.mStr, src1_storage,
00593 src2.mStr, src2_storage);
00594 BOOST_CHECK(src1.verify());
00595 BOOST_CHECK(src2.verify());
00596
00597 #if 0
00598 BOOST_MESSAGE(" src1=|" << s1 << "|" <<
00599 " src2=|" << s2 << "|" <<
00600 " expect=" << expected <<
00601 " expect2=" << expected2 <<
00602 " result=" << result);
00603 #endif
00604 BOOST_CHECK_EQUAL(result, expected);
00605
00606
00607 int result2 = SqlStrAsciiCmpF(
00608 src2.mStr, src2_storage,
00609 src1.mStr, src1_storage);
00610 BOOST_CHECK(src1.verify());
00611 BOOST_CHECK(src2.verify());
00612 BOOST_CHECK_EQUAL(result2 * -1, result);
00613
00614
00615 result = SqlStrAsciiCmpF(
00616 src1.mStr, src1_storage,
00617 src1.mStr, src1_storage);
00618 BOOST_CHECK(src1.verify());
00619 BOOST_CHECK_EQUAL(result, 0);
00620
00621 }
00622
00623
00624 void
00625 SqlStringTest::testSqlStringAsciiCmpFDiffLen()
00626 {
00627 int src1_storage, src2_storage, src1_len, src2_len;
00628 unsigned char startchar;
00629
00630 for (src1_storage = 0; src1_storage <= MAXLEN; src1_storage++) {
00631 for (src1_len = 0; src1_len < src1_storage; src1_len++) {
00632 for (src2_storage = 0; src2_storage <= MAXLEN; src2_storage++) {
00633 for (src2_len = 0; src2_len < src2_storage; src2_len++) {
00634
00635 for (startchar = 1; startchar < 255; startchar++) {
00636 SqlStringTestGen src1(
00637 src1_storage, src1_len,
00638 0, src1_storage - src1_len,
00639 'd', ' ');
00640 SqlStringTestGen src2(
00641 src2_storage, src2_len,
00642 0, src2_storage - src2_len,
00643 's', ' ');
00644
00645 src1.patternfill(startchar, 1, 255);
00646 src2.patternfill(startchar, 1, 255);
00647
00648 testSqlStringAsciiCmpFHelper(
00649 src1, src1_storage, src1_len,
00650 src2, src2_storage, src2_len);
00651 }
00652 }
00653 }
00654 }
00655 }
00656 }
00657
00658
00659 void
00660 SqlStringTest::testSqlStringAsciiCmpFEqLen()
00661 {
00662 int src1_storage, src2_storage, src1_len, src2_len, randX;
00663
00664
00665
00666 src1_storage = MAXCMPLEN;
00667 src2_storage = MAXCMPLEN;
00668 for (src1_len = 0; src1_len < src1_storage; src1_len++) {
00669 src2_len = src1_len;
00670 for (randX = 0; randX <= 65536; randX++) {
00671 SqlStringTestGen src1(
00672 src1_storage, src1_len,
00673 0, src1_storage - src1_len,
00674 'd', ' ');
00675 SqlStringTestGen src2(
00676 src2_storage, src2_len,
00677 0, src2_storage - src2_len,
00678 's', ' ');
00679
00680
00681 src1.randomize(1, 1, 255);
00682 src2.randomize(1, 1, 255);
00683
00684 testSqlStringAsciiCmpFHelper(
00685 src1, src1_storage, src1_len,
00686 src2, src2_storage, src2_len);
00687 }
00688 }
00689 }
00690
00691
00692 void
00693 SqlStringTest::testSqlStringAsciiCmpVHelper(
00694 SqlStringTestGen &src1,
00695 int src1_len,
00696 SqlStringTestGen &src2,
00697 int src2_len)
00698 {
00699 int result;
00700
00701 string s1(src1.mStr, src1_len);
00702 string s2(src2.mStr, src2_len);
00703
00704 int expected = testSqlStringNormalizeLexicalCmp(s1.compare(s2));
00705 char const * const s1p = s1.c_str();
00706 char const * const s2p = s2.c_str();
00707 int expected2 = testSqlStringNormalizeLexicalCmp(strcmp(s1p, s2p));
00708 BOOST_CHECK_EQUAL(expected, expected2);
00709
00710
00711 result = SqlStrAsciiCmpV(
00712 src1.mStr, src1_len,
00713 src2.mStr, src2_len);
00714 BOOST_CHECK(src1.verify());
00715 BOOST_CHECK(src2.verify());
00716
00717 #if 0
00718 BOOST_MESSAGE(" src1=|" << s1 << "|" <<
00719 " src2=|" << s2 << "|" <<
00720 " expect=" << expected <<
00721 " expect2=" << expected2 <<
00722 " result=" << result);
00723 #endif
00724 BOOST_CHECK_EQUAL(result, expected);
00725
00726
00727 int result2 = SqlStrAsciiCmpV(
00728 src2.mStr, src2_len,
00729 src1.mStr, src1_len);
00730 BOOST_CHECK(src1.verify());
00731 BOOST_CHECK(src2.verify());
00732 BOOST_CHECK_EQUAL(result2 * -1, result);
00733
00734
00735 result = SqlStrAsciiCmpV(
00736 src1.mStr, src1_len,
00737 src1.mStr, src1_len);
00738 BOOST_CHECK(src1.verify());
00739 BOOST_CHECK_EQUAL(result, 0);
00740
00741 }
00742
00743
00744 void
00745 SqlStringTest::testSqlStringAsciiCmpVDiffLen()
00746 {
00747 int src1_storage, src2_storage, src1_len, src2_len;
00748 unsigned char startchar;
00749
00750 for (src1_storage = 0; src1_storage <= MAXLEN; src1_storage++) {
00751 src1_len = src1_storage;
00752 for (src2_storage = 0; src2_storage <= MAXLEN; src2_storage++) {
00753 src2_len = src2_storage;
00754
00755 for (startchar = 1; startchar < 255; startchar++) {
00756 SqlStringTestGen src1(
00757 src1_storage, src1_len,
00758 0, src1_storage - src1_len,
00759 'd', ' ');
00760 SqlStringTestGen src2(
00761 src2_storage, src2_len,
00762 0, src2_storage - src2_len,
00763 's', ' ');
00764
00765 src1.patternfill(startchar, 1, 255);
00766 src2.patternfill(startchar, 1, 255);
00767
00768 testSqlStringAsciiCmpVHelper(
00769 src1, src1_len,
00770 src2, src2_len);
00771 }
00772 }
00773 }
00774 }
00775
00776
00777 void
00778 SqlStringTest::testSqlStringAsciiCmpVEqLen()
00779 {
00780 int src1_storage, src2_storage, src1_len, src2_len, randX;
00781
00782
00783
00784 src1_storage = MAXCMPLEN;
00785 src1_len = src1_storage;
00786 src2_storage = src1_storage;
00787 src2_len = src1_storage;
00788 for (randX = 0; randX <= 65536; randX++) {
00789 SqlStringTestGen src1(
00790 src1_storage, src1_len,
00791 0, src1_storage - src1_len,
00792 'd', ' ');
00793 SqlStringTestGen src2(
00794 src2_storage, src2_len,
00795 0, src2_storage - src2_len,
00796 's', ' ');
00797
00798
00799 src1.randomize(1, 1, 255);
00800 src2.randomize(1, 1, 255);
00801
00802 testSqlStringAsciiCmpVHelper(
00803 src1, src1_len,
00804 src2, src2_len);
00805 }
00806 }
00807
00808
00809 void
00810 SqlStringTest::testSqlStringAsciiLenBit()
00811 {
00812 int src_storage, src_len;
00813 int newlen;
00814
00815 src_storage = MAXLEN;
00816 for (src_storage = 0; src_storage <= MAXLEN; src_storage++) {
00817 for (src_len = 0; src_len <= src_storage; src_len++) {
00818 SqlStringTestGen src(
00819 src_storage, src_len,
00820 0, src_storage - src_len,
00821 's', ' ');
00822
00823 newlen = SqlStrAsciiLenBit(
00824 src.mStr,
00825 src_len);
00826 BOOST_CHECK_EQUAL(newlen, src_len * 8);
00827 BOOST_CHECK(src.verify());
00828
00829 newlen = SqlStrAsciiLenBit(
00830 src.mStr,
00831 src_storage);
00832 BOOST_CHECK_EQUAL(newlen, src_storage * 8);
00833 BOOST_CHECK(src.verify());
00834 }
00835 }
00836 }
00837
00838
00839 void
00840 SqlStringTest::testSqlStringAsciiLenChar()
00841 {
00842 int src_storage, src_len;
00843 int newlen;
00844
00845 src_storage = MAXLEN;
00846 for (src_storage = 0; src_storage <= MAXLEN; src_storage++) {
00847 for (src_len = 0; src_len <= src_storage; src_len++) {
00848 SqlStringTestGen src(
00849 src_storage, src_len,
00850 0, src_storage - src_len,
00851 's', ' ');
00852
00853 newlen = SqlStrAsciiLenChar(
00854 src.mStr,
00855 src_len);
00856 BOOST_CHECK_EQUAL(newlen, src_len);
00857 BOOST_CHECK(src.verify());
00858
00859 newlen = SqlStrAsciiLenChar(
00860 src.mStr,
00861 src_storage);
00862 BOOST_CHECK_EQUAL(newlen, src_storage);
00863 BOOST_CHECK(src.verify());
00864 }
00865 }
00866 }
00867
00868
00869 void
00870 SqlStringTest::testSqlStringAsciiLenOct()
00871 {
00872 int src_storage, src_len;
00873 int newlen;
00874
00875 src_storage = MAXLEN;
00876 for (src_storage = 0; src_storage <= MAXLEN; src_storage++) {
00877 for (src_len = 0; src_len <= src_storage; src_len++) {
00878 SqlStringTestGen src(
00879 src_storage, src_len,
00880 0, src_storage - src_len,
00881 's', ' ');
00882
00883 newlen = SqlStrAsciiLenOct(
00884 src.mStr,
00885 src_len);
00886 BOOST_CHECK_EQUAL(newlen, src_len);
00887 BOOST_CHECK(src.verify());
00888
00889 newlen = SqlStrAsciiLenOct(
00890 src.mStr,
00891 src_storage);
00892 BOOST_CHECK_EQUAL(newlen, src_storage);
00893 BOOST_CHECK(src.verify());
00894 }
00895 }
00896 }
00897
00898
00899 void
00900 SqlStringTest::testSqlStringAsciiOverlay()
00901 {
00902 int dst_storage, src_storage, src_len, over_storage, over_len;
00903 int position, length, lengthI;
00904 int exLeftLen, exMidLen, exRightLen;
00905 char *exLeftP, *exMidP, *exRightP;
00906 bool lenSpecified;
00907 bool caught;
00908 int newlen;
00909
00910 for (dst_storage = 0; dst_storage < MAXLEN; dst_storage++) {
00911 for (src_storage = 0; src_storage < MAXLEN; src_storage++) {
00912 src_len = src_storage;
00913 for (over_storage = 0; over_storage < MAXLEN; over_storage++) {
00914 over_len = over_storage;
00915 for (position = 0; position < MAXLEN; position++) {
00916 for (lengthI = -1; lengthI < MAXLEN; lengthI++) {
00917 if (lengthI == -1) {
00918 lenSpecified = false;
00919 length = over_len;
00920 } else {
00921 lenSpecified = true;
00922 length = lengthI;
00923 }
00924 #if 0
00925 BOOST_MESSAGE(" dst_storage=" << dst_storage <<
00926 " src_storage=" << src_storage <<
00927 " over_storage=" << over_storage <<
00928 " pos=" << position <<
00929 " length=" << length <<
00930 " spec=" << lenSpecified);
00931 #endif
00932 SqlStringTestGen dst(
00933 dst_storage, dst_storage,
00934 0, 0,
00935 'd', ' ');
00936 SqlStringTestGen src(
00937 src_storage, src_len,
00938 0, src_storage - src_len,
00939 's', ' ');
00940 SqlStringTestGen over(
00941 over_storage, over_len,
00942 0, over_storage - over_len,
00943 'o', ' ');
00944
00945 src.patternfill('a', 'a', 'z');
00946 over.patternfill('A', 'A', 'Z');
00947
00948
00949 exLeftP = src.mStr;
00950 if (position >= 1 && src_len >= 1) {
00951 exLeftLen = position - 1;
00952 if (exLeftLen > src_len) {
00953 exLeftLen = src_len;
00954 }
00955 } else {
00956 exLeftLen = 0;
00957 }
00958
00959 exMidP = over.mStr;
00960 exMidLen = over_len;
00961
00962 exRightLen = src_len - (exLeftLen + length);
00963 if (exRightLen < 0) {
00964 exRightLen = 0;
00965 }
00966 exRightP = exLeftP + (src_len - exRightLen);
00967
00968 string expect(exLeftP, exLeftLen);
00969 expect.append(exMidP, exMidLen);
00970 expect.append(exRightP, exRightLen);
00971
00972 caught = false;
00973 try {
00974 newlen = SqlStrAsciiOverlay(
00975 dst.mStr,
00976 dst_storage,
00977 src.mStr,
00978 src_len,
00979 over.mStr,
00980 over_len,
00981 position,
00982 length,
00983 lenSpecified);
00984 } catch (const char *str) {
00985 caught = true;
00986 if (!strcmp(str, "22011")) {
00987 BOOST_CHECK(
00988 position < 1
00989 || (lenSpecified && length < 1));
00990 } else if (!strcmp(str, "22001")) {
00991 BOOST_CHECK(src_len + over_len > dst_storage);
00992 } else {
00993 BOOST_CHECK(false);
00994 }
00995 }
00996 if (!caught) {
00997 BOOST_CHECK(position > 0);
00998 if (lenSpecified) {
00999 BOOST_CHECK(length >= 0);
01000 }
01001
01002 BOOST_CHECK(dst.verify());
01003 BOOST_CHECK(src.verify());
01004 BOOST_CHECK(over.verify());
01005
01006 string result(dst.mStr, newlen);
01007
01008 BOOST_CHECK(!result.compare(expect));
01009 BOOST_CHECK(!expect.compare(result));
01010 }
01011 }
01012 }
01013 }
01014 }
01015 }
01016 }
01017
01018 void
01019 SqlStringTest::testSqlStringAsciiPos()
01020 {
01021 int src_storage, find_start, find_len, randX;
01022 int alter_char;
01023
01024 int foundpos;
01025
01026 for (src_storage = 0; src_storage < MAXLEN; src_storage++) {
01027 for (randX = 0; randX < MAXRANDOM; randX++) {
01028 SqlStringTestGen src(
01029 src_storage, src_storage,
01030 0, 0,
01031 's', ' ');
01032 src.randomize('a', 'a', 'z');
01033
01034
01035 for (find_start = 0; find_start <= src_storage; find_start++) {
01036 for (find_len = 0; find_len <= src_storage - find_start;
01037 find_len++)
01038 {
01039 string validsubstr(src.mStr + find_start, find_len);
01040 SqlStringTestGen find(
01041 find_len, find_len,
01042 0, 0,
01043 'X', ' ');
01044 memcpy(find.mStr, validsubstr.c_str(), find_len);
01045
01046 foundpos = SqlStrAsciiPos(
01047 src.mStr,
01048 src_storage,
01049 find.mStr,
01050 find_len);
01051 BOOST_CHECK(src.verify());
01052 BOOST_CHECK(find.verify());
01053
01054 if (find_len) {
01055
01056 BOOST_CHECK_EQUAL(foundpos, find_start + 1);
01057 } else {
01058 BOOST_CHECK_EQUAL(
01059 foundpos, static_cast(1));
01060 }
01061
01062
01063 for (alter_char = 0; alter_char < find_len; alter_char++) {
01064 char save = *(find.mStr + alter_char);
01065
01066 *(find.mStr + alter_char) = 'X';
01067
01068 foundpos = SqlStrAsciiPos(
01069 src.mStr,
01070 src_storage,
01071 find.mStr,
01072 find_len);
01073 BOOST_CHECK(src.verify());
01074 BOOST_CHECK(find.verify());
01075
01076 BOOST_CHECK_EQUAL(foundpos, static_cast(0));
01077
01078 *(find.mStr + alter_char) = save;
01079 }
01080 }
01081 }
01082 }
01083 }
01084 }
01085
01086 void
01087 SqlStringTest::testSqlStringAsciiSubStr()
01088 {
01089 int src_storage, src_len, dst_storage, newlen;
01090 int sub_start, sub_len;
01091 bool caught;
01092 char const * resultP;
01093
01094
01095
01096
01097 for (dst_storage = 0; dst_storage < MAXLEN; dst_storage++) {
01098 for (src_storage = 0; src_storage <= dst_storage; src_storage++) {
01099 for (src_len = 0; src_len <= src_storage; src_len++) {
01100 for (sub_start = -3; sub_start <= 3 + src_storage;
01101 sub_start++)
01102 {
01103 for (sub_len = -3; sub_len <= 3 + src_storage; sub_len++) {
01104 SqlStringTestGen dst(
01105 dst_storage, dst_storage,
01106 0, 0,
01107 'd', ' ');
01108 SqlStringTestGen src(
01109 src_storage, src_len,
01110 0, src_storage - src_len,
01111 's', ' ');
01112 src.randomize();
01113 #if 0
01114 BOOST_MESSAGE(
01115 "src =|" << src.mLeftP <<
01116 "| dest_storage=" << dst_storage <<
01117 " src_storage=" << src_storage <<
01118 " src_len=" << src_len <<
01119 " sub_start=" << sub_start <<
01120 " sub_len=" << sub_len);
01121 #endif
01122 int exsubstart = sub_start;
01123 int exlen = sub_len;
01124 if (exsubstart < 1) {
01125
01126 exlen += (exsubstart - 1);
01127 }
01128 exsubstart--;
01129 if (exsubstart < 0) {
01130 exsubstart = 0;
01131 }
01132 if (exlen < 0) {
01133 exlen = 0;
01134 }
01135
01136 if (exsubstart + exlen > src_storage) {
01137 if (exsubstart > src_storage) {
01138 exlen = 0;
01139 } else {
01140 exlen = src_storage - exsubstart;
01141 }
01142 }
01143 if (exsubstart < 0) {
01144 exsubstart = 0;
01145 }
01146 if (exlen < 0) {
01147 exlen = 0;
01148 }
01149
01150 string expect(src.mStr + exsubstart, exlen);
01151
01152 caught = false;
01153 try {
01154 newlen = SqlStrAsciiSubStr(
01155 &resultP, dst_storage,
01156 src.mStr, src_storage,
01157 sub_start, sub_len, true);
01158 } catch (const char *str) {
01159 caught = true;
01160 if (!strcmp(str, "22011")) {
01161 BOOST_CHECK(sub_len < 0);
01162 } else if (!strcmp(str, "22001")) {
01163 BOOST_CHECK(sub_len > dst_storage);
01164 BOOST_CHECK(sub_len >= 0);
01165 } else {
01166 BOOST_CHECK(false);
01167 }
01168 }
01169 if (!caught) {
01170 BOOST_CHECK(sub_len >= 0);
01171 string result(resultP, newlen);
01172 #if 0
01173 BOOST_MESSAGE("expect |" << expect << "|");
01174 BOOST_MESSAGE("result |" << result << "|");
01175 #endif
01176 BOOST_CHECK(!result.compare(expect));
01177 BOOST_CHECK(!expect.compare(result));
01178 }
01179 BOOST_CHECK(dst.verify());
01180 BOOST_CHECK(src.verify());
01181
01182
01183
01184 if (sub_start > 0 && sub_len > 0 &&
01185 sub_start + sub_len - 1 > src_storage) {
01186 caught = false;
01187 try {
01188 newlen = SqlStrAsciiSubStr(
01189 &resultP, dst_storage,
01190 src.mStr, src_storage,
01191 sub_start, 0, false);
01192 } catch (const char *str) {
01193 caught = true;
01194 if (!strcmp(str, "22011")) {
01195 BOOST_CHECK(sub_len < 0);
01196 } else if (!strcmp(str, "22001")) {
01197 BOOST_CHECK(sub_len > dst_storage);
01198 } else {
01199 BOOST_CHECK(false);
01200 }
01201 }
01202 if (!caught) {
01203
01204
01205
01206
01207 string result(resultP, newlen);
01208 #if 0
01209 BOOST_MESSAGE("expect |" << expect << "|");
01210 BOOST_MESSAGE("result |" << result << "|");
01211 #endif
01212 BOOST_CHECK(!result.compare(expect));
01213 BOOST_CHECK(!expect.compare(result));
01214 }
01215 BOOST_CHECK(dst.verify());
01216 BOOST_CHECK(src.verify());
01217 }
01218 }
01219 }
01220 }
01221 }
01222 }
01223 }
01224
01225 void
01226 SqlStringTest::testSqlStringAsciiToLower()
01227 {
01228 int dest_storage, dest_len, src_storage, src_len, randX;
01229 int newlen;
01230 bool caught;
01231
01232 for (dest_storage = 0; dest_storage < MAXLEN; dest_storage++) {
01233 dest_len = dest_storage;
01234 for (src_storage = 0; src_storage < MAXLEN; src_storage++) {
01235 src_len = src_storage;
01236 for (randX = 0; randX < MAXRANDOM; randX++) {
01237 SqlStringTestGen dest(
01238 dest_storage, dest_len,
01239 0, 0,
01240 'd', ' ');
01241 SqlStringTestGen src(
01242 src_storage, src_len,
01243 0, src_storage - src_len,
01244 's', ' ');
01245 src.randomize('A');
01246
01247 string save(src.mStr, src_len);
01248 string::iterator itr;
01249 char const *s;
01250 int count;
01251
01252
01253 caught = false;
01254 try {
01255 newlen = SqlStrAsciiToLower(
01256 dest.mStr, dest_storage, src.mStr, src_len);
01257 } catch (const char *str) {
01258 caught = true;
01259 BOOST_CHECK_EQUAL(strcmp(str, "22001"), 0);
01260 BOOST_CHECK(src_len > dest_storage);
01261 } catch (...) {
01262 BOOST_CHECK(false);
01263 }
01264 if (!caught) {
01265 BOOST_CHECK(src_len <= dest_storage);
01266 BOOST_CHECK(src.verify());
01267 BOOST_CHECK(dest.verify());
01268 BOOST_CHECK_EQUAL(newlen, src_len);
01269
01270 itr = save.begin();
01271 s = dest.mStr;
01272 count = 0;
01273 while (itr != save.end()) {
01274 if (*itr >= 'A' && *itr <= 'Z') {
01275 BOOST_CHECK_EQUAL(*s, (*itr + ('a' - 'A')));
01276 } else {
01277 BOOST_CHECK_EQUAL(*itr, *s);
01278 }
01279 s++;
01280 itr++;
01281 count++;
01282 }
01283 BOOST_CHECK_EQUAL(count, src_len);
01284 }
01285 }
01286 }
01287 }
01288 }
01289
01290
01291 void
01292 SqlStringTest::testSqlStringAsciiToUpper()
01293 {
01294 int dest_storage, dest_len, src_storage, src_len, randX;
01295 int newlen;
01296 bool caught;
01297
01298
01299 for (dest_storage = 0; dest_storage < MAXLEN; dest_storage++) {
01300 dest_len = dest_storage;
01301 for (src_storage = 0; src_storage < MAXLEN; src_storage++) {
01302 src_len = src_storage;
01303 for (randX = 0; randX < MAXRANDOM; randX++) {
01304 SqlStringTestGen dest(
01305 dest_storage, dest_len,
01306 0, 0,
01307 'd', ' ');
01308 SqlStringTestGen src(
01309 src_storage, src_len,
01310 0, src_storage - src_len,
01311 's', ' ');
01312 src.randomize('a');
01313
01314 string save(src.mStr, src_len);
01315 string::iterator itr;
01316 char const *s;
01317 int count;
01318
01319
01320 caught = false;
01321 try {
01322 newlen = SqlStrAsciiToUpper(
01323 dest.mStr, dest_storage, src.mStr, src_len);
01324 } catch (const char *str) {
01325 caught = true;
01326 BOOST_CHECK_EQUAL(strcmp(str, "22001"), 0);
01327 BOOST_CHECK(src_len > dest_storage);
01328 } catch (...) {
01329 BOOST_CHECK(false);
01330 }
01331 if (!caught) {
01332 BOOST_CHECK(src_len <= dest_storage);
01333 BOOST_CHECK(src.verify());
01334 BOOST_CHECK(dest.verify());
01335 BOOST_CHECK_EQUAL(newlen, src_len);
01336
01337 itr = save.begin();
01338 s = dest.mStr;
01339 count = 0;
01340
01341 while (itr != save.end()) {
01342 if (*itr >= 'a' && *itr <= 'z') {
01343 BOOST_CHECK_EQUAL(*s, (*itr - ('a' - 'A')));
01344 } else {
01345 BOOST_CHECK_EQUAL(*itr, *s);
01346 }
01347 s++;
01348 itr++;
01349 count++;
01350 }
01351 BOOST_CHECK_EQUAL(count, src_len);
01352 }
01353 }
01354 }
01355 }
01356 }
01357
01358 void
01359 SqlStringTest::testSqlStringAsciiTrim()
01360 {
01361 int dst_storage, src_storage, src_len, leftpad, rightpad, randX, i;
01362 char padchar = ' ';
01363 char textchar = 's';
01364 bool caught;
01365
01366 BOOST_REQUIRE(MAXLEN >= 5);
01367
01368 for (dst_storage = 0; dst_storage < MAXLEN; dst_storage++) {
01369 for (src_storage = 0; src_storage < dst_storage + 5; src_storage++) {
01370 for (src_len = 0; src_len <= src_storage; src_len++) {
01371 for (leftpad = 0; leftpad <= src_storage - src_len; leftpad++) {
01372 rightpad = src_storage - (src_len + leftpad);
01373 for (randX = 0; randX < MAXRANDOM; randX++) {
01374 BOOST_REQUIRE(
01375 leftpad + rightpad + src_len == src_storage);
01376 for (i = 0; i < 4; i++) {
01377 int newsize;
01378 int expectsize;
01379 string resultByReference;
01380 string resultCopy;
01381 string expect;
01382 SqlStringTestGen src(
01383 src_storage, src_len,
01384 leftpad, rightpad,
01385 textchar, padchar);
01386 SqlStringTestGen dst(
01387 dst_storage, dst_storage,
01388 0, 0,
01389 textchar, padchar);
01390
01391 int lefttrim, righttrim;
01392 switch (i) {
01393 case 0:
01394 lefttrim = true;
01395 righttrim = true;
01396 expect.append(src_len, textchar);
01397 expectsize = src_len;
01398 break;
01399 case 1:
01400 lefttrim = true;
01401 righttrim = false;
01402 expect.append(src_len, textchar);
01403
01404 if (src_len) {
01405 expect.append(rightpad, padchar);
01406 }
01407 expectsize = src_len + (src_len ? rightpad : 0);
01408 break;
01409 case 2:
01410 lefttrim = false;
01411 righttrim = true;
01412
01413 if (src_len) {
01414 expect.append(leftpad, padchar);
01415 }
01416 expect.append(src_len, textchar);
01417 expectsize = src_len + (src_len ? leftpad : 0);
01418 break;
01419 case 3:
01420 lefttrim = false;
01421 righttrim = false;
01422 expect.append(leftpad, padchar);
01423 expect.append(src_len, textchar);
01424 expect.append(rightpad, padchar);
01425 expectsize = src_len + leftpad + rightpad;
01426 break;
01427 }
01428
01429
01430 caught = false;
01431 try {
01432 newsize =
01433 SqlStrAsciiTrim(
01434 dst.mStr,
01435 dst_storage,
01436 src.mStr,
01437 src_len + leftpad + rightpad,
01438 lefttrim,
01439 righttrim);
01440 } catch (const char *str) {
01441 caught = true;
01442 BOOST_CHECK_EQUAL(strcmp(str, "22001"), 0);
01443 BOOST_CHECK(expectsize > dst_storage);
01444 } catch (...) {
01445 BOOST_CHECK(false);
01446 }
01447
01448 if (!caught) {
01449 BOOST_CHECK(expectsize <= dst_storage);
01450
01451 BOOST_CHECK(src.verify());
01452 BOOST_CHECK(dst.verify());
01453 BOOST_CHECK_EQUAL(newsize, expectsize);
01454 resultCopy = string(dst.mStr, newsize);
01455
01456 BOOST_CHECK(!resultCopy.compare(expect));
01457 BOOST_CHECK(!expect.compare(resultCopy));
01458 }
01459
01460
01461
01462 char const * start;
01463 newsize = SqlStrAsciiTrim(
01464 &start,
01465 src.mStr,
01466 src_len + leftpad + rightpad,
01467 lefttrim,
01468 righttrim);
01469
01470 BOOST_CHECK(start >= src.mStr);
01471 BOOST_CHECK(start <= src.mStr + src_storage);
01472 BOOST_CHECK(src.verify());
01473 BOOST_CHECK(dst.verify());
01474 BOOST_CHECK_EQUAL(newsize, expectsize);
01475 resultByReference = string(start, newsize);
01476
01477 BOOST_CHECK(!resultByReference.compare(expect));
01478 BOOST_CHECK(!expect.compare(resultByReference));
01479 }
01480 }
01481 }
01482 }
01483 }
01484 }
01485 }
01486
01487
01488 FENNEL_UNIT_TEST_SUITE(SqlStringTest);
01489
01490