searchengine/cpix/tsrc/cpixunittest/src/flushtests.cpp
changeset 24 65456528cac2
parent 3 ae3f1779f6da
equal deleted inserted replaced
23:d4d56f5e7c55 24:65456528cac2
   124 
   124 
   125 
   125 
   126 
   126 
   127     void testEmptyIndex(Itk::TestMgr * testMgr)
   127     void testEmptyIndex(Itk::TestMgr * testMgr)
   128     {
   128     {
   129         char *xml_file = (char *)__FUNCTION__;
       
   130         assert_failed = 0;
       
   131         checkIndexFiles(testMgr);
   129         checkIndexFiles(testMgr);
   132         testResultXml(xml_file);
   130     }   
   133         
       
   134     }
       
   135 
       
   136     
       
   137     void testAddingBy512B(Itk::TestMgr * testMgr)
   131     void testAddingBy512B(Itk::TestMgr * testMgr)
   138     {
   132     {
   139         char *xml_file = (char *)__FUNCTION__;
       
   140         assert_failed = 0;
       
   141         setMaxInsertBufferSize(testMgr,
   133         setMaxInsertBufferSize(testMgr,
   142                          512); // 512 B buffer
   134                          512); // 512 B buffer
   143         addItems(testMgr,
   135         addItems(testMgr,
   144                  10);
   136                  10);
   145         testResultXml(xml_file);
   137        
   146     }
   138     }
   147 
   139 
   148 
   140 
   149     void testAddingBy10KB(Itk::TestMgr * testMgr)
   141     void testAddingBy10KB(Itk::TestMgr * testMgr)
   150     {
   142     {
   151         char *xml_file = (char *)__FUNCTION__;
       
   152         assert_failed = 0;
       
   153         setMaxInsertBufferSize(testMgr,
   143         setMaxInsertBufferSize(testMgr,
   154                                10*1024); // 10 KB buffer
   144                                10*1024); // 10 KB buffer
   155         addItems(testMgr,
   145         addItems(testMgr,
   156                  40);
   146                  40);
   157         testResultXml(xml_file);
   147        
   158     }
   148     }
   159 
   149 
   160 
   150 
   161     void testFlushing(Itk::TestMgr * testMgr)
   151     void testFlushing(Itk::TestMgr * testMgr)
   162     {
   152     {
   163         char *xml_file = (char *)__FUNCTION__;
       
   164         assert_failed = 0;
       
   165         addItems(testMgr,
   153         addItems(testMgr,
   166                  15);
   154                  15);
   167         flush(testMgr);
   155         flush(testMgr);
   168         checkIndexFiles(testMgr);
   156         checkIndexFiles(testMgr);
   169         testResultXml(xml_file);
   157        
   170     }
   158     }
   171 
   159 
   172 
   160 
   173 private:
   161 private:
   174 
   162 
   210         
   198         
   211         ITK_ASSERT(testMgr,
   199         ITK_ASSERT(testMgr,
   212                    cpix_Succeeded(util_->idxDb()),
   200                    cpix_Succeeded(util_->idxDb()),
   213                    "Could not set the maxInsertBufferSize to %d",
   201                    "Could not set the maxInsertBufferSize to %d",
   214                    trunkated); 
   202                    trunkated); 
   215         if(!cpix_Succeeded(util_->idxDb()))
   203 
   216             {
   204                        printf("Set max insert buffer size to %d\n",
   217                 assert_failed = 1;
       
   218             }
       
   219         printf("Set max insert buffer size to %d\n",
       
   220         	   trunkated);
   205         	   trunkated);
   221     }
   206     }
   222 
   207 
   223     
   208     
   224     void flush(Itk::TestMgr * testMgr)
   209     void flush(Itk::TestMgr * testMgr)
   225     {
   210     {
   226         cpix_IdxDb_flush(util_->idxDb());
   211         cpix_IdxDb_flush(util_->idxDb());
   227         ITK_ASSERT(testMgr,
   212         ITK_ASSERT(testMgr,
   228                    cpix_Succeeded(util_->idxDb()),
   213                    cpix_Succeeded(util_->idxDb()),
   229                    "Could not flush index database");
   214                    "Could not flush index database");
   230         if(!cpix_Succeeded(util_->idxDb()))
   215 
   231             {
       
   232                 assert_failed = 1;
       
   233             }
       
   234         printf("Flushed index database\n");
   216         printf("Flushed index database\n");
   235     }
   217     }
   236     
   218     
   237 
   219 
   238 private:
   220 private: