Fennel: /home/pub/open/dev/fennel/calctest/CalcExtCastTest.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/common/TraceSource.h"
00026
00027 #include "fennel/tuple/TupleDataWithBuffer.h"
00028 #include "fennel/tuple/TuplePrinter.h"
00029 #include "fennel/calculator/CalcCommon.h"
00030 #include "fennel/calculator/StringToHex.h"
00031 #include "fennel/common/FennelExcn.h"
00032
00033 #include <boost/test/test_tools.hpp>
00034 #include <boost/scoped_array.hpp>
00035 #include
00036 #include
00037 #include <math.h>
00038
00039
00040 using namespace fennel;
00041 using namespace std;
00042
00043 class CalcExtCastTest : virtual public TestBase, public TraceSource
00044 {
00045 void testCalcExtCastStringToChar();
00046 void testCalcExtCastStringToVarChar();
00047 void testCalcExtCastBooleanToChar();
00048 void testCalcExtCastBooleanToVarChar();
00049 void testCalcExtCastExactToChar();
00050 void testCalcExtCastExactToVarChar();
00051 void testCalcExtCastDecimalToChar();
00052 void testCalcExtCastDecimalToVarChar();
00053 void testCalcExtCastBigExactToString();
00054 void testCalcExtCastExactToStringTruncates();
00055 void testCalcExtCastDecimalToStringTruncates();
00056 void testCalcExtCastCharToBoolean();
00057 void testCalcExtCastVarCharToBoolean();
00058 void testCalcExtCastCharToExact();
00059 void testCalcExtCastVarCharToExact();
00060 void testCalcExtCastCharToDecimal();
00061 void testCalcExtCastVarCharToDecimal();
00062 void testCalcExtCastStringToExactFails();
00063 void testCalcExtCastStringToDecimalFails();
00064 void testCalcExtCastStringToDecimalMinMax();
00065 void testCalcExtCastStringToDecimalRange();
00066 void testCalcExtCastStringToApprox();
00067 void testCalcExtCastApproxToString();
00068
00069
00070
00071
00072 int cmpTupStr(TupleDatum const & tup, char const * const str);
00073 int cmpTupStr(TupleDatum const & tup, const string& str);
00074 int cmpTupBool(TupleDatum const & tup, bool val);
00075 int cmpTupInt(TupleDatum const & tup, int val);
00076 int cmpTupInt64(TupleDatum const & tup, int64_t val);
00077 int cmpTupNull(TupleDatum const & tup);
00078 int cmpTupDouble(TupleDatum const & tup, double val);
00079 void printOutput(TupleData const & tup, Calculator const & calc);
00080 void refLocalOutput(ostringstream& pg, int count);
00081 string minInt64String();
00082 string maxInt64String();
00083 string rpad(string s, int size, char pad = ' ');
00084
00085 static const bool verbose = true;
00086
00087 static const char* truncErr;
00088 static const char* invalidCharErr;
00089 static const char* outOfRangeErr;
00090
00091 public:
00092 explicit CalcExtCastTest()
00093 : TraceSource(shared_from_this(),"CalcExtCastTest")
00094 {
00095 srand(time(NULL));
00096 CalcInit::instance();
00097 FENNEL_UNIT_TEST_CASE(CalcExtCastTest, testCalcExtCastStringToChar);
00098 FENNEL_UNIT_TEST_CASE(CalcExtCastTest, testCalcExtCastStringToVarChar);
00099 FENNEL_UNIT_TEST_CASE(CalcExtCastTest, testCalcExtCastBooleanToVarChar);
00100 FENNEL_UNIT_TEST_CASE(CalcExtCastTest, testCalcExtCastBooleanToChar);
00101 FENNEL_UNIT_TEST_CASE(CalcExtCastTest, testCalcExtCastExactToVarChar);
00102 FENNEL_UNIT_TEST_CASE(CalcExtCastTest, testCalcExtCastExactToChar);
00103 FENNEL_UNIT_TEST_CASE(CalcExtCastTest, testCalcExtCastDecimalToChar);
00104 FENNEL_UNIT_TEST_CASE(CalcExtCastTest, testCalcExtCastDecimalToVarChar);
00105 FENNEL_UNIT_TEST_CASE(CalcExtCastTest, testCalcExtCastBigExactToString);
00106 FENNEL_UNIT_TEST_CASE(
00107 CalcExtCastTest, testCalcExtCastExactToStringTruncates);
00108 FENNEL_UNIT_TEST_CASE(
00109 CalcExtCastTest, testCalcExtCastDecimalToStringTruncates);
00110 FENNEL_UNIT_TEST_CASE(CalcExtCastTest, testCalcExtCastCharToBoolean);
00111 FENNEL_UNIT_TEST_CASE(CalcExtCastTest, testCalcExtCastVarCharToBoolean);
00112 FENNEL_UNIT_TEST_CASE(CalcExtCastTest, testCalcExtCastCharToExact);
00113 FENNEL_UNIT_TEST_CASE(CalcExtCastTest, testCalcExtCastVarCharToExact);
00114 FENNEL_UNIT_TEST_CASE(CalcExtCastTest, testCalcExtCastCharToDecimal);
00115 FENNEL_UNIT_TEST_CASE(CalcExtCastTest, testCalcExtCastVarCharToDecimal);
00116 FENNEL_UNIT_TEST_CASE(
00117 CalcExtCastTest, testCalcExtCastStringToExactFails);
00118 FENNEL_UNIT_TEST_CASE(
00119 CalcExtCastTest, testCalcExtCastStringToDecimalFails);
00120 FENNEL_UNIT_TEST_CASE(
00121 CalcExtCastTest, testCalcExtCastStringToDecimalMinMax);
00122 FENNEL_UNIT_TEST_CASE(
00123 CalcExtCastTest, testCalcExtCastStringToDecimalRange);
00124 FENNEL_UNIT_TEST_CASE(CalcExtCastTest, testCalcExtCastStringToApprox);
00125 FENNEL_UNIT_TEST_CASE(CalcExtCastTest, testCalcExtCastApproxToString);
00126 }
00127
00128 virtual ~CalcExtCastTest()
00129 {
00130 }
00131 };
00132
00133 const char * CalcExtCastTest::truncErr = "22001";
00134 const char * CalcExtCastTest::invalidCharErr = "22018";
00135 const char * CalcExtCastTest::outOfRangeErr = "22003";
00136
00137
00138 string CalcExtCastTest::minInt64String()
00139 {
00140 ostringstream os("");
00141 os << dec << numeric_limits::min();
00142 return os.str();
00143 }
00144
00145
00146 string CalcExtCastTest::maxInt64String()
00147 {
00148 ostringstream os("");
00149 os << dec << numeric_limits::max();
00150 return os.str();
00151 }
00152
00153
00154 string
00155 CalcExtCastTest::rpad(string s, int size, char pad)
00156 {
00157 int n = size - s.size();
00158 if (n > 0) {
00159 s.append(n, pad);
00160 }
00161 return s;
00162 }
00163
00164 int
00165 CalcExtCastTest::cmpTupInt(TupleDatum const & tup, int val)
00166 {
00167 if (cmpTupNull(tup)) {
00168 return 1;
00169 }
00170 return *(reinterpret_cast<int*>
00171 (const_cast(tup.pData))) - val;
00172 }
00173
00174 int
00175 CalcExtCastTest::cmpTupDouble(TupleDatum const & tup, double val)
00176 {
00177 if (cmpTupNull(tup)) {
00178 return 1;
00179 }
00180 double tval = * reinterpret_cast<double*>
00181 (const_cast(tup.pData));
00182 if (fabs(tval - val) < 0.00001) {
00183 return 0;
00184 }
00185 return (tval > val) ? 1 : -1;
00186 }
00187
00188 int
00189 CalcExtCastTest::cmpTupInt64(
00190 TupleDatum const & tup,
00191 int64_t val)
00192 {
00193 if (cmpTupNull(tup)) {
00194 return 1;
00195 }
00196 return *(reinterpret_cast<int64_t*>
00197 (const_cast(tup.pData))) - val;
00198 }
00199
00200 int
00201 CalcExtCastTest::cmpTupStr(
00202 TupleDatum const & tup,
00203 const string& s)
00204 {
00205 return cmpTupStr(tup, s.c_str());
00206 }
00207
00208 int
00209 CalcExtCastTest::cmpTupStr(
00210 TupleDatum const & tup,
00211 char const * const str)
00212 {
00213 if (cmpTupNull(tup)) {
00214 return 1;
00215 }
00216 int len = strlen(str);
00217 BOOST_CHECK_EQUAL(len, tup.cbData);
00218 return strncmp(
00219 reinterpret_cast<char *>(const_cast(tup.pData)),
00220 str,
00221 len);
00222 }
00223
00224 int
00225 CalcExtCastTest::cmpTupBool(TupleDatum const & tup, bool val)
00226 {
00227 if (cmpTupNull(tup)) {
00228 return 0;
00229 }
00230 return *(reinterpret_cast<bool*>
00231 (const_cast(tup.pData))) == val;
00232 }
00233
00234 int
00235 CalcExtCastTest::cmpTupNull(TupleDatum const & tup)
00236 {
00237 return ((const_cast(tup.pData)) == NULL)? 1 : 0;
00238 }
00239
00240
00241 void
00242 CalcExtCastTest::printOutput(
00243 TupleData const & tup,
00244 Calculator const & calc)
00245 {
00246 if (verbose) {
00247 TuplePrinter tuplePrinter;
00248 tuplePrinter.print(cout, calc.getOutputRegisterDescriptor(), tup);
00249 cout << endl;
00250 }
00251 }
00252
00253
00254
00255 void
00256 CalcExtCastTest::refLocalOutput(
00257 ostringstream& pg,
00258 int count)
00259 {
00260 int i;
00261
00262 for (i = 0; i < count; i++) {
00263 pg << "REF O" << i << ", L" << i << ";" << endl;
00264 }
00265 }
00266
00267
00268 void
00269 CalcExtCastTest::testCalcExtCastStringToChar()
00270 {
00271 ostringstream pg(""), outloc("");
00272
00273 outloc << "c,5, c,5, c,5, c,5, c,5, c,5, c,5, c,5;" << endl;
00274
00275 pg << "O " << outloc.str();
00276 pg << "L " << outloc.str();
00277 pg << "C vc,3, vc,8, c,3, c,8, vc,8, c,8, vc,8, c,8;" << endl;
00278 pg << "V 0x" << stringToHex("ABC");
00279 pg << ", 0x" << stringToHex("DEFGH");
00280 pg << ", 0x" << stringToHex("ZYX");
00281 pg << ", 0x" << stringToHex("WVUTS ");
00282 pg << ", 0x" << stringToHex("IJKLMNOP");
00283 pg << ", 0x" << stringToHex("RQPONMLK");
00284 pg << ",,;" << endl;
00285 pg << "T;" << endl;
00286
00287
00288 pg << "CALL 'castA(L0, C0);" << endl;
00289
00290
00291 pg << "CALL 'castA(L1, C1);" << endl;
00292
00293
00294 pg << "CALL 'castA(L2, C2);" << endl;
00295
00296
00297 pg << "CALL 'castA(L3, C3);" << endl;
00298
00299
00300 pg << "CALL 'castA(L4, C4);" << endl;
00301
00302
00303 pg << "CALL 'castA(L5, C5);" << endl;
00304
00305
00306 pg << "CALL 'castA(L6, C6);" << endl;
00307
00308
00309 pg << "CALL 'castA(L7, C7);" << endl;
00310
00311
00312 refLocalOutput(pg, 8);
00313
00314 Calculator calc(0);
00315
00316 try {
00317 calc.assemble(pg.str().c_str());
00318 } catch (FennelExcn& ex) {
00319 BOOST_MESSAGE("Assemble exception " << ex.getMessage());
00320 BOOST_MESSAGE(pg.str());
00321 BOOST_REQUIRE(0);
00322 }
00323
00324 TupleDataWithBuffer outTuple(calc.getOutputRegisterDescriptor());
00325 TupleDataWithBuffer inTuple(calc.getInputRegisterDescriptor());
00326
00327 calc.bind(&inTuple, &outTuple);
00328 calc.exec();
00329 printOutput(outTuple, calc);
00330 deque::iterator iter = calc.mWarnings.begin();
00331
00332
00333 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[0], "ABC "));
00334
00335
00336 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[1], "DEFGH"));
00337
00338
00339 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[2], "ZYX "));
00340
00341
00342 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[3], "WVUTS"));
00343
00344
00345 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[4], "IJKLM"));
00346
00347
00348
00349
00350
00351
00352 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[5], "RQPON"));
00353
00354
00355
00356
00357
00358
00359 BOOST_CHECK_EQUAL(1, cmpTupNull(outTuple[6]));
00360
00361
00362 BOOST_CHECK_EQUAL(1, cmpTupNull(outTuple[7]));
00363
00364 BOOST_CHECK(iter == calc.mWarnings.end());
00365 }
00366
00367
00368 void
00369 CalcExtCastTest::testCalcExtCastStringToVarChar()
00370 {
00371 ostringstream pg(""), outloc("");
00372
00373 outloc << "vc,5, vc,5, vc,5, vc,5, vc,5, vc,5, vc,5, vc,5;" << endl;
00374
00375 pg << "O " << outloc.str();
00376 pg << "L " << outloc.str();
00377 pg << "C vc,3, vc,8, c,3, c,8, vc,8, c,8, vc,8, c,8;" << endl;
00378 pg << "V 0x" << stringToHex("ABC");
00379 pg << ", 0x" << stringToHex("DEFGH");
00380 pg << ", 0x" << stringToHex("ZYX");
00381 pg << ", 0x" << stringToHex("WVUTS ");
00382 pg << ", 0x" << stringToHex("IJKLMNOP");
00383 pg << ", 0x" << stringToHex("RQPONMLK");
00384 pg << ",,;" << endl;
00385 pg << "T;" << endl;
00386
00387
00388 pg << "CALL 'castA(L0, C0);" << endl;
00389
00390
00391 pg << "CALL 'castA(L1, C1);" << endl;
00392
00393
00394 pg << "CALL 'castA(L2, C2);" << endl;
00395
00396
00397 pg << "CALL 'castA(L3, C3);" << endl;
00398
00399
00400 pg << "CALL 'castA(L4, C4);" << endl;
00401
00402
00403 pg << "CALL 'castA(L5, C5);" << endl;
00404
00405
00406 pg << "CALL 'castA(L6, C6);" << endl;
00407
00408
00409 pg << "CALL 'castA(L7, C7);" << endl;
00410
00411
00412 refLocalOutput(pg, 8);
00413
00414 Calculator calc(0);
00415
00416 try {
00417 calc.assemble(pg.str().c_str());
00418 } catch (FennelExcn& ex) {
00419 BOOST_MESSAGE("Assemble exception " << ex.getMessage());
00420 BOOST_MESSAGE(pg.str());
00421 BOOST_REQUIRE(0);
00422 }
00423
00424 TupleDataWithBuffer outTuple(calc.getOutputRegisterDescriptor());
00425 TupleDataWithBuffer inTuple(calc.getInputRegisterDescriptor());
00426
00427 calc.bind(&inTuple, &outTuple);
00428 calc.exec();
00429 printOutput(outTuple, calc);
00430 deque::iterator iter = calc.mWarnings.begin();
00431
00432
00433 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[0], "ABC"));
00434
00435
00436 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[1], "DEFGH"));
00437
00438
00439 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[2], "ZYX"));
00440
00441
00442 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[3], "WVUTS"));
00443
00444
00445 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[4], "IJKLM"));
00446
00447
00448
00449
00450
00451
00452 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[5], "RQPON"));
00453
00454
00455
00456
00457
00458
00459 BOOST_CHECK_EQUAL(1, cmpTupNull(outTuple[6]));
00460
00461
00462 BOOST_CHECK_EQUAL(1, cmpTupNull(outTuple[7]));
00463
00464 BOOST_CHECK(iter == calc.mWarnings.end());
00465 }
00466
00467
00468 void
00469 CalcExtCastTest::testCalcExtCastBooleanToChar()
00470 {
00471
00472
00473 ostringstream pg(""), outloc("");
00474 outloc << "c,3, c,3, c,3, c,4, c,4, c,4, c,5, c,5, c,5;" << endl;
00475 pg << "O " << outloc.str();
00476 pg << "L " << outloc.str();
00477 pg << "C bo, bo, bo;" << endl;
00478 pg << "V , 1, 0;" << endl;
00479 pg << "T;" << endl;
00480
00481 for (int i = 0; i < 3; i++) {
00482 pg << "CALL 'castA(L" << i << ", C" << i << ");" << endl;
00483 }
00484
00485 for (int i = 0; i < 3; i++) {
00486 pg << "CALL 'castA(L" << (i + 3) << ", C" << i << ");" << endl;
00487 }
00488
00489 for (int i = 0; i < 3; i++) {
00490 pg << "CALL 'castA(L" << (i + 6) << ", C" << i << ");" << endl;
00491 }
00492 refLocalOutput(pg, 9);
00493
00494 Calculator calc(0);
00495 try {
00496 calc.assemble(pg.str().c_str());
00497 } catch (FennelExcn& ex) {
00498 BOOST_MESSAGE("Assemble exception " << ex.getMessage());
00499 BOOST_MESSAGE(pg.str());
00500 BOOST_REQUIRE(0);
00501 }
00502
00503 TupleDataWithBuffer outTuple(calc.getOutputRegisterDescriptor());
00504 TupleDataWithBuffer inTuple(calc.getInputRegisterDescriptor());
00505 calc.bind(&inTuple, &outTuple);
00506 calc.exec();
00507 printOutput(outTuple, calc);
00508 deque::iterator iter = calc.mWarnings.begin();
00509
00510
00511 BOOST_CHECK(cmpTupNull(outTuple[0]));
00512
00513
00514 BOOST_CHECK_EQUAL(iter->pc, 1);
00515 BOOST_CHECK_EQUAL(0, strcmp(iter->str, invalidCharErr));
00516 iter++;
00517
00518
00519 BOOST_CHECK_EQUAL(iter->pc, 2);
00520 BOOST_CHECK_EQUAL(0, strcmp(iter->str, invalidCharErr));
00521 iter++;
00522
00523 BOOST_CHECK(cmpTupNull(outTuple[3]));
00524 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[4], "TRUE"));
00525
00526
00527 BOOST_CHECK_EQUAL(iter->pc, 5);
00528 BOOST_CHECK_EQUAL(0, strcmp(iter->str, invalidCharErr));
00529 iter++;
00530
00531 BOOST_CHECK(cmpTupNull(outTuple[6]));
00532 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[7], "TRUE "));
00533 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[8], "FALSE"));
00534 BOOST_CHECK(iter == calc.mWarnings.end());
00535 }
00536
00537
00538 void
00539 CalcExtCastTest::testCalcExtCastBooleanToVarChar()
00540 {
00541
00542
00543 ostringstream pg(""), outloc("");
00544 outloc << "vc,3, vc,3, vc,3, vc,4, vc,4, vc,4, vc,5, vc,5, vc,5;" << endl;
00545 pg << "O " << outloc.str();
00546 pg << "L " << outloc.str();
00547 pg << "C bo, bo, bo;" << endl;
00548 pg << "V , 1, 0;" << endl;
00549 pg << "T;" << endl;
00550
00551 for (int i = 0; i < 3; i++) {
00552 pg << "CALL 'castA(L" << i << ", C" << i << ");" << endl;
00553 }
00554
00555 for (int i = 0; i < 3; i++) {
00556 pg << "CALL 'castA(L" << (i + 3) << ", C" << i << ");" << endl;
00557 }
00558
00559 for (int i = 0; i < 3; i++) {
00560 pg << "CALL 'castA(L" << (i + 6) << ", C" << i << ");" << endl;
00561 }
00562 refLocalOutput(pg, 9);
00563
00564 Calculator calc(0);
00565 try {
00566 calc.assemble(pg.str().c_str());
00567 } catch (FennelExcn& ex) {
00568 BOOST_MESSAGE("Assemble exception " << ex.getMessage());
00569 BOOST_MESSAGE(pg.str());
00570 BOOST_REQUIRE(0);
00571 }
00572
00573 TupleDataWithBuffer outTuple(calc.getOutputRegisterDescriptor());
00574 TupleDataWithBuffer inTuple(calc.getInputRegisterDescriptor());
00575 calc.bind(&inTuple, &outTuple);
00576 calc.exec();
00577 printOutput(outTuple, calc);
00578 deque::iterator iter = calc.mWarnings.begin();
00579
00580
00581 BOOST_CHECK(cmpTupNull(outTuple[0]));
00582
00583
00584 BOOST_CHECK_EQUAL(iter->pc, 1);
00585 BOOST_CHECK_EQUAL(0, strcmp(iter->str, invalidCharErr));
00586 iter++;
00587
00588
00589 BOOST_CHECK_EQUAL(iter->pc, 2);
00590 BOOST_CHECK_EQUAL(0, strcmp(iter->str, invalidCharErr));
00591 iter++;
00592
00593 BOOST_CHECK(cmpTupNull(outTuple[3]));
00594 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[4], "TRUE"));
00595
00596
00597 BOOST_CHECK_EQUAL(iter->pc, 5);
00598 BOOST_CHECK_EQUAL(0, strcmp(iter->str, invalidCharErr));
00599 iter++;
00600
00601 BOOST_CHECK(cmpTupNull(outTuple[6]));
00602 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[7], "TRUE"));
00603 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[8], "FALSE"));
00604 BOOST_CHECK(iter == calc.mWarnings.end());
00605 }
00606
00607
00608 void
00609 CalcExtCastTest::testCalcExtCastExactToChar()
00610 {
00611
00612 ostringstream pg(""), outloc("");
00613 outloc << "c,3, c,3, c,3, c,3, c,16, c,16, c,16, c,16;" << endl;
00614 pg << "O " << outloc.str();
00615 pg << "L " << outloc.str();
00616 pg << "C s8, s8, s8, s8;" << endl;
00617 pg << "V , 0, 10, -10;" << endl;
00618 pg << "T;" << endl;
00619
00620 for (int i = 0; i < 4; i++) {
00621 pg << "CALL 'castA(L" << i << ", C" << i << ");" << endl;
00622 }
00623
00624 for (int i = 0; i < 4; i++) {
00625 pg << "CALL 'castA(L" << (i + 4) << ", C" << i << ");" << endl;
00626 }
00627 refLocalOutput(pg, 8);
00628
00629 Calculator calc(0);
00630 try {
00631 calc.assemble(pg.str().c_str());
00632 } catch (FennelExcn& ex) {
00633 BOOST_MESSAGE("Assemble exception " << ex.getMessage());
00634 BOOST_MESSAGE(pg.str());
00635 BOOST_REQUIRE(0);
00636 }
00637
00638 TupleDataWithBuffer outTuple(calc.getOutputRegisterDescriptor());
00639 TupleDataWithBuffer inTuple(calc.getInputRegisterDescriptor());
00640 calc.bind(&inTuple, &outTuple);
00641 calc.exec();
00642 printOutput(outTuple, calc);
00643 deque::iterator iter = calc.mWarnings.begin();
00644
00645
00646 BOOST_CHECK(cmpTupNull(outTuple[0]));
00647 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[1], "0 "));
00648 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[2], "10 "));
00649 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[3], "-10"));
00650 BOOST_CHECK(cmpTupNull(outTuple[4]));
00651 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[5], "0 "));
00652 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[6], "10 "));
00653 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[7], "-10 "));
00654 BOOST_CHECK(iter == calc.mWarnings.end());
00655 }
00656
00657
00658 void
00659 CalcExtCastTest::testCalcExtCastExactToVarChar()
00660 {
00661
00662 ostringstream pg(""), outloc("");
00663 outloc << "vc,3, vc,3, vc,3, vc,3, vc,16, vc,16, vc,16, vc,16;" << endl;
00664 pg << "O " << outloc.str();
00665 pg << "L " << outloc.str();
00666 pg << "C s8, s8, s8, s8;" << endl;
00667 pg << "V , 0, 10, -10;" << endl;
00668 pg << "T;" << endl;
00669
00670 for (int i = 0; i < 4; i++) {
00671 pg << "CALL 'castA(L" << i << ", C" << i << ");" << endl;
00672 }
00673
00674 for (int i = 0; i < 4; i++) {
00675 pg << "CALL 'castA(L" << (i + 4) << ", C" << i << ");" << endl;
00676 }
00677 refLocalOutput(pg, 8);
00678
00679 Calculator calc(0);
00680 try {
00681 calc.assemble(pg.str().c_str());
00682 } catch (FennelExcn& ex) {
00683 BOOST_MESSAGE("Assemble exception " << ex.getMessage());
00684 BOOST_MESSAGE(pg.str());
00685 BOOST_REQUIRE(0);
00686 }
00687
00688 TupleDataWithBuffer outTuple(calc.getOutputRegisterDescriptor());
00689 TupleDataWithBuffer inTuple(calc.getInputRegisterDescriptor());
00690 calc.bind(&inTuple, &outTuple);
00691 calc.exec();
00692 printOutput(outTuple, calc);
00693 deque::iterator iter = calc.mWarnings.begin();
00694
00695
00696 BOOST_CHECK(cmpTupNull(outTuple[0]));
00697 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[1], "0"));
00698 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[2], "10"));
00699 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[3], "-10"));
00700 BOOST_CHECK(cmpTupNull(outTuple[4]));
00701 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[5], "0"));
00702 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[6], "10"));
00703 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[7], "-10"));
00704 BOOST_CHECK(iter == calc.mWarnings.end());
00705 }
00706
00707
00708 void
00709 CalcExtCastTest::testCalcExtCastDecimalToChar()
00710 {
00711
00712
00713
00714
00715
00716
00717
00718
00719
00720 ostringstream pg(""), outloc("");
00721 outloc << "c,6, c,6, c,6, c,6, c,6, c,6, c,6, "
00722 << "c,16, c,16, c,16, c,16, c,16, c,16, c,16, "
00723 << "c,5, c,5, c,5, c,5, c,5, c,5, c,5, "
00724 << "c,16, c,16, c,16, c,16, c,16, c,16, c,16, "
00725 << "c,7, c,7, c,7, c,7, c,7, c,7, c,7, "
00726 << "c,16, c,16, c,16, c,16, c,16, c,16, c,16;" << endl;
00727 pg << "O " << outloc.str();
00728 pg << "L " << outloc.str();
00729 pg << "C s8, s8, s8, s8, s8, s8, s8, s4, s4, s4, s4;" << endl;
00730 pg << "V , 0, 1000, -1090, 430, -9, 30, 5, 2, 0, -2;" << endl;
00731 pg << "T;" << endl;
00732
00733 for (int i = 0; i < 7; i++) {
00734 pg << "CALL 'castA(L" << i << ", C" << i << ", C7, C8 );" << endl;
00735 }
00736
00737 for (int i = 0; i < 7; i++) {
00738 pg << "CALL 'castA(L" << (i + 7) << ", C" << i << ", C7, C8 );" << endl;
00739 }
00740
00741
00742 for (int i = 0; i < 7; i++) {
00743 pg << "CALL 'castA(L" << (i + 14) << ", C" << i << ", C7, C9 );"
00744 << endl;
00745 }
00746
00747 for (int i = 0; i < 7; i++) {
00748 pg << "CALL 'castA(L" << (i + 21) << ", C" << i << ", C7, C9 );"
00749 << endl;
00750 }
00751
00752
00753 for (int i = 0; i < 7; i++) {
00754 pg << "CALL 'castA(L" << (i + 28) << ", C" << i << ", C7, C10 );"
00755 << endl;
00756 }
00757
00758 for (int i = 0; i < 7; i++) {
00759 pg << "CALL 'castA(L" << (i + 35) << ", C" << i << ", C7, C10 );"
00760 << endl;
00761 }
00762
00763 refLocalOutput(pg, 7*6);
00764
00765 Calculator calc(0);
00766 try {
00767 calc.assemble(pg.str().c_str());
00768 } catch (FennelExcn& ex) {
00769 BOOST_MESSAGE("Assemble exception " << ex.getMessage());
00770 BOOST_MESSAGE(pg.str());
00771 BOOST_REQUIRE(0);
00772 }
00773
00774 TupleDataWithBuffer outTuple(calc.getOutputRegisterDescriptor());
00775 TupleDataWithBuffer inTuple(calc.getInputRegisterDescriptor());
00776 calc.bind(&inTuple, &outTuple);
00777 calc.exec();
00778 printOutput(outTuple, calc);
00779 deque::iterator iter = calc.mWarnings.begin();
00780
00781
00782
00783 BOOST_CHECK(cmpTupNull(outTuple[0]));
00784 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[1], ".00 "));
00785 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[2], "10.00 "));
00786 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[3], "-10.90"));
00787 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[4], "4.30 "));
00788 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[5], "-.09 "));
00789 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[6], ".30 "));
00790 BOOST_CHECK(cmpTupNull(outTuple[7]));
00791 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[8], ".00 "));
00792 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[9], "10.00 "));
00793 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[10], "-10.90 "));
00794 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[11], "4.30 "));
00795 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[12], "-.09 "));
00796 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[13], ".30 "));
00797
00798
00799 BOOST_CHECK(cmpTupNull(outTuple[14]));
00800 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[15], "0 "));
00801 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[16], "1000 "));
00802 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[17], "-1090"));
00803 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[18], "430 "));
00804 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[19], "-9 "));
00805 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[20], "30 "));
00806 BOOST_CHECK(cmpTupNull(outTuple[21]));
00807 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[22], "0 "));
00808 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[23], "1000 "));
00809 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[24], "-1090 "));
00810 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[25], "430 "));
00811 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[26], "-9 "));
00812 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[27], "30 "));
00813
00814
00815 BOOST_CHECK(cmpTupNull(outTuple[28]));
00816 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[29], "0 "));
00817 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[30], "100000 "));
00818 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[31], "-109000"));
00819 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[32], "43000 "));
00820 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[33], "-900 "));
00821 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[34], "3000 "));
00822 BOOST_CHECK(cmpTupNull(outTuple[35]));
00823 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[36], "0 "));
00824 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[37], "100000 "));
00825 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[38], "-109000 "));
00826 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[39], "43000 "));
00827 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[40], "-900 "));
00828 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[41], "3000 "));
00829 }
00830
00831
00832 void
00833 CalcExtCastTest::testCalcExtCastDecimalToVarChar()
00834 {
00835
00836
00837
00838
00839
00840
00841
00842
00843
00844 ostringstream pg(""), outloc("");
00845 outloc << "vc,6, vc,6, vc,6, vc,6, vc,6, vc,6, vc,6, "
00846 << "vc,16, vc,16, vc,16, vc,16, vc,16, vc,16, vc,16, "
00847 << "vc,5, vc,5, vc,5, vc,5, vc,5, vc,5, vc,5, "
00848 << "vc,16, vc,16, vc,16, vc,16, vc,16, vc,16, vc,16, "
00849 << "vc,7, vc,7, vc,7, vc,7, vc,7, vc,7, vc,7, "
00850 << "vc,16, vc,16, vc,16, vc,16, vc,16, vc,16, vc,16;" << endl;
00851 pg << "O " << outloc.str();
00852 pg << "L " << outloc.str();
00853 pg << "C s8, s8, s8, s8, s8, s8, s8, s4, s4, s4, s4;" << endl;
00854 pg << "V , 0, 1000, -1090, 430, -9, 30, 5, 2, 0, -2;" << endl;
00855 pg << "T;" << endl;
00856
00857 for (int i = 0; i < 7; i++) {
00858 pg << "CALL 'castA(L" << i << ", C" << i << ", C7, C8 );" << endl;
00859 }
00860
00861 for (int i = 0; i < 7; i++) {
00862 pg << "CALL 'castA(L" << (i + 7) << ", C" << i << ", C7, C8 );" << endl;
00863 }
00864
00865 for (int i = 0; i < 7; i++) {
00866 pg << "CALL 'castA(L" << (i + 14) << ", C" << i << ", C7, C9 );"
00867 << endl;
00868 }
00869
00870 for (int i = 0; i < 7; i++) {
00871 pg << "CALL 'castA(L" << (i + 21) << ", C" << i << ", C7, C9 );"
00872 << endl;
00873 }
00874
00875 for (int i = 0; i < 7; i++) {
00876 pg << "CALL 'castA(L" << (i + 28) << ", C" << i << ", C7, C10 );"
00877 << endl;
00878 }
00879
00880 for (int i = 0; i < 7; i++) {
00881 pg << "CALL 'castA(L" << (i + 35) << ", C" << i << ", C7, C10 );"
00882 << endl;
00883 }
00884 refLocalOutput(pg, 7 * 6);
00885
00886 Calculator calc(0);
00887 try {
00888 calc.assemble(pg.str().c_str());
00889 } catch (FennelExcn& ex) {
00890 BOOST_MESSAGE("Assemble exception " << ex.getMessage());
00891 BOOST_MESSAGE(pg.str());
00892 BOOST_REQUIRE(0);
00893 }
00894
00895 TupleDataWithBuffer outTuple(calc.getOutputRegisterDescriptor());
00896 TupleDataWithBuffer inTuple(calc.getInputRegisterDescriptor());
00897 calc.bind(&inTuple, &outTuple);
00898 calc.exec();
00899 printOutput(outTuple, calc);
00900 deque::iterator iter = calc.mWarnings.begin();
00901
00902
00903
00904 BOOST_CHECK(cmpTupNull(outTuple[0]));
00905 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[1], ".00"));
00906 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[2], "10.00"));
00907 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[3], "-10.90"));
00908 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[4], "4.30"));
00909 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[5], "-.09"));
00910 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[6], ".30"));
00911 BOOST_CHECK(cmpTupNull(outTuple[7]));
00912 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[8], ".00"));
00913 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[9], "10.00"));
00914 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[10], "-10.90"));
00915 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[11], "4.30"));
00916 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[12], "-.09"));
00917 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[13], ".30"));
00918
00919
00920 BOOST_CHECK(cmpTupNull(outTuple[14]));
00921 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[15], "0"));
00922 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[16], "1000"));
00923 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[17], "-1090"));
00924 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[18], "430"));
00925 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[19], "-9"));
00926 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[20], "30"));
00927 BOOST_CHECK(cmpTupNull(outTuple[21]));
00928 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[22], "0"));
00929 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[23], "1000"));
00930 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[24], "-1090"));
00931 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[25], "430"));
00932 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[26], "-9"));
00933 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[27], "30"));
00934
00935
00936 BOOST_CHECK(cmpTupNull(outTuple[28]));
00937 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[29], "0"));
00938 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[30], "100000"));
00939 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[31], "-109000"));
00940 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[32], "43000"));
00941 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[33], "-900"));
00942 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[34], "3000"));
00943 BOOST_CHECK(cmpTupNull(outTuple[35]));
00944 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[36], "0"));
00945 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[37], "100000"));
00946 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[38], "-109000"));
00947 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[39], "43000"));
00948 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[40], "-900"));
00949 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[41], "3000"));
00950 }
00951
00952
00953 void
00954 CalcExtCastTest::testCalcExtCastBigExactToString()
00955 {
00956
00957 ostringstream pg(""), outloc("");
00958 outloc << "vc,32, vc,32, c,32, c,32;" << endl;
00959 pg << "O " << outloc.str();
00960 pg << "L " << outloc.str();
00961 pg << "C s8, s8;" << endl;
00962 pg << "V " << maxInt64String() << ", " << minInt64String() << ";" << endl;
00963 pg << "T;" << endl;
00964 pg << "CALL 'castA(L0, C0);" << endl;
00965 pg << "CALL 'castA(L1, C1);" << endl;
00966 pg << "CALL 'castA(L2, C0);" << endl;
00967 pg << "CALL 'castA(L3, C1);" << endl;
00968 refLocalOutput(pg, 4);
00969
00970 Calculator calc(0);
00971 try {
00972 calc.assemble(pg.str().c_str());
00973 } catch (FennelExcn& ex) {
00974 BOOST_MESSAGE("Assemble exception " << ex.getMessage());
00975 BOOST_MESSAGE(pg.str());
00976 BOOST_REQUIRE(0);
00977 }
00978
00979 TupleDataWithBuffer outTuple(calc.getOutputRegisterDescriptor());
00980 TupleDataWithBuffer inTuple(calc.getInputRegisterDescriptor());
00981 calc.bind(&inTuple, &outTuple);
00982 calc.exec();
00983 printOutput(outTuple, calc);
00984 deque::iterator iter = calc.mWarnings.begin();
00985
00986
00987 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[0], maxInt64String()));
00988 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[1], minInt64String()));
00989 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[2], rpad(maxInt64String(), 32)));
00990 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[3], rpad(minInt64String(), 32)));
00991 BOOST_CHECK(iter == calc.mWarnings.end());
00992 }
00993
00994
00995 void
00996 CalcExtCastTest::testCalcExtCastExactToStringTruncates()
00997 {
00998
00999 ostringstream pg(""), outloc("");
01000 outloc << "vc,3, vc,3, c,3, c,3;" << endl;
01001 pg << "O " << outloc.str();
01002 pg << "L " << outloc.str();
01003 pg << "C s8, s8;" << endl;
01004 pg << "V 1666, -1666;" << endl;
01005 pg << "T;" << endl;
01006 pg << "CALL 'castA(L0, C0);" << endl;
01007 pg << "CALL 'castA(L1, C1);" << endl;
01008 pg << "CALL 'castA(L2, C0);" << endl;
01009 pg << "CALL 'castA(L3, C1);" << endl;
01010 refLocalOutput(pg, 4);
01011
01012 Calculator calc(0);
01013 try {
01014 calc.assemble(pg.str().c_str());
01015 } catch (FennelExcn& ex) {
01016 BOOST_MESSAGE("Assemble exception " << ex.getMessage());
01017 BOOST_MESSAGE(pg.str());
01018 BOOST_REQUIRE(0);
01019 }
01020
01021 TupleDataWithBuffer outTuple(calc.getOutputRegisterDescriptor());
01022 TupleDataWithBuffer inTuple(calc.getInputRegisterDescriptor());
01023 calc.bind(&inTuple, &outTuple);
01024 calc.exec();
01025 printOutput(outTuple, calc);
01026 deque::iterator iter = calc.mWarnings.begin();
01027
01028
01029
01030 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[0], "166"));
01031 BOOST_CHECK_EQUAL(iter->pc, 0);
01032 BOOST_CHECK_EQUAL(0, strcmp(iter->str, truncErr));
01033 iter++;
01034
01035
01036 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[1], "-16"));
01037 BOOST_CHECK_EQUAL(iter->pc, 1);
01038 BOOST_CHECK_EQUAL(0, strcmp(iter->str, truncErr));
01039 iter++;
01040
01041
01042 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[2], "166"));
01043 BOOST_CHECK_EQUAL(iter->pc, 2);
01044 BOOST_CHECK_EQUAL(0, strcmp(iter->str, truncErr));
01045 iter++;
01046
01047
01048 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[3], "-16"));
01049 BOOST_CHECK_EQUAL(iter->pc, 3);
01050 BOOST_CHECK_EQUAL(0, strcmp(iter->str, truncErr));
01051 iter++;
01052 BOOST_CHECK(iter == calc.mWarnings.end());
01053 }
01054
01055
01056
01057 void
01058 CalcExtCastTest::testCalcExtCastDecimalToStringTruncates()
01059 {
01060
01061
01062
01063
01064
01065 ostringstream pg(""), outloc("");
01066 outloc << "vc,3, vc,3, vc,3, c,3, c,3, c,3, "
01067 << "vc,3, vc,3, vc,3, c,3, c,3, c,3, "
01068 << "vc,3, vc,3, vc,3, c,3, c,3, c,3;" << endl;
01069 pg << "O " << outloc.str();
01070 pg << "L " << outloc.str();
01071 pg << "C s8, s8, s8, s4, s4, s4, s4;" << endl;
01072 pg << "V -1090, -9, 30, 5, 2, 0, -2;" << endl;
01073 pg << "T;" << endl;
01074
01075 pg << "CALL 'castA(L0, C0, C3, C4);" << endl;
01076 pg << "CALL 'castA(L1, C1, C3, C4);" << endl;
01077 pg << "CALL 'castA(L2, C2, C3, C4);" << endl;
01078 pg << "CALL 'castA(L3, C0, C3, C4);" << endl;
01079 pg << "CALL 'castA(L4, C1, C3, C4);" << endl;
01080 pg << "CALL 'castA(L5, C2, C3, C4);" << endl;
01081
01082 pg << "CALL 'castA(L6, C0, C3, C5);" << endl;
01083 pg << "CALL 'castA(L7, C1, C3, C5);" << endl;
01084 pg << "CALL 'castA(L8, C2, C3, C5);" << endl;
01085 pg << "CALL 'castA(L9, C0, C3, C5);" << endl;
01086 pg << "CALL 'castA(L10, C1, C3, C5);" << endl;
01087 pg << "CALL 'castA(L11, C2, C3, C5);" << endl;
01088
01089 pg << "CALL 'castA(L12, C0, C3, C6);" << endl;
01090 pg << "CALL 'castA(L13, C1, C3, C6);" << endl;
01091 pg << "CALL 'castA(L14, C2, C3, C6);" << endl;
01092 pg << "CALL 'castA(L15, C0, C3, C6);" << endl;
01093 pg << "CALL 'castA(L16, C1, C3, C6);" << endl;
01094 pg << "CALL 'castA(L17, C2, C3, C6);" << endl;
01095
01096 refLocalOutput(pg, 18);
01097
01098 Calculator calc(0);
01099 try {
01100 calc.assemble(pg.str().c_str());
01101 } catch (FennelExcn& ex) {
01102 BOOST_MESSAGE("Assemble exception " << ex.getMessage());
01103 BOOST_MESSAGE(pg.str());
01104 BOOST_REQUIRE(0);
01105 }
01106
01107 TupleDataWithBuffer outTuple(calc.getOutputRegisterDescriptor());
01108 TupleDataWithBuffer inTuple(calc.getInputRegisterDescriptor());
01109 calc.bind(&inTuple, &outTuple);
01110 calc.exec();
01111 printOutput(outTuple, calc);
01112 deque::iterator iter = calc.mWarnings.begin();
01113
01114
01115
01116
01117 BOOST_CHECK_EQUAL(iter->pc, 0);
01118 BOOST_CHECK_EQUAL(0, strcmp(iter->str, truncErr));
01119 iter++;
01120
01121
01122 BOOST_CHECK_EQUAL(iter->pc, 1);
01123 BOOST_CHECK_EQUAL(0, strcmp(iter->str, truncErr));
01124 iter++;
01125
01126
01127 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[2], ".30"));
01128
01129
01130 BOOST_CHECK_EQUAL(iter->pc, 3);
01131 BOOST_CHECK_EQUAL(0, strcmp(iter->str, truncErr));
01132 iter++;
01133
01134
01135 BOOST_CHECK_EQUAL(iter->pc, 4);
01136 BOOST_CHECK_EQUAL(0, strcmp(iter->str, truncErr));
01137 iter++;
01138
01139
01140 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[5], ".30"));
01141
01142
01143
01144 BOOST_CHECK_EQUAL(iter->pc, 6);
01145 BOOST_CHECK_EQUAL(0, strcmp(iter->str, truncErr));
01146 iter++;
01147
01148
01149 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[7], "-9"));
01150
01151
01152 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[8], "30"));
01153
01154
01155 BOOST_CHECK_EQUAL(iter->pc, 9);
01156 BOOST_CHECK_EQUAL(0, strcmp(iter->str, truncErr));
01157 iter++;
01158
01159
01160 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[10], "-9 "));
01161
01162
01163 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[11], "30 "));
01164
01165
01166
01167 BOOST_CHECK_EQUAL(iter->pc, 12);
01168 BOOST_CHECK_EQUAL(0, strcmp(iter->str, truncErr));
01169 iter++;
01170
01171
01172 BOOST_CHECK_EQUAL(iter->pc, 13);
01173 BOOST_CHECK_EQUAL(0, strcmp(iter->str, truncErr));
01174 iter++;
01175
01176
01177 BOOST_CHECK_EQUAL(iter->pc, 14);
01178 BOOST_CHECK_EQUAL(0, strcmp(iter->str, truncErr));
01179 iter++;
01180
01181
01182 BOOST_CHECK_EQUAL(iter->pc, 15);
01183 BOOST_CHECK_EQUAL(0, strcmp(iter->str, truncErr));
01184 iter++;
01185
01186
01187 BOOST_CHECK_EQUAL(iter->pc, 16);
01188 BOOST_CHECK_EQUAL(0, strcmp(iter->str, truncErr));
01189 iter++;
01190
01191
01192 BOOST_CHECK_EQUAL(iter->pc, 17);
01193 BOOST_CHECK_EQUAL(0, strcmp(iter->str, truncErr));
01194 iter++;
01195
01196 BOOST_CHECK(iter == calc.mWarnings.end());
01197 }
01198
01199 void CalcExtCastTest::testCalcExtCastCharToBoolean()
01200 {
01201
01202 ostringstream pg(""), outloc("");
01203 outloc << "bo, bo, bo, bo, bo, bo, bo, bo;" << endl;
01204 pg << "O " << outloc.str();
01205 pg << "L " << outloc.str();
01206 pg << "C c,4, c,4, c,8, c,5, c,9, c,7, c,11, c,13;" << endl;
01207 pg << "V "
01208 << ", 0x" << stringToHex("tRUe")
01209 << ", 0x" << stringToHex(" true ")
01210 << ", 0x" << stringToHex("faLSe")
01211 << ", 0x" << stringToHex(" FALSE ")
01212 << ", 0x" << stringToHex("UnknowN")
01213 << ", 0x" << stringToHex(" UnknowN ")
01214 << ", 0x" << stringToHex(" Invalid ")
01215 << ";" << endl;
01216 pg << "T;" << endl;
01217 for (int i = 0; i < 8; i++) {
01218 pg << "CALL 'castA(L"<<i<<",C"<<i<<");"<< endl;
01219 }
01220 refLocalOutput(pg, 8);
01221
01222 Calculator calc(0);
01223 try {
01224 calc.assemble(pg.str().c_str());
01225 } catch (FennelExcn& ex) {
01226 BOOST_MESSAGE("Assemble exception " << ex.getMessage());
01227 BOOST_MESSAGE(pg.str());
01228 BOOST_REQUIRE(0);
01229 }
01230
01231 TupleDataWithBuffer outTuple(calc.getOutputRegisterDescriptor());
01232 TupleDataWithBuffer inTuple(calc.getInputRegisterDescriptor());
01233 calc.bind(&inTuple, &outTuple);
01234 calc.exec();
01235 printOutput(outTuple, calc);
01236 deque::iterator iter = calc.mWarnings.begin();
01237
01238 BOOST_CHECK_EQUAL(1, cmpTupNull(outTuple[0]));
01239 BOOST_CHECK_EQUAL(1, cmpTupBool(outTuple[1], true));
01240 BOOST_CHECK_EQUAL(1, cmpTupBool(outTuple[2], true));
01241 BOOST_CHECK_EQUAL(1, cmpTupBool(outTuple[3], false));
01242 BOOST_CHECK_EQUAL(1, cmpTupBool(outTuple[4], false));
01243
01244
01245
01246 BOOST_CHECK_EQUAL(iter->pc, 5);
01247 BOOST_CHECK_EQUAL(0, strcmp(iter->str, invalidCharErr));
01248 iter++;
01249
01250 BOOST_CHECK_EQUAL(iter->pc, 6);
01251 BOOST_CHECK_EQUAL(0, strcmp(iter->str, invalidCharErr));
01252 iter++;
01253
01254
01255 BOOST_CHECK_EQUAL(iter->pc, 7);
01256 BOOST_CHECK_EQUAL(0, strcmp(iter->str, invalidCharErr));
01257 iter++;
01258
01259 BOOST_CHECK(iter == calc.mWarnings.end());
01260 }
01261
01262 void CalcExtCastTest::testCalcExtCastVarCharToBoolean()
01263 {
01264
01265 ostringstream pg(""), outloc("");
01266 outloc << "bo, bo, bo, bo, bo, bo, bo, bo;" << endl;
01267 pg << "O " << outloc.str();
01268 pg << "L " << outloc.str();
01269 pg << "C vc,4, vc,8, vc,8, vc,9, vc,9, vc,7, vc,11, vc,13;" << endl;
01270 pg << "V "
01271 << ", 0x" << stringToHex("tRUe")
01272 << ", 0x" << stringToHex(" true ")
01273 << ", 0x" << stringToHex("faLSe")
01274 << ", 0x" << stringToHex(" FALSE ")
01275 << ", 0x" << stringToHex("UnknowN")
01276 << ", 0x" << stringToHex(" UnknowN ")
01277 << ", 0x" << stringToHex(" Invalid ")
01278 << ";" << endl;
01279 pg << "T;" << endl;
01280 for (int i = 0; i < 8; i++) {
01281 pg << "CALL 'castA(L" << i << ",C" << i << ");" << endl;
01282 }
01283 refLocalOutput(pg, 8);
01284
01285 Calculator calc(0);
01286 try {
01287 calc.assemble(pg.str().c_str());
01288 } catch (FennelExcn& ex) {
01289 BOOST_MESSAGE("Assemble exception " << ex.getMessage());
01290 BOOST_MESSAGE(pg.str());
01291 BOOST_REQUIRE(0);
01292 }
01293
01294 TupleDataWithBuffer outTuple(calc.getOutputRegisterDescriptor());
01295 TupleDataWithBuffer inTuple(calc.getInputRegisterDescriptor());
01296 calc.bind(&inTuple, &outTuple);
01297 calc.exec();
01298 printOutput(outTuple, calc);
01299 deque::iterator iter = calc.mWarnings.begin();
01300
01301 BOOST_CHECK_EQUAL(1, cmpTupNull(outTuple[0]));
01302 BOOST_CHECK_EQUAL(1, cmpTupBool(outTuple[1], true));
01303 BOOST_CHECK_EQUAL(1, cmpTupBool(outTuple[2], true));
01304 BOOST_CHECK_EQUAL(1, cmpTupBool(outTuple[3], false));
01305 BOOST_CHECK_EQUAL(1, cmpTupBool(outTuple[4], false));
01306
01307
01308
01309 BOOST_CHECK_EQUAL(iter->pc, 5);
01310 BOOST_CHECK_EQUAL(0, strcmp(iter->str, invalidCharErr));
01311 iter++;
01312
01313 BOOST_CHECK_EQUAL(iter->pc, 6);
01314 BOOST_CHECK_EQUAL(0, strcmp(iter->str, invalidCharErr));
01315 iter++;
01316
01317
01318 BOOST_CHECK_EQUAL(iter->pc, 7);
01319 BOOST_CHECK_EQUAL(0, strcmp(iter->str, invalidCharErr));
01320 iter++;
01321
01322 BOOST_CHECK(iter == calc.mWarnings.end());
01323 }
01324
01325
01326 void CalcExtCastTest::testCalcExtCastVarCharToExact()
01327 {
01328
01329 ostringstream pg(""), outloc("");
01330 outloc << "s8, s8, s8, s8, s8, s8, s8, s8, s8;" << endl;
01331 pg << "O " << outloc.str();
01332 pg << "L " << outloc.str();
01333 pg << "C vc,4, vc,4, vc,4, vc,20, vc,21, vc,8, vc,8, vc,32, vc,32;" << endl;
01334 pg << "V "
01335 << ", 0x" << stringToHex("123") << ", 0x" << stringToHex("-123")
01336 << ", 0x" << stringToHex(maxInt64String())
01337 << ", 0x" << stringToHex(minInt64String())
01338 << ", 0x" << stringToHex("123 ") << ", 0x" << stringToHex("-123 ")
01339 << ", 0x" << stringToHex(rpad(maxInt64String(), 32))
01340 << ", 0x" << stringToHex(rpad(minInt64String(), 32))
01341 << ";" << endl;
01342 pg << "T;" << endl;
01343 for (int i = 0; i < 9; i++) {
01344 pg << "CALL 'castA(L" << i << ",C" << i << ");" << endl;
01345 }
01346 refLocalOutput(pg, 9);
01347
01348 Calculator calc(0);
01349 try {
01350 calc.assemble(pg.str().c_str());
01351 } catch (FennelExcn& ex) {
01352 BOOST_MESSAGE("Assemble exception " << ex.getMessage());
01353 BOOST_MESSAGE(pg.str());
01354 BOOST_REQUIRE(0);
01355 }
01356
01357 TupleDataWithBuffer outTuple(calc.getOutputRegisterDescriptor());
01358 TupleDataWithBuffer inTuple(calc.getInputRegisterDescriptor());
01359 calc.bind(&inTuple, &outTuple);
01360 calc.exec();
01361 printOutput(outTuple, calc);
01362 deque::iterator iter = calc.mWarnings.begin();
01363
01364 BOOST_CHECK_EQUAL(1, cmpTupNull(outTuple[0]));
01365 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[1], 123));
01366 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[2], -123));
01367 BOOST_CHECK_EQUAL(
01368 0, cmpTupInt64(outTuple[3], numeric_limits::max()));
01369 BOOST_CHECK_EQUAL(
01370 0, cmpTupInt64(outTuple[4], numeric_limits::min()));
01371 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[5], 123));
01372 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[6], -123));
01373 BOOST_CHECK_EQUAL(
01374 0, cmpTupInt64(outTuple[7], numeric_limits::max()));
01375 BOOST_CHECK_EQUAL(
01376 0, cmpTupInt64(outTuple[8], numeric_limits::min()));
01377 BOOST_CHECK(iter == calc.mWarnings.end());
01378 }
01379
01380 void CalcExtCastTest::testCalcExtCastCharToExact()
01381 {
01382
01383 ostringstream pg(""), outloc("");
01384 outloc << "s8, s8, s8, s8, s8, s8, s8, s8, s8;" << endl;
01385 pg << "O " << outloc.str();
01386 pg << "L " << outloc.str();
01387 pg << "C c,3, c,3, c,4, c,19, c,20, c,8, c,8, c,32, c,32;" << endl;
01388 pg << "V "
01389 << ", 0x" << stringToHex("123") << ", 0x" << stringToHex("-123")
01390 << ", 0x" << stringToHex(maxInt64String())
01391 << ", 0x" << stringToHex(minInt64String())
01392 << ", 0x" << stringToHex("123 ") << ", 0x" << stringToHex("-123 ")
01393 << ", 0x" << stringToHex(rpad(maxInt64String(), 32))
01394 << ", 0x" << stringToHex(rpad(minInt64String(), 32))
01395 << ";" << endl;
01396 pg << "T;" << endl;
01397 for (int i = 0; i < 9; i++) {
01398 pg << "CALL 'castA(L" << i << ",C" << i << ");" << endl;
01399 }
01400 refLocalOutput(pg, 9);
01401
01402 Calculator calc(0);
01403 try {
01404 calc.assemble(pg.str().c_str());
01405 } catch (FennelExcn& ex) {
01406 BOOST_MESSAGE("Assemble exception " << ex.getMessage());
01407 BOOST_MESSAGE(pg.str());
01408 BOOST_REQUIRE(0);
01409 }
01410
01411 TupleDataWithBuffer outTuple(calc.getOutputRegisterDescriptor());
01412 TupleDataWithBuffer inTuple(calc.getInputRegisterDescriptor());
01413 calc.bind(&inTuple, &outTuple);
01414 calc.exec();
01415 printOutput(outTuple, calc);
01416 deque::iterator iter = calc.mWarnings.begin();
01417
01418 BOOST_CHECK_EQUAL(1, cmpTupNull(outTuple[0]));
01419 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[1], 123));
01420 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[2], -123));
01421 BOOST_CHECK_EQUAL(
01422 0, cmpTupInt64(outTuple[3], numeric_limits::max()));
01423 BOOST_CHECK_EQUAL(
01424 0, cmpTupInt64(outTuple[4], numeric_limits::min()));
01425 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[5], 123));
01426 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[6], -123));
01427 BOOST_CHECK_EQUAL(
01428 0, cmpTupInt64(outTuple[7], numeric_limits::max()));
01429 BOOST_CHECK_EQUAL(
01430 0, cmpTupInt64(outTuple[8], numeric_limits::min()));
01431 BOOST_CHECK(iter == calc.mWarnings.end());
01432 }
01433
01434 void CalcExtCastTest::testCalcExtCastVarCharToDecimal()
01435 {
01436
01437
01438
01439
01440
01441 ostringstream pg(""), outloc("");
01442 outloc << "s8, s8, s8, s8, s8, s8, s8, s8, s8, "
01443 << "s8, s8, s8, s8, s8, s8, s8, s8, s8, "
01444 << "s8, s8, s8, s8, s8, s8, s8, s8, s8;"
01445 << endl;
01446 pg << "O " << outloc.str();
01447 pg << "L " << outloc.str();
01448 pg << "C vc,1, vc,5, vc,9, vc,6, vc,7, vc,10, vc,10, vc,10, vc,10, "
01449 << " s4, s4, s4, s4;" << endl;
01450 pg << "V "
01451 << ", 0x" << stringToHex("99.99")
01452 << ", 0x" << stringToHex("-105.0e-3")
01453 << ", 0x" << stringToHex("950.00")
01454 << ", 0x" << stringToHex("234.446")
01455 << ", 0x" << stringToHex("99.99 ")
01456 << ", 0x" << stringToHex("-105.0e-3 ")
01457 << ", 0x" << stringToHex("950.00 ")
01458 << ", 0x" << stringToHex("234.446 ")
01459 << ", 5, 2, 0, -2;" << endl;
01460 pg << "T;" << endl;
01461
01462 for (int i = 0; i < 9; i++) {
01463 pg << "CALL 'castA(L" << i << ",C" << i << ",C9, C10);" << endl;
01464 }
01465 for (int i = 0; i < 9; i++) {
01466 pg << "CALL 'castA(L" << (i + 9) << ",C" << i << ",C9, C11);" << endl;
01467 }
01468 for (int i = 0; i < 9; i++) {
01469 pg << "CALL 'castA(L" << (i + 18) << ",C" << i << ",C9, C12);" << endl;
01470 }
01471 refLocalOutput(pg, 9*3);
01472
01473 Calculator calc(0);
01474 try {
01475 calc.assemble(pg.str().c_str());
01476 } catch (FennelExcn& ex) {
01477 BOOST_MESSAGE("Assemble exception " << ex.getMessage());
01478 BOOST_MESSAGE(pg.str());
01479 BOOST_REQUIRE(0);
01480 }
01481
01482 TupleDataWithBuffer outTuple(calc.getOutputRegisterDescriptor());
01483 TupleDataWithBuffer inTuple(calc.getInputRegisterDescriptor());
01484 calc.bind(&inTuple, &outTuple);
01485 calc.exec();
01486 printOutput(outTuple, calc);
01487 deque::iterator iter = calc.mWarnings.begin();
01488
01489
01490 BOOST_CHECK_EQUAL(1, cmpTupNull(outTuple[0]));
01491 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[1], 9999));
01492 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[2], -11));
01493 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[3], 95000));
01494 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[4], 23445));
01495 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[5], 9999));
01496 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[6], -11));
01497 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[7], 95000));
01498 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[8], 23445));
01499
01500
01501 BOOST_CHECK_EQUAL(1, cmpTupNull(outTuple[9]));
01502 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[10], 100));
01503 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[11], 0));
01504 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[12], 950));
01505 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[13], 234));
01506 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[14], 100));
01507 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[15], 0));
01508 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[16], 950));
01509 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[17], 234));
01510
01511
01512 BOOST_CHECK_EQUAL(1, cmpTupNull(outTuple[18]));
01513 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[19], 1));
01514 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[20], 0));
01515 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[21], 10));
01516 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[22], 2));
01517 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[23], 1));
01518 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[24], 0));
01519 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[25], 10));
01520 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[26], 2));
01521
01522 BOOST_CHECK(iter == calc.mWarnings.end());
01523 }
01524
01525 void CalcExtCastTest::testCalcExtCastCharToDecimal()
01526 {
01527
01528
01529
01530
01531
01532 ostringstream pg(""), outloc("");
01533 outloc << "s8, s8, s8, s8, s8, s8, s8, s8, s8, "
01534 << "s8, s8, s8, s8, s8, s8, s8, s8, s8, "
01535 << "s8, s8, s8, s8, s8, s8, s8, s8, s8;"
01536 << endl;
01537 pg << "O " << outloc.str();
01538 pg << "L " << outloc.str();
01539 pg << "C c,1, c,5, c,7, c,4, c,20, c,10, c,10, c,10, c,32, "
01540 << " s4, s4, s4, s4;" << endl;
01541 pg << "V "
01542 << ", 0x" << stringToHex(".8987")
01543 << ", 0x" << stringToHex("-0005.2")
01544 << ", 0x" << stringToHex("+980")
01545 << ", 0x" << stringToHex("0.000000000000355e14")
01546 << ", 0x" << stringToHex(".8987 ")
01547 << ", 0x" << stringToHex("-0005.2 ")
01548 << ", 0x" << stringToHex("+980 ")
01549 << ", 0x" << stringToHex("0.000000000000355e14 ")
01550 << ", 5, 2, 0, -2;" << endl;
01551 pg << "T;" << endl;
01552
01553 for (int i = 0; i < 9; i++) {
01554 pg << "CALL 'castA(L" << i << ",C" << i << ",C9, C10);" << endl;
01555 }
01556 for (int i = 0; i < 9; i++) {
01557 pg << "CALL 'castA(L" << (i + 9) << ",C" << i << ",C9, C11);" << endl;
01558 }
01559 for (int i = 0; i < 9; i++) {
01560 pg << "CALL 'castA(L" << (i + 18) << ",C" << i << ",C9, C12);" << endl;
01561 }
01562 refLocalOutput(pg, 9*3);
01563
01564 Calculator calc(0);
01565 try {
01566 calc.assemble(pg.str().c_str());
01567 } catch (FennelExcn& ex) {
01568 BOOST_MESSAGE("Assemble exception " << ex.getMessage());
01569 BOOST_MESSAGE(pg.str());
01570 BOOST_REQUIRE(0);
01571 }
01572
01573 TupleDataWithBuffer outTuple(calc.getOutputRegisterDescriptor());
01574 TupleDataWithBuffer inTuple(calc.getInputRegisterDescriptor());
01575 calc.bind(&inTuple, &outTuple);
01576 calc.exec();
01577 printOutput(outTuple, calc);
01578 deque::iterator iter = calc.mWarnings.begin();
01579
01580
01581 BOOST_CHECK_EQUAL(1, cmpTupNull(outTuple[0]));
01582 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[1], 90));
01583 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[2], -520));
01584 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[3], 98000));
01585 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[4], 3550));
01586 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[5], 90));
01587 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[6], -520));
01588 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[7], 98000));
01589 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[8], 3550));
01590
01591
01592 BOOST_CHECK_EQUAL(1, cmpTupNull(outTuple[9]));
01593 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[10], 1));
01594 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[11], -5));
01595 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[12], 980));
01596 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[13], 36));
01597 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[14], 1));
01598 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[15], -5));
01599 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[16], 980));
01600 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[17], 36));
01601
01602
01603 BOOST_CHECK_EQUAL(1, cmpTupNull(outTuple[18]));
01604 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[19], 0));
01605 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[20], 0));
01606 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[21], 10));
01607 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[22], 0));
01608 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[23], 0));
01609 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[24], 0));
01610 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[25], 10));
01611 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[26], 0));
01612
01613 BOOST_CHECK(iter == calc.mWarnings.end());
01614 }
01615
01616 void CalcExtCastTest::testCalcExtCastStringToExactFails()
01617 {
01618
01619 ostringstream pg(""), outloc("");
01620 outloc << "s8, s8, s8, s8;" << endl;
01621 pg << "O " << outloc.str();
01622 pg << "L " << outloc.str();
01623 pg << "C vc,3, vc,3, c,3, c,3;" << endl;
01624 pg << "V 0x" << stringToHex("abc") << ", 0x" << stringToHex("12z")
01625 << ", 0x" << stringToHex("abc") << ", 0x" << stringToHex("12z")
01626 << ";" << endl;
01627 pg << "T;" << endl;
01628 pg << "CALL 'castA(L0, C0);" << endl;
01629 pg << "CALL 'castA(L1, C1);" << endl;
01630 pg << "CALL 'castA(L2, C0);" << endl;
01631 pg << "CALL 'castA(L3, C1);" << endl;
01632 refLocalOutput(pg, 4);
01633
01634 Calculator calc(0);
01635 try {
01636 calc.assemble(pg.str().c_str());
01637 } catch (FennelExcn& ex) {
01638 BOOST_MESSAGE("Assemble exception " << ex.getMessage());
01639 BOOST_MESSAGE(pg.str());
01640 BOOST_REQUIRE(0);
01641 }
01642
01643 TupleDataWithBuffer outTuple(calc.getOutputRegisterDescriptor());
01644 TupleDataWithBuffer inTuple(calc.getInputRegisterDescriptor());
01645 calc.bind(&inTuple, &outTuple);
01646 calc.exec();
01647 printOutput(outTuple, calc);
01648
01649
01650 deque::iterator iter = calc.mWarnings.begin();
01651 for (int pc = 0; pc < 4; pc++, iter++) {
01652 BOOST_CHECK_EQUAL(iter->pc, pc);
01653 BOOST_CHECK_EQUAL(0, strcmp(iter->str, invalidCharErr));
01654 }
01655 BOOST_CHECK(iter == calc.mWarnings.end());
01656 }
01657
01658 void CalcExtCastTest::testCalcExtCastStringToDecimalFails()
01659 {
01660
01661
01662 ostringstream pg(""), outloc("");
01663 outloc << "s8, s8, s8, s8, s8, s8, s8, s8;" << endl;
01664 pg << "O " << outloc.str();
01665 pg << "L " << outloc.str();
01666 pg << "C vc,3, vc,9, vc,14, vc,7, c,3, c,9, c,14, c,7, "
01667 << " s4, s4;" << endl;
01668 pg << "V 0x" << stringToHex("12c")
01669 << ", 0x" << stringToHex("34.54.243")
01670 << ", 0x" << stringToHex("342.342e453.23")
01671 << ", 0x" << stringToHex("234e 23")
01672 << ", 0x" << stringToHex("12c")
01673 << ", 0x" << stringToHex("34.54.243")
01674 << ", 0x" << stringToHex("342.342e453.23")
01675 << ", 0x" << stringToHex("234e 23")
01676 << ", 5, 2;" << endl;
01677 pg << "T;" << endl;
01678
01679 for (int i = 0; i < 8; i++) {
01680 pg << "CALL 'castA(L" << i << ",C" << i << ",C8, C9);" << endl;
01681 }
01682 refLocalOutput(pg, 8);
01683
01684 Calculator calc(0);
01685 try {
01686 calc.assemble(pg.str().c_str());
01687 } catch (FennelExcn& ex) {
01688 BOOST_MESSAGE("Assemble exception " << ex.getMessage());
01689 BOOST_MESSAGE(pg.str());
01690 BOOST_REQUIRE(0);
01691 }
01692
01693 TupleDataWithBuffer outTuple(calc.getOutputRegisterDescriptor());
01694 TupleDataWithBuffer inTuple(calc.getInputRegisterDescriptor());
01695 calc.bind(&inTuple, &outTuple);
01696 calc.exec();
01697 printOutput(outTuple, calc);
01698
01699
01700 deque::iterator iter = calc.mWarnings.begin();
01701 for (int pc = 0; pc < 8; pc++, iter++) {
01702 BOOST_CHECK_EQUAL(iter->pc, pc);
01703 BOOST_CHECK_EQUAL(0, strcmp(iter->str, invalidCharErr));
01704 }
01705 BOOST_CHECK(iter == calc.mWarnings.end());
01706 }
01707
01708 void CalcExtCastTest::testCalcExtCastStringToDecimalMinMax()
01709 {
01710
01711
01712
01713
01714
01715
01716
01717
01718
01719
01720
01721
01722 ostringstream pg(""), outloc("");
01723 outloc << "s8, s8, s8, s8, s8, s8, s8, s8, s8, s8, s8, "
01724 << "s8, s8, s8, s8, s8, s8, s8, s8, s8, s8, s8;" << endl;
01725 pg << "O " << outloc.str();
01726 pg << "L " << outloc.str();
01727 pg << "C vc,30, vc,30, vc,30, vc,30, vc,30, "
01728 << " vc,30, vc,30, vc,30, vc,30, vc,30, vc,30, "
01729 << " s4, s4, s4, s4;" << endl;
01730 pg << "V 0x" << stringToHex(minInt64String())
01731 << ", 0x" << stringToHex(maxInt64String())
01732 << ", 0x" << stringToHex("9223372036854775808")
01733 << ", 0x" << stringToHex("9223372036854775807.12345")
01734 << ", 0x" << stringToHex("9223372036854775807.9")
01735 << ", 0x" << stringToHex("-9223372036854775809")
01736 << ", 0x" << stringToHex("-9223372036854775807.9")
01737 << ", 0x" << stringToHex("-9223372036854775808.9")
01738 << ", 0x" << stringToHex("9323415432153452535")
01739 << ", 0x" << stringToHex("9.78E+18")
01740 << ", 0x" << stringToHex("9.78E+20")
01741 << ", 19, 0, 9, -10;" << endl;
01742 pg << "T;" << endl;
01743
01744 for (int i = 0; i < 11; i++) {
01745 pg << "CALL 'castA(L" << i << ",C" << i << ",C11, C12);" << endl;
01746 }
01747 for (int i = 0; i < 11; i++) {
01748 pg << "CALL 'castA(L" << (i + 11) << ",C" << i << ",C13, C14);" << endl;
01749 }
01750 refLocalOutput(pg, 22);
01751
01752 Calculator calc(0);
01753 try {
01754 calc.assemble(pg.str().c_str());
01755 } catch (FennelExcn& ex) {
01756 cout << ex.getMessage();
01757 BOOST_MESSAGE("Assemble exception " << ex.getMessage());
01758 BOOST_MESSAGE(pg.str());
01759 BOOST_REQUIRE(0);
01760 }
01761
01762 TupleDataWithBuffer outTuple(calc.getOutputRegisterDescriptor());
01763 TupleDataWithBuffer inTuple(calc.getInputRegisterDescriptor());
01764 calc.bind(&inTuple, &outTuple);
01765 calc.exec();
01766 printOutput(outTuple, calc);
01767
01768
01769 deque::iterator iter = calc.mWarnings.begin();
01770
01771
01772
01773 BOOST_CHECK_EQUAL(
01774 0, cmpTupInt64(outTuple[0], std::numeric_limits::min()));
01775
01776
01777 BOOST_CHECK_EQUAL(
01778 0, cmpTupInt64(outTuple[1], std::numeric_limits::max()));
01779
01780
01781 BOOST_CHECK_EQUAL(iter->pc, 2);
01782 BOOST_CHECK_EQUAL(0, strcmp(iter->str, outOfRangeErr));
01783 iter++;
01784
01785
01786 BOOST_CHECK_EQUAL(
01787 0, cmpTupInt64(outTuple[3], std::numeric_limits::max()));
01788
01789
01790 BOOST_CHECK_EQUAL(iter->pc, 4);
01791 BOOST_CHECK_EQUAL(0, strcmp(iter->str, outOfRangeErr));
01792 iter++;
01793
01794
01795 BOOST_CHECK_EQUAL(iter->pc, 5);
01796 BOOST_CHECK_EQUAL(0, strcmp(iter->str, outOfRangeErr));
01797 iter++;
01798
01799
01800 BOOST_CHECK_EQUAL(
01801 0, cmpTupInt64(outTuple[6], std::numeric_limits::min()));
01802
01803
01804 BOOST_CHECK_EQUAL(iter->pc, 7);
01805 BOOST_CHECK_EQUAL(0, strcmp(iter->str, outOfRangeErr));
01806 iter++;
01807
01808
01809 BOOST_CHECK_EQUAL(iter->pc, 8);
01810 BOOST_CHECK_EQUAL(0, strcmp(iter->str, outOfRangeErr));
01811 iter++;
01812
01813
01814 BOOST_CHECK_EQUAL(iter->pc, 9);
01815 BOOST_CHECK_EQUAL(0, strcmp(iter->str, outOfRangeErr));
01816 iter++;
01817
01818
01819 BOOST_CHECK_EQUAL(iter->pc, 10);
01820 BOOST_CHECK_EQUAL(0, strcmp(iter->str, outOfRangeErr));
01821 iter++;
01822
01823
01824 int64_t factor = 1;
01825 for (int i = 0; i < 10; i++) {
01826 factor *= 10;
01827 }
01828 int64_t smax = std::numeric_limits::max()/factor + 1;
01829 int64_t smin = std::numeric_limits::min()/factor - 1;
01830
01831
01832 BOOST_CHECK_EQUAL(0, cmpTupInt64(outTuple[11], smin));
01833
01834
01835 BOOST_CHECK_EQUAL(0, cmpTupInt64(outTuple[12], smax));
01836
01837
01838 BOOST_CHECK_EQUAL(0, cmpTupInt64(outTuple[13], smax));
01839
01840
01841 BOOST_CHECK_EQUAL(0, cmpTupInt64(outTuple[14], smax));
01842
01843
01844 BOOST_CHECK_EQUAL(0, cmpTupInt64(outTuple[15], smax));
01845
01846
01847 BOOST_CHECK_EQUAL(0, cmpTupInt64(outTuple[16], smin));
01848
01849
01850 BOOST_CHECK_EQUAL(0, cmpTupInt64(outTuple[17], smin));
01851
01852
01853 BOOST_CHECK_EQUAL(0, cmpTupInt64(outTuple[18], smin));
01854
01855
01856 BOOST_CHECK_EQUAL(0, cmpTupInt64(outTuple[19], 932341543ll));
01857
01858
01859 BOOST_CHECK_EQUAL(0, cmpTupInt64(outTuple[20], 978000000ll));
01860
01861
01862 BOOST_CHECK_EQUAL(iter->pc, 21);
01863 BOOST_CHECK_EQUAL(0, strcmp(iter->str, outOfRangeErr));
01864 iter++;
01865
01866 BOOST_CHECK(iter == calc.mWarnings.end());
01867 }
01868
01869
01870 void CalcExtCastTest::testCalcExtCastStringToDecimalRange()
01871 {
01872
01873
01874 ostringstream pg(""), outloc("");
01875 outloc << "s8, s8, s8, s8, s8, s8;" << endl;
01876 pg << "O " << outloc.str();
01877 pg << "L " << outloc.str();
01878 pg << "C vc,30, vc,30, vc,30, vc,30, vc,30, vc,30, "
01879 << " s4, s4;" << endl;
01880 pg << "V 0x" << stringToHex("1000")
01881 << ", 0x" << stringToHex("999.999")
01882 << ", 0x" << stringToHex("999.991")
01883 << ", 0x" << stringToHex("9.99999e2")
01884 << ", 0x" << stringToHex("9.9999e2")
01885 << ", 0x" << stringToHex("99999999990000000000e-20")
01886 << ", 5, 2;" << endl;
01887 pg << "T;" << endl;
01888
01889 for (int i = 0; i < 6; i++) {
01890 pg << "CALL 'castA(L" << i << ",C" << i << ",C6, C7);" << endl;
01891 }
01892 refLocalOutput(pg, 6);
01893
01894 Calculator calc(0);
01895 try {
01896 calc.assemble(pg.str().c_str());
01897 } catch (FennelExcn& ex) {
01898 cout << ex.getMessage();
01899 BOOST_MESSAGE("Assemble exception " << ex.getMessage());
01900 BOOST_MESSAGE(pg.str());
01901 BOOST_REQUIRE(0);
01902 }
01903
01904 TupleDataWithBuffer outTuple(calc.getOutputRegisterDescriptor());
01905 TupleDataWithBuffer inTuple(calc.getInputRegisterDescriptor());
01906 calc.bind(&inTuple, &outTuple);
01907 calc.exec();
01908 printOutput(outTuple, calc);
01909
01910
01911 deque::iterator iter = calc.mWarnings.begin();
01912
01913
01914
01915 BOOST_CHECK_EQUAL(iter->pc, 0);
01916 BOOST_CHECK_EQUAL(0, strcmp(iter->str, outOfRangeErr));
01917 iter++;
01918
01919
01920 BOOST_CHECK_EQUAL(iter->pc, 1);
01921 BOOST_CHECK_EQUAL(0, strcmp(iter->str, outOfRangeErr));
01922 iter++;
01923
01924
01925 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[2], 99999));
01926
01927
01928 BOOST_CHECK_EQUAL(iter->pc, 3);
01929 BOOST_CHECK_EQUAL(0, strcmp(iter->str, outOfRangeErr));
01930 iter++;
01931
01932
01933 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[4], 99999));
01934
01935
01936 BOOST_CHECK_EQUAL(0, cmpTupInt(outTuple[5], 100));
01937 BOOST_CHECK(iter == calc.mWarnings.end());
01938 }
01939
01940
01941 void CalcExtCastTest::testCalcExtCastStringToApprox()
01942 {
01943
01944
01945 ostringstream pg(""), outloc("");
01946 outloc << "d, d, d, d, d, d, d, d, "
01947 << "d, d, d, d, d, d, d, d, "
01948 << "d, d, d, d, d, d, d, d;" << endl;
01949 pg << "O " << outloc.str();
01950 pg << "L " << outloc.str();
01951 pg << "C "
01952 << "vc,8, vc,8, vc,8, vc,8, vc,8, vc,8, vc,8, vc,8, "
01953 << "c,1, c,1, c,3, c,2, c,4, c,5, c,5, c,7, "
01954 << "c,16, c,16, c,16, c,16, c,16, c,16, c,16, c,16;" << endl;
01955 pg << "V ";
01956 for (int i = 0; i < 2; i++) {
01957 pg << ","
01958 << "0x" << stringToHex("0") << ","
01959 << "0x" << stringToHex("0.0") << ","
01960 << "0x" << stringToHex(".0") << ","
01961 << "0x" << stringToHex("1.98") << ","
01962 << "0x" << stringToHex("-1.98") << ","
01963 << "0x" << stringToHex("0.001") << ","
01964 << "0x" << stringToHex("0.00100") << ",";
01965 }
01966
01967 pg << ","
01968 << "0x" << stringToHex("0 ") << ","
01969 << "0x" << stringToHex("0.0 ") << ","
01970 << "0x" << stringToHex(".0 ") << ","
01971 << "0x" << stringToHex("1.98 ") << ","
01972 << "0x" << stringToHex("-1.98 ") << ","
01973 << "0x" << stringToHex("0.001 ") << ","
01974 << "0x" << stringToHex("0.00100 ") << ";" << endl;
01975 pg << "T;" << endl;
01976 for (int i = 0; i < 8; i++) {
01977 pg << "CALL 'castA(L" << i << ", C" << i << ");" << endl;
01978 }
01979 for (int i = 0; i < 8; i++) {
01980 pg << "CALL 'castA(L" << (i + 8) << ", C" << i << ");" << endl;
01981 }
01982 for (int i = 0; i < 8; i++) {
01983 pg << "CALL 'castA(L" << (i + 16) << ", C" << i << ");" << endl;
01984 }
01985 refLocalOutput(pg, 24);
01986
01987 Calculator calc(0);
01988 try {
01989 calc.assemble(pg.str().c_str());
01990 } catch (FennelExcn& ex) {
01991 BOOST_MESSAGE("Assemble exception " << ex.getMessage());
01992 BOOST_MESSAGE(pg.str());
01993 BOOST_REQUIRE(0);
01994 }
01995
01996 TupleDataWithBuffer outTuple(calc.getOutputRegisterDescriptor());
01997 TupleDataWithBuffer inTuple(calc.getInputRegisterDescriptor());
01998 calc.bind(&inTuple, &outTuple);
01999 calc.exec();
02000 printOutput(outTuple, calc);
02001
02002 deque::iterator iter = calc.mWarnings.begin();
02003
02004 for (int pass = 0, i = 0; pass < 3; pass++) {
02005 BOOST_CHECK(cmpTupNull(outTuple[i++]));
02006 BOOST_CHECK_EQUAL(0, cmpTupDouble(outTuple[i++], 0));
02007 BOOST_CHECK_EQUAL(0, cmpTupDouble(outTuple[i++], 0));
02008 BOOST_CHECK_EQUAL(0, cmpTupDouble(outTuple[i++], 0));
02009 BOOST_CHECK_EQUAL(0, cmpTupDouble(outTuple[i++], 1.98));
02010 BOOST_CHECK_EQUAL(0, cmpTupDouble(outTuple[i++], -1.98));
02011 BOOST_CHECK_EQUAL(0, cmpTupDouble(outTuple[i++], 0.001));
02012 BOOST_CHECK_EQUAL(0, cmpTupDouble(outTuple[i++], 0.001));
02013 }
02014 BOOST_CHECK(iter == calc.mWarnings.end());
02015 }
02016
02017 void CalcExtCastTest::testCalcExtCastApproxToString()
02018 {
02019
02020
02021 ostringstream pg(""), outloc("");
02022 outloc << "vc,16, vc,16, vc,16, vc,16, vc,16, vc,16, "
02023 << "c,16, c,16, c,16, c,16, c,16, c,16;" << endl;
02024 pg << "O " << outloc.str();
02025 pg << "L " << outloc.str();
02026 pg << "C d,d,d,d,d,d;" << endl;
02027 pg << "V , 0.0, 1.98, -1.98, 0.001, -0.001;" << endl;
02028 pg << "T;" << endl;
02029 for (int i = 0; i < 6; i++) {
02030 pg << "CALL 'castA(L" << i << ", C" << i << ");" << endl;
02031 }
02032 for (int i = 0; i < 6; i++) {
02033 pg << "CALL 'castA(L" << (i + 6) << ", C" << i << ");" << endl;
02034 }
02035 refLocalOutput(pg, 12);
02036
02037
02038 Calculator calc(0);
02039 try {
02040 calc.assemble(pg.str().c_str());
02041 } catch (FennelExcn& ex) {
02042 BOOST_MESSAGE("Assemble exception " << ex.getMessage());
02043 BOOST_MESSAGE(pg.str());
02044 BOOST_REQUIRE(0);
02045 }
02046
02047 TupleDataWithBuffer outTuple(calc.getOutputRegisterDescriptor());
02048 TupleDataWithBuffer inTuple(calc.getInputRegisterDescriptor());
02049 calc.bind(&inTuple, &outTuple);
02050 calc.exec();
02051 printOutput(outTuple, calc);
02052
02053 deque::iterator iter = calc.mWarnings.begin();
02054
02055 int i = 0;
02056
02057
02058 BOOST_CHECK(cmpTupNull(outTuple[i++]));
02059 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[i++], "0E0"));
02060 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[i++], "1.98E0"));
02061 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[i++], "-1.98E0"));
02062 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[i++], "1E-3"));
02063 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[i++], "-1E-3"));
02064
02065 BOOST_CHECK(cmpTupNull(outTuple[i++]));
02066 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[i++], "0E0 "));
02067 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[i++], "1.98E0 "));
02068 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[i++], "-1.98E0 "));
02069 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[i++], "1E-3 "));
02070 BOOST_CHECK_EQUAL(0, cmpTupStr(outTuple[i++], "-1E-3 "));
02071 BOOST_CHECK(iter == calc.mWarnings.end());
02072 }
02073
02074 FENNEL_UNIT_TEST_SUITE(CalcExtCastTest);
02075
02076