searchengine/cpix/tsrc/cpixunittest/src/asynctests.cpp
changeset 3 ae3f1779f6da
parent 0 671dee74050a
child 14 8bd192d47aaa
equal deleted inserted replaced
2:6c1a2771f4b7 3:ae3f1779f6da
    35 #include "suggestion.h"
    35 #include "suggestion.h"
    36 #include "testutils.h"
    36 #include "testutils.h"
    37 #include "testcorpus.h"
    37 #include "testcorpus.h"
    38 #include "setupsentry.h"
    38 #include "setupsentry.h"
    39 
    39 
       
    40 #include "std_log_result.h"
    40 
    41 
    41 // TODO PROPER, EXAMPLARY error clearing (cpix_ClearError())
    42 // TODO PROPER, EXAMPLARY error clearing (cpix_ClearError())
    42 
    43 
    43 
    44 
    44 bool AddField(cpix_Document * doc,
    45 bool AddField(cpix_Document * doc,
  1215 
  1216 
  1216 
  1217 
  1217     
  1218     
  1218     void testSingleThreadIdx(Itk::TestMgr * testMgr)
  1219     void testSingleThreadIdx(Itk::TestMgr * testMgr)
  1219     {
  1220     {
       
  1221         char *xml_file = (char*)__FUNCTION__;
       
  1222         assert_failed = 0;
  1220         testMgr_ = testMgr;
  1223         testMgr_ = testMgr;
  1221 
  1224 
  1222         // cpix_setLogLevel(CPIX_LL_DEBUG);
  1225         // cpix_setLogLevel(CPIX_LL_DEBUG);
  1223 
  1226 
  1224         pthread_t
  1227         pthread_t
  1244                               &rv);
  1247                               &rv);
  1245         
  1248         
  1246         ITK_EXPECT(testMgr,
  1249         ITK_EXPECT(testMgr,
  1247                    result == 0,
  1250                    result == 0,
  1248                    "Could not join indexer thread");
  1251                    "Could not join indexer thread");
  1249 
  1252         if(result != 0) 
       
  1253             {
       
  1254             assert_failed = 1;
       
  1255             }
       
  1256         testResultXml(xml_file);
  1250         // cpix_setLogLevel(CPIX_LL_TRACE);
  1257         // cpix_setLogLevel(CPIX_LL_TRACE);
  1251 
  1258 
  1252         printStatistics();
  1259         printStatistics();
  1253     }
  1260     }
  1254     
  1261     
  1255 
  1262 
  1256 
  1263 
  1257     void testSingleThreadQry(Itk::TestMgr * testMgr)
  1264     void testSingleThreadQry(Itk::TestMgr * testMgr)
  1258     {
  1265     {
       
  1266         char *xml_file = (char*)__FUNCTION__;
       
  1267         assert_failed = 0;
  1259         testMgr_ = testMgr;
  1268         testMgr_ = testMgr;
  1260 
  1269 
  1261         // cpix_setLogLevel(CPIX_LL_DEBUG);
  1270         // cpix_setLogLevel(CPIX_LL_DEBUG);
  1262 
  1271 
  1263         pthread_t
  1272         pthread_t
  1283                               &rv);
  1292                               &rv);
  1284 
  1293 
  1285         ITK_EXPECT(testMgr,
  1294         ITK_EXPECT(testMgr,
  1286                    result == 0,
  1295                    result == 0,
  1287                    "Could not join searcher thread");
  1296                    "Could not join searcher thread");
  1288 
  1297         if(result != 0) 
       
  1298             {
       
  1299             assert_failed = 1;
       
  1300             }
       
  1301         testResultXml(xml_file);
  1289         // cpix_setLogLevel(CPIX_LL_TRACE);
  1302         // cpix_setLogLevel(CPIX_LL_TRACE);
  1290 
  1303 
  1291         printStatistics();
  1304         printStatistics();
  1292     }
  1305     }
  1293 
  1306 
  1294 
  1307 
  1295 
  1308 
  1296     void testMultiThreads(Itk::TestMgr * testMgr)
  1309     void testMultiThreads(Itk::TestMgr * testMgr)
  1297     {
  1310     {
       
  1311         char *xml_file = (char*)__FUNCTION__;
       
  1312         assert_failed = 0;
  1298         cleanup();
  1313         cleanup();
  1299         setup();
  1314         setup();
  1300 
  1315 
  1301         testMgr_ = testMgr;
  1316         testMgr_ = testMgr;
  1302 
  1317 
  1348                               &rv);
  1363                               &rv);
  1349         
  1364         
  1350         ITK_EXPECT(testMgr,
  1365         ITK_EXPECT(testMgr,
  1351                    result == 0,
  1366                    result == 0,
  1352                    "Could not join indexer thread");
  1367                    "Could not join indexer thread");
  1353 
  1368         if(result != 0) 
       
  1369             {
       
  1370             assert_failed = 1;
       
  1371             }
       
  1372         
  1354         result = pthread_join(searcherThreadHndl,
  1373         result = pthread_join(searcherThreadHndl,
  1355                               &rv);
  1374                               &rv);
  1356 
  1375 
  1357         ITK_EXPECT(testMgr,
  1376         ITK_EXPECT(testMgr,
  1358                    result == 0,
  1377                    result == 0,
  1359                    "Could not join searcher thread");
  1378                    "Could not join searcher thread");
  1360 
  1379         if(result != 0) 
       
  1380             {
       
  1381             assert_failed = 1;
       
  1382             }
       
  1383         testResultXml(xml_file);
  1361         // cpix_setLogLevel(CPIX_LL_TRACE);
  1384         // cpix_setLogLevel(CPIX_LL_TRACE);
  1362 
  1385 
  1363         printStatistics();
  1386         printStatistics();
  1364     }
  1387     }
  1365 
  1388 
  1534                             }
  1557                             }
  1535                     }
  1558                     }
  1536             }
  1559             }
  1537         catch (...)
  1560         catch (...)
  1538             {
  1561             {
       
  1562                 assert_failed = 1;
  1539                 ITK_EXPECT(testMgr_,
  1563                 ITK_EXPECT(testMgr_,
  1540                            false,
  1564                            false,
  1541                            "INDEXER: Failed indexing\n");
  1565                            "INDEXER: Failed indexing\n");
  1542                 throw;
  1566                 throw;
  1543             }
  1567             }
  1608                         ITK_DBGMSG(testMgr_, ":");
  1632                         ITK_DBGMSG(testMgr_, ":");
  1609                     }
  1633                     }
  1610             }
  1634             }
  1611         catch (...)
  1635         catch (...)
  1612             {
  1636             {
       
  1637                 assert_failed = 1;
  1613                 ITK_EXPECT(testMgr_,
  1638                 ITK_EXPECT(testMgr_,
  1614                            false,
  1639                            false,
  1615                            "SEARCHER: Failed searching\n");
  1640                            "SEARCHER: Failed searching\n");
  1616                 throw;
  1641                 throw;
  1617             }
  1642             }