开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
NDBT_Test.cpp
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：28k
源码类别：

MySQL数据库

开发平台：

Visual C++

NDBT_Test.cpp：源码内容
  1. /* Copyright (C) 2003 MySQL AB
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. #include <ndb_global.h>
  19. #include "NDBT.hpp"
  20. #include "NDBT_Test.hpp"
  22. #include <PortDefs.h>
  24. #include <getarg.h>
  25. #include <time.h>
  27. // No verbose outxput
  29. NDBT_Context::NDBT_Context(){
  30.   tab = NULL;
  31.   suite = NULL;
  32.   testcase = NULL;
  33.   ndb = NULL;
  34.   records = 1;
  35.   loops = 1;
  36.   stopped = false;
  37.   remote_mgm ="";
  38.   propertyMutexPtr = NdbMutex_Create();
  39.   propertyCondPtr = NdbCondition_Create();
  40. }
  42.  
  43. char * NDBT_Context::getRemoteMgm() const {
  44.   return remote_mgm;
  45. } 
  46. void NDBT_Context::setRemoteMgm(char * mgm) {
  47.   remote_mgm = strdup(mgm);
  48. } 
  51. NDBT_Context::~NDBT_Context(){
  52.   NdbCondition_Destroy(propertyCondPtr);
  53.   NdbMutex_Destroy(propertyMutexPtr);
  54. }
  56. const NdbDictionary::Table* NDBT_Context::getTab(){
  57.   assert(tab != NULL);
  58.   return tab;
  59. }
  61. NDBT_TestSuite* NDBT_Context::getSuite(){ 
  62.   assert(suite != NULL);
  63.   return suite;
  64. }
  66. NDBT_TestCase* NDBT_Context::getCase(){ 
  67.   assert(testcase != NULL);
  68.   return testcase;
  69. }
  71. int NDBT_Context::getNumRecords() const{ 
  72.   return records;   
  73. }
  75. int NDBT_Context::getNumLoops() const{ 
  76.   return loops;
  77. }
  79. int NDBT_Context::getNoOfRunningSteps() const {
  80.   return testcase->getNoOfRunningSteps();
  81.   
  82. }
  83. int NDBT_Context::getNoOfCompletedSteps() const {
  84.   return testcase->getNoOfCompletedSteps();
  85. }
  88. Uint32 NDBT_Context::getProperty(const char* _name, Uint32 _default){ 
  89.   Uint32 val;
  90.   NdbMutex_Lock(propertyMutexPtr);
  91.   if(!props.get(_name, &val))
  92.     val = _default;
  93.   NdbMutex_Unlock(propertyMutexPtr);
  94.   return val;
  95. }
  97. bool NDBT_Context::getPropertyWait(const char* _name, Uint32 _waitVal){ 
  98.   bool result;
  99.   NdbMutex_Lock(propertyMutexPtr);
  100.   Uint32 val =! _waitVal;
  101.   
  102.   while((!props.get(_name, &val) || (props.get(_name, &val) && val != _waitVal)) &&  
  103. !stopped)
  104.     NdbCondition_Wait(propertyCondPtr,
  105.       propertyMutexPtr);
  106.   result = (val == _waitVal);
  107.   NdbMutex_Unlock(propertyMutexPtr);
  108.   return stopped;
  109. }
  111. const char* NDBT_Context::getProperty(const char* _name, const char* _default){ 
  112.   const char* val;
  113.   NdbMutex_Lock(propertyMutexPtr);
  114.   if(!props.get(_name, &val))
  115.     val = _default;
  116.   NdbMutex_Unlock(propertyMutexPtr);
  117.   return val;
  118. }
  120. const char* NDBT_Context::getPropertyWait(const char* _name, const char* _waitVal){ 
  121.   const char* val;
  122.   NdbMutex_Lock(propertyMutexPtr);
  123.   while(!props.get(_name, &val) && (strcmp(val, _waitVal)==0))
  124.     NdbCondition_Wait(propertyCondPtr,
  125.       propertyMutexPtr);
  127.   NdbMutex_Unlock(propertyMutexPtr);
  128.   return val;
  129. }
  131. void  NDBT_Context::setProperty(const char* _name, Uint32 _val){ 
  132.   NdbMutex_Lock(propertyMutexPtr);
  133.   const bool b = props.put(_name, _val, true);
  134.   assert(b == true);
  135.   NdbMutex_Unlock(propertyMutexPtr);
  136. }
  137. void
  138. NDBT_Context::decProperty(const char * name){
  139.   NdbMutex_Lock(propertyMutexPtr);
  140.   Uint32 val = 0;
  141.   if(props.get(name, &val)){
  142.     assert(val > 0);
  143.     props.put(name, (val - 1), true);
  144.   }
  145.   NdbCondition_Broadcast(propertyCondPtr);
  146.   NdbMutex_Unlock(propertyMutexPtr);
  147. }
  148. void
  149. NDBT_Context::incProperty(const char * name){
  150.   NdbMutex_Lock(propertyMutexPtr);
  151.   Uint32 val = 0;
  152.   props.get(name, &val);
  153.   props.put(name, (val + 1), true);
  154.   NdbCondition_Broadcast(propertyCondPtr);
  155.   NdbMutex_Unlock(propertyMutexPtr);
  156. }
  158. void  NDBT_Context::setProperty(const char* _name, const char* _val){ 
  159.   NdbMutex_Lock(propertyMutexPtr);
  160.   const bool b = props.put(_name, _val);
  161.   assert(b == true);
  162.   NdbMutex_Unlock(propertyMutexPtr);
  163. }
  165. void NDBT_Context::stopTest(){ 
  166.   NdbMutex_Lock(propertyMutexPtr);
  167.   g_info << "|- stopTest called" << endl;
  168.   stopped = true;
  169.   NdbCondition_Broadcast(propertyCondPtr);
  170.   NdbMutex_Unlock(propertyMutexPtr);
  171. }
  173. bool NDBT_Context::isTestStopped(){ 
  174.   NdbMutex_Lock(propertyMutexPtr);
  175.   bool val = stopped;
  176.   NdbMutex_Unlock(propertyMutexPtr);
  177.   return val;
  178. }
  180. void NDBT_Context::wait(){
  181.   NdbMutex_Lock(propertyMutexPtr);
  182.   NdbCondition_Wait(propertyCondPtr,
  183.     propertyMutexPtr);
  184.   NdbMutex_Unlock(propertyMutexPtr);
  185. }
  187. void NDBT_Context::wait_timeout(int msec){
  188.   NdbMutex_Lock(propertyMutexPtr);
  189.   NdbCondition_WaitTimeout(propertyCondPtr,
  190.    propertyMutexPtr,
  191.    msec);
  192.   NdbMutex_Unlock(propertyMutexPtr);
  193. }
  195. void NDBT_Context::broadcast(){
  196.   NdbMutex_Lock(propertyMutexPtr);
  197.   NdbCondition_Broadcast(propertyCondPtr);
  198.   NdbMutex_Unlock(propertyMutexPtr);
  199. }
  201. Uint32 NDBT_Context::getDbProperty(const char*){ 
  202.   abort();
  203.   return 0;
  204. }
  206. bool NDBT_Context::setDbProperty(const char*, Uint32){ 
  207.   abort();
  208.   return true;
  209. }
  211. void NDBT_Context::setTab(const NdbDictionary::Table* ptab){ 
  212.   assert(ptab != NULL);
  213.   tab = ptab;
  214. }
  216. void NDBT_Context::setSuite(NDBT_TestSuite* psuite){ 
  217.   assert(psuite != NULL);
  218.   suite = psuite;
  219. }
  221. void NDBT_Context::setCase(NDBT_TestCase* pcase){ 
  222.   assert(pcase != NULL);
  223.   testcase = pcase;
  224. }
  226. void NDBT_Context::setNumRecords(int _records){ 
  227.   records = _records;
  228.   
  229. }
  231. void NDBT_Context::setNumLoops(int _loops){ 
  232.   loops = _loops;
  233. }
  235. NDBT_Step::NDBT_Step(NDBT_TestCase* ptest, const char* pname, 
  236.      NDBT_TESTFUNC* pfunc): name(pname){
  237.   assert(pfunc != NULL);
  238.   func = pfunc;
  239.   testcase = ptest;
  240.   step_no = -1;
  241. }
  243. int NDBT_Step::execute(NDBT_Context* ctx) {
  244.   assert(ctx != NULL);
  246.   int result;  
  248.   g_info << "  |- " << name << " started [" << ctx->suite->getDate() << "]" 
  249.  << endl;
  250.   
  251.   result = setUp();
  252.   if (result != NDBT_OK){
  253.     return result;
  254.   }
  256.   result = func(ctx, this);
  258.   if (result != NDBT_OK) {
  259.     g_err << "  |- " << name << " FAILED [" << ctx->suite->getDate() 
  260.    << "]" << endl;
  261.   }  
  262.    else {
  263.     g_info << "  |- " << name << " PASSED [" << ctx->suite->getDate() << "]"
  264.    << endl;
  265.   }
  266.   
  267.   tearDown();
  268.   
  269.   return result;
  270. }
  272. void NDBT_Step::setContext(NDBT_Context* pctx){
  273.   assert(pctx != NULL);
  274.   m_ctx = pctx;
  275. }
  277. NDBT_Context* NDBT_Step::getContext(){
  278.   assert(m_ctx != NULL);
  279.   return m_ctx;
  280. }
  282. NDBT_NdbApiStep::NDBT_NdbApiStep(NDBT_TestCase* ptest, 
  283.    const char* pname, 
  284.    NDBT_TESTFUNC* pfunc)
  285.   : NDBT_Step(ptest, pname, pfunc),
  286.     ndb(NULL) {
  287. }
  290. int
  291. NDBT_NdbApiStep::setUp(){
  292.   ndb = new Ndb( "TEST_DB" );
  293.   ndb->init(1024);
  295.   int result = ndb->waitUntilReady(300); // 5 minutes
  296.   if (result != 0){
  297.     g_err << name << ": Ndb was not ready" << endl;
  298.     return NDBT_FAILED;
  299.   }
  300.   return NDBT_OK;
  301. }
  303. void 
  304. NDBT_NdbApiStep::tearDown(){
  305.   delete ndb;
  306.   ndb = NULL;
  307. }
  309. Ndb* NDBT_NdbApiStep::getNdb(){ 
  310.   assert(ndb != NULL);
  311.   return ndb;
  312. }
  315. NDBT_ParallelStep::NDBT_ParallelStep(NDBT_TestCase* ptest, 
  316.      const char* pname, 
  317.      NDBT_TESTFUNC* pfunc)
  318.   : NDBT_NdbApiStep(ptest, pname, pfunc) {
  319. }
  320. NDBT_Verifier::NDBT_Verifier(NDBT_TestCase* ptest, 
  321.      const char* pname, 
  322.      NDBT_TESTFUNC* pfunc)
  323.   : NDBT_NdbApiStep(ptest, pname, pfunc) {
  324. }
  325. NDBT_Initializer::NDBT_Initializer(NDBT_TestCase* ptest, 
  326.    const char* pname, 
  327.    NDBT_TESTFUNC* pfunc)
  328.   : NDBT_NdbApiStep(ptest, pname, pfunc) {
  329. }
  330. NDBT_Finalizer::NDBT_Finalizer(NDBT_TestCase* ptest, 
  331.        const char* pname, 
  332.        NDBT_TESTFUNC* pfunc)
  333.   : NDBT_NdbApiStep(ptest, pname, pfunc) {
  334. }
  336. NDBT_TestCase::NDBT_TestCase(NDBT_TestSuite* psuite, 
  337.      const char* pname, 
  338.      const char* pcomment) : 
  339.   name(strdup(pname)) ,
  340.   comment(strdup(pcomment)),
  341.   suite(psuite)
  342. {
  343.   _name.assign(pname);
  344.   _comment.assign(pcomment);
  345.   name= _name.c_str();
  346.   comment= _comment.c_str();
  347.   assert(suite != NULL);
  348. }
  350. NDBT_TestCaseImpl1::NDBT_TestCaseImpl1(NDBT_TestSuite* psuite, 
  351.        const char* pname, 
  352.        const char* pcomment) : 
  353.   NDBT_TestCase(psuite, pname, pcomment){
  355.   numStepsOk = 0;
  356.   numStepsFail = 0;
  357.   numStepsCompleted = 0;
  358.   waitThreadsMutexPtr = NdbMutex_Create();
  359.   waitThreadsCondPtr = NdbCondition_Create();
  360. }
  362. NDBT_TestCaseImpl1::~NDBT_TestCaseImpl1(){
  363.   NdbCondition_Destroy(waitThreadsCondPtr);
  364.   NdbMutex_Destroy(waitThreadsMutexPtr);
  365.   size_t i;
  366.   for(i = 0; i < initializers.size();  i++)
  367.     delete initializers[i];
  368.   initializers.clear();
  369.   for(i = 0; i < verifiers.size();  i++)
  370.     delete verifiers[i];
  371.   verifiers.clear();
  372.   for(i = 0; i < finalizers.size();  i++)
  373.     delete finalizers[i];
  374.   finalizers.clear();
  375.   for(i = 0; i < steps.size();  i++)
  376.     delete steps[i];
  377.   steps.clear();
  378.   results.clear();
  379.   for(i = 0; i < testTables.size();  i++)
  380.     delete testTables[i];
  381.   testTables.clear();
  382.   for(i = 0; i < testResults.size();  i++)
  383.     delete testResults[i];
  384.   testResults.clear();
  386. }
  388. int NDBT_TestCaseImpl1::addStep(NDBT_Step* pStep){
  389.   assert(pStep != NULL);
  390.   steps.push_back(pStep);
  391.   pStep->setStepNo(steps.size());
  392.   int res = NORESULT;
  393.   results.push_back(res);
  394.   return 0;
  395. }
  397. int NDBT_TestCaseImpl1::addVerifier(NDBT_Verifier* pVerifier){
  398.   assert(pVerifier != NULL);
  399.   verifiers.push_back(pVerifier);
  400.   return 0;
  401. }
  403. int NDBT_TestCaseImpl1::addInitializer(NDBT_Initializer* pInitializer){
  404.   assert(pInitializer != NULL);
  405.   initializers.push_back(pInitializer);
  406.   return 0;
  407. }
  409. int NDBT_TestCaseImpl1::addFinalizer(NDBT_Finalizer* pFinalizer){
  410.   assert(pFinalizer != NULL);
  411.   finalizers.push_back(pFinalizer);
  412.   return 0;
  413. }
  415. void NDBT_TestCaseImpl1::addTable(const char* tableName, bool isVerify) {
  416.   assert(tableName != NULL);
  417.   const NdbDictionary::Table* pTable = NDBT_Tables::getTable(tableName);
  418.   assert(pTable != NULL);
  419.   testTables.push_back(pTable);
  420.   isVerifyTables = isVerify;
  421. }
  423. bool NDBT_TestCaseImpl1::tableExists(NdbDictionary::Table* aTable) {
  424.   for (unsigned i = 0; i < testTables.size(); i++) {
  425.     if (strcasecmp(testTables[i]->getName(), aTable->getName()) == 0) {
  426.       return true;
  427.     }
  428.   }
  429.   return false;
  430. }
  432. bool NDBT_TestCaseImpl1::isVerify(const NdbDictionary::Table* aTable) {
  433.   if (testTables.size() > 0) {
  434.     int found = false;
  435.     // OK, we either exclude or include this table in the actual test
  436.     for (unsigned i = 0; i < testTables.size(); i++) {
  437.       if (strcasecmp(testTables[i]->getName(), aTable->getName()) == 0) {
  438. // Found one!
  439. if (isVerifyTables) {
  440.   // Found one to test
  441.   found = true;
  442. } else {
  443.   // Skip this one!
  444.   found = false;
  445. }
  446.       }
  447.     } // for
  448.     return found;
  449.   } else {
  450.     // No included or excluded test tables, i.e., all tables should be      
  451.     // tested
  452.     return true;
  453.   }
  454.   return true;
  455. }
  457. void  NDBT_TestCase::setProperty(const char* _name, Uint32 _val){ 
  458.   const bool b = props.put(_name, _val);
  459.   assert(b == true);
  460. }
  462. void  NDBT_TestCase::setProperty(const char* _name, const char* _val){ 
  463.   const bool b = props.put(_name, _val);
  464.   assert(b == true);
  465. }
  468. void *
  469. runStep(void * s){
  470.   assert(s != NULL);
  471.   NDBT_Step* pStep = (NDBT_Step*)s;
  472.   NDBT_Context* ctx = pStep->getContext();
  473.   assert(ctx != NULL);
  474.    // Execute function
  475.   int res = pStep->execute(ctx);
  476.   if(res != NDBT_OK){
  477.     ctx->stopTest();
  478.   }
  479.   // Report 
  480.   NDBT_TestCaseImpl1* pCase = (NDBT_TestCaseImpl1*)ctx->getCase();
  481.   assert(pCase != NULL);
  482.   pCase->reportStepResult(pStep, res);
  483.   return NULL;
  484. }
  486. extern "C" 
  487. void *
  488. runStep_C(void * s)
  489. {
  490.   runStep(s);
  491.   return NULL;
  492. }
  495. void NDBT_TestCaseImpl1::startStepInThread(int stepNo, NDBT_Context* ctx){  
  496.   NDBT_Step* pStep = steps[stepNo];
  497.   pStep->setContext(ctx);
  498.   char buf[16];
  499.   BaseString::snprintf(buf, sizeof(buf), "step_%d", stepNo);
  500.   NdbThread* pThread = NdbThread_Create(runStep_C,
  501. (void**)pStep,
  502. 65535,
  503. buf, 
  504. NDB_THREAD_PRIO_LOW);
  505.   threads.push_back(pThread);
  506. }
  508. void NDBT_TestCaseImpl1::waitSteps(){
  509.   NdbMutex_Lock(waitThreadsMutexPtr);
  510.   while(numStepsCompleted != steps.size())
  511.     NdbCondition_Wait(waitThreadsCondPtr,
  512.      waitThreadsMutexPtr);
  514.   unsigned completedSteps = 0;  
  515.   unsigned i;
  516.   for(i=0; i<steps.size(); i++){
  517.     if (results[i] != NORESULT){
  518.       completedSteps++;
  519.       if (results[i] == NDBT_OK)
  520. numStepsOk++;
  521.       else
  522. numStepsFail++;
  523.     }       
  524.   }
  525.   assert(completedSteps == steps.size());
  526.   assert(completedSteps == numStepsCompleted);
  527.   
  528.   NdbMutex_Unlock(waitThreadsMutexPtr);
  529.   void *status;
  530.   for(i=0; i<steps.size();i++){
  531.     NdbThread_WaitFor(threads[i], &status);
  532.     NdbThread_Destroy(&threads[i]);   
  533.   }
  534.   threads.clear();
  535. }
  538. int
  539. NDBT_TestCaseImpl1::getNoOfRunningSteps() const {
  540.   return steps.size() - getNoOfCompletedSteps();
  541. }
  543. int 
  544. NDBT_TestCaseImpl1::getNoOfCompletedSteps() const {
  545.   return numStepsCompleted;
  546. }
  548. void NDBT_TestCaseImpl1::reportStepResult(const NDBT_Step* pStep, int result){
  549.   NdbMutex_Lock(waitThreadsMutexPtr);
  550.   assert(pStep != NULL);
  551.   for (unsigned i = 0; i < steps.size(); i++){
  552.     if(steps[i] != NULL && steps[i] == pStep){
  553.       results[i] = result;
  554.       numStepsCompleted++;
  555.     }
  556.   }
  557.   if(numStepsCompleted == steps.size()){
  558.     NdbCondition_Signal(waitThreadsCondPtr);
  559.   }
  560.   NdbMutex_Unlock(waitThreadsMutexPtr);
  561. }
  564. int NDBT_TestCase::execute(NDBT_Context* ctx){
  565.   int res;
  567.   ndbout << "- " << name << " started [" << ctx->suite->getDate()
  568.  << "]" << endl;
  570.   ctx->setCase(this);
  572.   // Copy test case properties to ctx
  573.   Properties::Iterator it(&props);
  574.   for(const char * key = it.first(); key != 0; key = it.next()){
  576.     PropertiesType pt;
  577.     const bool b = props.getTypeOf(key, &pt);
  578.     assert(b == true);
  579.     switch(pt){
  580.     case PropertiesType_Uint32:{
  581.       Uint32 val;
  582.       props.get(key, &val);
  583.       ctx->setProperty(key, val);
  584.       break;
  585.     }
  586.     case PropertiesType_char:{
  587.       const char * val;
  588.       props.get(key, &val);
  589.       ctx->setProperty(key, val);
  590.       break;
  591.     }
  592.     default:
  593.       abort();
  594.     }
  595.   }
  597.   // start timer so that we get a time even if
  598.   // test case consist only of initializer
  599.   startTimer(ctx);
  600.   
  601.   if ((res = runInit(ctx)) == NDBT_OK){
  602.     // If initialiser is ok, run steps
  603.     
  604.     res = runSteps(ctx);
  605.     if (res == NDBT_OK){
  606.       // If steps is ok, run verifier
  607.       res = runVerifier(ctx);
  608.     } 
  609.     
  610.   }
  612.   stopTimer(ctx);
  613.   printTimer(ctx);
  615.   // Always run finalizer to clean up db
  616.   runFinal(ctx); 
  618.   if (res == NDBT_OK) {
  619.     ndbout << "- " << name << " PASSED [" << ctx->suite->getDate() << "]" 
  620.    << endl;
  621.   }
  622.   else {
  623.     ndbout << "- " << name << " FAILED [" << ctx->suite->getDate() << "]" 
  624.    << endl;
  625.   }
  626.   return res;
  627. }
  630. void NDBT_TestCase::startTimer(NDBT_Context* ctx){
  631.   timer.doStart();
  632. }
  634. void NDBT_TestCase::stopTimer(NDBT_Context* ctx){
  635.   timer.doStop();
  636. }
  638. void NDBT_TestCase::printTimer(NDBT_Context* ctx){
  639.   if (suite->timerIsOn()){
  640.     g_info << endl; 
  641.     timer.printTestTimer(ctx->getNumLoops(), ctx->getNumRecords());
  642.   }
  643. }
  645. int NDBT_TestCaseImpl1::runInit(NDBT_Context* ctx){
  646.   int res = NDBT_OK;
  647.   for (unsigned i = 0; i < initializers.size(); i++){
  648.     initializers[i]->setContext(ctx);
  649.     res = initializers[i]->execute(ctx);
  650.     if (res != NDBT_OK)
  651.       break;
  652.   }
  653.   return res;
  654. }
  656. int NDBT_TestCaseImpl1::runSteps(NDBT_Context* ctx){
  657.   int res = NDBT_OK;
  659.   // Reset variables
  660.   numStepsOk = 0;
  661.   numStepsFail = 0;
  662.   numStepsCompleted = 0;
  663.   unsigned i;
  664.   for (i = 0; i < steps.size(); i++)
  665.     startStepInThread(i, ctx);
  666.   waitSteps();
  668.   for(i = 0; i < steps.size(); i++)
  669.     if (results[i] != NDBT_OK)
  670.       res = NDBT_FAILED;
  671.   return res;
  672. }
  674. int NDBT_TestCaseImpl1::runVerifier(NDBT_Context* ctx){
  675.   int res = NDBT_OK;
  676.   for (unsigned i = 0; i < verifiers.size(); i++){
  677.     verifiers[i]->setContext(ctx);
  678.     res = verifiers[i]->execute(ctx);
  679.     if (res != NDBT_OK)
  680.       break;
  681.   }
  682.   return res;
  683. }
  685. int NDBT_TestCaseImpl1::runFinal(NDBT_Context* ctx){
  686.   int res = NDBT_OK;
  687.   for (unsigned i = 0; i < finalizers.size(); i++){
  688.     finalizers[i]->setContext(ctx);
  689.     res = finalizers[i]->execute(ctx);
  690.     if (res != NDBT_OK)
  691.       break;
  692.   }
  693.   return res;
  694. }
  697. void NDBT_TestCaseImpl1::saveTestResult(const NdbDictionary::Table* ptab, 
  698. int result){
  699.   testResults.push_back(new NDBT_TestCaseResult(ptab->getName(), 
  700. result,
  701. timer.elapsedTime()));
  702. }
  704. void NDBT_TestCaseImpl1::printTestResult(){
  706.   char buf[255];
  707.   ndbout << name<<endl;
  709.   for (unsigned i = 0; i < testResults.size(); i++){
  710.     NDBT_TestCaseResult* tcr = testResults[i];
  711.     const char* res;
  712.     if (tcr->getResult() == NDBT_OK)
  713.       res = "OK";
  714.     else if (tcr->getResult() == NDBT_FAILED)
  715.       res = "FAIL";
  716.     else if (tcr->getResult() == FAILED_TO_CREATE)
  717.       res = "FAILED TO CREATE TABLE";
  718.     else if (tcr->getResult() == FAILED_TO_DISCOVER)
  719.       res = "FAILED TO DISCOVER TABLE";
  720.     BaseString::snprintf(buf, 255," %-10s %-5s %-20s", tcr->getName(), res, tcr->getTimeStr());
  721.     ndbout << buf<<endl;    
  722.   }
  723. }
  729. NDBT_TestSuite::NDBT_TestSuite(const char* pname):name(pname){
  730.    numTestsOk = 0;
  731.    numTestsFail = 0;
  732.    numTestsExecuted = 0;
  733.    records = 0;
  734.    loops = 0;
  735.    createTable = true;
  736. }
  739. NDBT_TestSuite::~NDBT_TestSuite(){
  740.   for(unsigned i=0; i<tests.size(); i++){
  741.     delete tests[i];
  742.   }
  743.   tests.clear();
  744. }
  746. void NDBT_TestSuite::setCreateTable(bool _flag){
  747.   createTable = _flag;
  748. }
  750. bool NDBT_TestSuite::timerIsOn(){
  751.   return (timer != 0);
  752. }
  754. int NDBT_TestSuite::addTest(NDBT_TestCase* pTest){
  755.   assert(pTest != NULL);
  756.   tests.push_back(pTest);
  757.   return 0;
  758. }
  760. int NDBT_TestSuite::executeAll(const char* _testname){
  762.   if(tests.size() == 0)
  763.     return NDBT_FAILED;
  764.   Ndb ndb("TEST_DB");
  765.   ndb.init(1024);
  767.   int result = ndb.waitUntilReady(300); // 5 minutes
  768.   if (result != 0){
  769.     g_err << name <<": Ndb was not ready" << endl;
  770.     return NDBT_FAILED;
  771.   }
  773.   ndbout << name << " started [" << getDate() << "]" << endl;
  775.   testSuiteTimer.doStart();
  777.   for (int t=0; t < NDBT_Tables::getNumTables(); t++){
  778.     const NdbDictionary::Table* ptab = NDBT_Tables::getTable(t);
  779.     ndbout << "|- " << ptab->getName() << endl;
  780.     execute(&ndb, ptab, _testname);
  781.   }
  782.   testSuiteTimer.doStop();
  783.   return reportAllTables(_testname);
  784. }
  786. int 
  787. NDBT_TestSuite::executeOne(const char* _tabname, const char* _testname){
  788.   
  789.   if(tests.size() == 0)
  790.     return NDBT_FAILED;
  791.   Ndb ndb("TEST_DB");
  792.   ndb.init(1024);
  794.   int result = ndb.waitUntilReady(300); // 5 minutes
  795.   if (result != 0){
  796.     g_err << name <<": Ndb was not ready" << endl;
  797.     return NDBT_FAILED;
  798.   }
  800.   ndbout << name << " started [" << getDate() << "]" << endl;
  802.   const NdbDictionary::Table* ptab = NDBT_Tables::getTable(_tabname);
  803.   if (ptab == NULL)
  804.     return NDBT_FAILED;
  806.   ndbout << "|- " << ptab->getName() << endl;
  808.   execute(&ndb, ptab, _testname);
  810.   if (numTestsFail > 0){
  811.     return NDBT_FAILED;
  812.   }else{
  813.     return NDBT_OK;
  814.   }
  815. }
  817. void NDBT_TestSuite::execute(Ndb* ndb, const NdbDictionary::Table* pTab, 
  818.      const char* _testname){
  819.   int result; 
  821.  
  822.   for (unsigned t = 0; t < tests.size(); t++){
  824.     if (_testname != NULL && 
  825. strcasecmp(tests[t]->getName(), _testname) != 0)
  826.       continue;
  828.     if (tests[t]->isVerify(pTab) == false) {
  829.       continue;
  830.     }
  832.     tests[t]->initBeforeTest();
  834.     NdbDictionary::Dictionary* pDict = ndb->getDictionary();
  835.     const NdbDictionary::Table* pTab2 = pDict->getTable(pTab->getName());
  836.     if (createTable == true){
  838.       if(pTab2 != 0 && pDict->dropTable(pTab->getName()) != 0){
  839. numTestsFail++;
  840. numTestsExecuted++;
  841. g_err << "ERROR0: Failed to drop table " << pTab->getName() << endl;
  842. tests[t]->saveTestResult(pTab, FAILED_TO_CREATE);
  843. continue;
  844.       }
  845.       
  846.       if(NDBT_Tables::createTable(ndb, pTab->getName()) != 0){
  847. numTestsFail++;
  848. numTestsExecuted++;
  849. g_err << "ERROR1: Failed to create table " << pTab->getName()
  850.               << pDict->getNdbError() << endl;
  851. tests[t]->saveTestResult(pTab, FAILED_TO_CREATE);
  852. continue;
  853.       }
  854.       pTab2 = pDict->getTable(pTab->getName());
  855.     } else if(!pTab2) {
  856.       pTab2 = pTab;
  857.     } 
  858.     
  859.     ctx = new NDBT_Context();
  860.     ctx->setTab(pTab2);
  861.     ctx->setNumRecords(records);
  862.     ctx->setNumLoops(loops);
  863.     if(remote_mgm != NULL)
  864.       ctx->setRemoteMgm(remote_mgm);
  865.     ctx->setSuite(this);
  867.     result = tests[t]->execute(ctx);
  868.     tests[t]->saveTestResult(pTab, result);
  869.     if (result != NDBT_OK)
  870.       numTestsFail++;
  871.     else
  872.       numTestsOk++;
  873.     numTestsExecuted++;
  875.     if (result == NDBT_OK && createTable == true){
  876.       pDict->dropTable(pTab->getName());
  877.     }
  878.     
  879.     delete ctx;
  880.   }
  881. }
  886. int 
  887. NDBT_TestSuite::report(const char* _tcname){
  888.   int result;
  889.   ndbout << "Completed " << name << " [" << getDate() << "]" << endl;
  890.   printTestCaseSummary(_tcname);
  891.   ndbout << numTestsExecuted << " test(s) executed" << endl;
  892.   ndbout << numTestsOk << " test(s) OK" 
  893.  << endl;
  894.   if(numTestsFail > 0)
  895.     ndbout << numTestsFail << " test(s) failed"
  896.    << endl;
  897.   testSuiteTimer.printTotalTime();
  898.   if (numTestsFail > 0 || numTestsExecuted == 0){
  899.     result = NDBT_FAILED;
  900.   }else{
  901.     result = NDBT_OK;
  902.   }
  903.   return result;
  904. }
  906. void NDBT_TestSuite::printTestCaseSummary(const char* _tcname){
  907.   ndbout << "= SUMMARY OF TEST EXECUTION ==============" << endl;
  908.   for (unsigned t = 0; t < tests.size(); t++){
  909.     if (_tcname != NULL && 
  910. strcasecmp(tests[t]->getName(), _tcname) != 0)
  911.       continue;
  913.     tests[t]->printTestResult();
  914.   }
  915.   ndbout << "==========================================" << endl;
  916. }
  918. int NDBT_TestSuite::reportAllTables(const char* _testname){
  919.   int result;
  920.   ndbout << "Completed running test [" << getDate() << "]" << endl;
  921.   const int totalNumTests = numTestsExecuted;
  922.   printTestCaseSummary(_testname);
  923.   ndbout << numTestsExecuted<< " test(s) executed" << endl;
  924.   ndbout << numTestsOk << " test(s) OK("
  925.  <<(int)(((float)numTestsOk/totalNumTests)*100.0) <<"%)" 
  926.  << endl;
  927.   if(numTestsFail > 0)
  928.     ndbout << numTestsFail << " test(s) failed("
  929.    <<(int)(((float)numTestsFail/totalNumTests)*100.0) <<"%)" 
  930.    << endl;
  931.   testSuiteTimer.printTotalTime();
  932.   if (numTestsExecuted > 0){
  933.     if (numTestsFail > 0){
  934.       result = NDBT_FAILED;
  935.     }else{
  936.       result = NDBT_OK;
  937.     }
  938.   } else {
  939.     result = NDBT_FAILED;
  940.   }
  941.   return result;
  942. }
  944. int NDBT_TestSuite::execute(int argc, const char** argv){
  945.   int res = NDBT_FAILED;
  946.   /* Arguments:
  947.        Run only a subset of tests
  948.        -n testname Which test to run
  949.        Recommendations to test functions:
  950.        --records Number of records to use(default: 10000)
  951.        --loops Number of loops to execute in the test(default: 100)
  953.        Other parameters should:
  954.        * be calculated from the above two parameters 
  955.        * be divided into different test cases, ex. one testcase runs
  956.          with FragmentType = Single and another perfoms the same 
  957.          test with FragmentType = Large
  958.        * let the test case iterate over all/subset of appropriate parameters
  959.          ex. iterate over FragmentType = Single to FragmentType = AllLarge
  961.        Remeber that the intention is that it should be _easy_ to run 
  962.        a complete test suite without any greater knowledge of what 
  963.        should be tested ie. keep arguments at a minimum
  964.   */
  965.   int _records = 1000;
  966.   int _loops = 5;
  967.   int _timer = 0;
  968.   char * _remote_mgm =NULL;
  969.   char* _testname = NULL;
  970.   const char* _tabname = NULL;
  971.   int _print = false;
  972.   int _print_html = false;
  974.   int _print_cases = false;
  975.   int _verbose = false;
  976. #ifndef DBUG_OFF
  977.   const char *debug_option= 0;
  978. #endif
  980.   struct getargs args[] = {
  981.     { "print", '', arg_flag, &_print, "Print execution tree", "" },
  982.     { "print_html", '', arg_flag, &_print_html, "Print execution tree in html table format", "" },
  983.     { "print_cases", '', arg_flag, &_print_cases, "Print list of test cases", "" },
  984.     { "records", 'r', arg_integer, &_records, "Number of records", "records" },
  985.     { "loops", 'l', arg_integer, &_loops, "Number of loops", "loops" },
  986.     { "testname", 'n', arg_string, &_testname, "Name of test to run", "testname" },
  987.     { "remote_mgm", 'm', arg_string, &_remote_mgm, 
  988.       "host:port to mgmsrv of remote cluster", "host:port" },
  989.     { "timer", 't', arg_flag, &_timer, "Print execution time", "time" },
  990. #ifndef DBUG_OFF
  991.     { "debug", 0, arg_string, &debug_option,
  992.       "Specify debug options e.g. d:t:i:o,out.trace", "options" },
  993. #endif
  994.     { "verbose", 'v', arg_flag, &_verbose, "Print verbose status", "verbose" }
  995.   };
  996.   int num_args = sizeof(args) / sizeof(args[0]);
  997.   int optind = 0;
  999.   if(getarg(args, num_args, argc, argv, &optind)) {
  1000.     arg_printusage(args, num_args, argv[0], "tabname1 tabname2 ... tabnameNn");
  1001.     return NDBT_WRONGARGS;
  1002.   }
  1004. #ifndef DBUG_OFF
  1005.   if (debug_option)
  1006.     DBUG_PUSH(debug_option);
  1007. #endif
  1009.   // Check if table name is supplied
  1010.   if (argv[optind] != NULL)
  1011.     _tabname = argv[optind];
  1013.   if (_print == true){
  1014.     printExecutionTree();
  1015.     return 0;
  1016.   }
  1018.   if (_print_html == true){
  1019.     printExecutionTreeHTML();
  1020.     return 0;
  1021.   }
  1023.   if (_print_cases == true){
  1024.     printCases();
  1025.     return NDBT_ProgramExit(NDBT_FAILED);
  1026.   }
  1028.   if (_verbose)
  1029.     setOutputLevel(2); // Show g_info
  1030.   else 
  1031.    setOutputLevel(0); // Show only g_err ?
  1033.   remote_mgm = _remote_mgm;
  1034.   records = _records;
  1035.   loops = _loops;
  1036.   timer = _timer;
  1038.   if(optind == argc){
  1039.     // No table specified
  1040.     res = executeAll(_testname);
  1041.   } else {
  1042.     testSuiteTimer.doStart(); 
  1043.     Ndb ndb("TEST_DB"); ndb.init();
  1044.     for(int i = optind; i<argc; i++){
  1045.       executeOne(argv[i], _testname);
  1046.     }
  1047.     testSuiteTimer.doStop();
  1048.     res = report(_testname);
  1049.   }
  1050.   
  1051.   return NDBT_ProgramExit(res);
  1052. }
  1053.  
  1056. void NDBT_TestSuite::printExecutionTree(){
  1057.   ndbout << "Testsuite: " << name << endl;
  1058.   for (unsigned t = 0; t < tests.size(); t++){
  1059.     tests[t]->print();
  1060.     ndbout << endl;
  1061.   } 
  1062. }
  1064. void NDBT_TestSuite::printExecutionTreeHTML(){
  1065.   ndbout << "<tr>" << endl;
  1066.   ndbout << "<td><h3>" << name << "</h3></td>" << endl;
  1067.   ndbout << "</tr>" << endl;
  1068.   for (unsigned t = 0; t < tests.size(); t++){
  1069.     tests[t]->printHTML();
  1070.     ndbout << endl;
  1071.   } 
  1073. }
  1075. void NDBT_TestSuite::printCases(){
  1076.   ndbout << "# Testsuite: " << name << endl;
  1077.   ndbout << "# Number of tests: " << tests.size() << endl; 
  1078.   for (unsigned t = 0; t < tests.size(); t++){
  1079.     ndbout << name << " -n " << tests[t]->getName() << endl;
  1080.   } 
  1081. }
  1083. const char* NDBT_TestSuite::getDate(){
  1084.   static char theTime[128];
  1085.   struct tm* tm_now;
  1086.   time_t now;
  1087.   now = time((time_t*)NULL);
  1088. #ifdef NDB_WIN32
  1089.   tm_now = localtime(&now);
  1090. #else
  1091.   tm_now = gmtime(&now);
  1092. #endif
  1093.   
  1094.   BaseString::snprintf(theTime, 128,
  1095.    "%d-%.2d-%.2d %.2d:%.2d:%.2d",
  1096.    tm_now->tm_year + 1900, 
  1097.    tm_now->tm_mon + 1, 
  1098.    tm_now->tm_mday,
  1099.    tm_now->tm_hour,
  1100.    tm_now->tm_min,
  1101.    tm_now->tm_sec);
  1103.   return theTime;
  1104. }
  1106. void NDBT_TestCaseImpl1::printHTML(){
  1108.   ndbout << "<tr><td>&nbsp;</td>" << endl;
  1109.   ndbout << "<td name=tc>" << endl << name << "</td><td width=70%>" 
  1110.  << comment << "</td></tr>" << endl;  
  1111. }
  1113. void NDBT_TestCaseImpl1::print(){
  1114.   ndbout << "Test case: " << name << endl;
  1115.   ndbout << "Description: "<< comment << endl;
  1117.   ndbout << "Parameters: " << endl;
  1119.   Properties::Iterator it(&props);
  1120.   for(const char * key = it.first(); key != 0; key = it.next()){
  1121.     PropertiesType pt;
  1122.     const bool b = props.getTypeOf(key, &pt);
  1123.     assert(b == true);
  1124.     switch(pt){
  1125.     case PropertiesType_Uint32:{
  1126.       Uint32 val;
  1127.       props.get(key, &val);
  1128.       ndbout << "      " << key << ": " << val << endl;
  1129.       break;
  1130.     }
  1131.     case PropertiesType_char:{
  1132.       const char * val;
  1133.       props.get(key, &val);
  1134.       ndbout << "    " << key << ": " << val << endl;
  1135.       break;
  1136.     }
  1137.     default:
  1138.       abort();
  1139.     }  
  1140.   }
  1141.   unsigned i; 
  1142.   for(i=0; i<initializers.size(); i++){
  1143.     ndbout << "Initializers[" << i << "]: " << endl;
  1144.     initializers[i]->print();
  1145.   }
  1146.   for(i=0; i<steps.size(); i++){
  1147.     ndbout << "Step[" << i << "]: " << endl;
  1148.     steps[i]->print();
  1149.   }
  1150.   for(i=0; i<verifiers.size(); i++){
  1151.     ndbout << "Verifier[" << i << "]: " << endl;
  1152.     verifiers[i]->print();
  1153.   }
  1154.   for(i=0; i<finalizers.size(); i++){
  1155.     ndbout << "Finalizer[" << i << "]: " << endl;
  1156.     finalizers[i]->print();
  1157.   }
  1158.       
  1159. }
  1161. void NDBT_Step::print(){
  1162.   ndbout << "      "<< name << endl;
  1164. }
  1166. void
  1167. NDBT_Context::sync_down(const char * key){
  1168.   Uint32 threads = getProperty(key, (unsigned)0);
  1169.   if(threads){
  1170.     decProperty(key);
  1171.   }
  1172. }
  1174. void
  1175. NDBT_Context::sync_up_and_wait(const char * key, Uint32 value){
  1176.   setProperty(key, value);
  1177.   getPropertyWait(key, (unsigned)0);
  1178. }
  1180. template class Vector<NDBT_TestCase*>;
  1181. template class Vector<NDBT_TestCaseResult*>;
  1182. template class Vector<NDBT_Step*>;
  1183. template class Vector<NdbThread*>;
  1184. template class Vector<NDBT_Verifier*>;
  1185. template class Vector<NDBT_Initializer*>;
  1186. template class Vector<NDBT_Finalizer*>;
  1187. template class Vector<const NdbDictionary::Table*>;