main.cpp

Go to the documentation of this file.

#include <gtest/gtest.h>
#include <iostream>
#include <fstream>
#include <iterator>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>

#include <Poco/ConsoleChannel.h>
#include <Poco/FileChannel.h>
#include <Poco/FormattingChannel.h>
#include <Poco/PatternFormatter.h>
#include <Poco/Logger.h>
#include <Poco/AutoPtr.h>

#include "SphinxTestPrinter.hpp"

#include "SphinxResultDataSerializator.hpp"

#include "SphinxIndexTest.hpp"
#include "SphinxSearchTest.hpp"
#include "SphinxManageTest.hpp"
#include "SphinxFunctionalObjectTest.hpp"
#include "SphinxStressTest.hpp"

#include "SphinxInputJsonMessage.hpp"
#include "SphinxOutputJsonMessage.hpp"
#include "SphinxFunctionalObject.hpp"

#include "SphinxMultiIndexTest.hpp"
#include "SphinxSearchInterface.hpp"

//-------------------------------------------------------------------
//-------------------------------------------------------------------
namespace HCE
{
  namespace sphinx
  {
    namespace tests
    {
      Poco::SharedPtr<SphinxFunctionalObject> pObj = nullptr;
      std::string homeDir;
      TestPerfomanceData perfomanceData;
      StressTestData stressTestData;
    } // end namespace tests
  } // end namespace sphinx
} // end namespace HCE
//-----------------------------------------------------------------------------
void printUsageAndExit(const char* appName)
{
  std::cerr << "\nUsage: " << appName << " -S <home_dir> -F <data_file_name> -C <index_count> -D <source_test_dir> -I <index_name> -M <need_make_index> -R <need_remove_index>"
      << "\n\n<home_dir> - home dir of cluster node (need for all tests)"
      << "\n<data_file_name> - data file used for create temporary indexes (need for perfomance test)"
      << "\n<index_count> - number of create temporary indexes (need for perfomance test)"
      << "\n<source_test_dir> - source dir content data files (need for stress test)"
      << "\n<index_name> - index name (need for stress test)"
      << "\n<need_make_index> - flag necessary make index (need for stress test)"
      << "\n<need_remove_index> - flag necessary remove index (need for stress test)\n"
      << std::endl;
  exit(1);
}
//-------------------------------------------------------------------
//-------------------------------------------------------------------

int main(int argc, char** argv)
{
  Poco::AutoPtr<Poco::PatternFormatter> pPatternFormatter(new Poco::PatternFormatter("%Y-%m-%d %H:%M:%S.%c %N[%P]:%s:%q:%t"));
  if (pPatternFormatter)
  {
    Poco::AutoPtr<Poco::FormattingChannel> pChannel = new Poco::FormattingChannel(pPatternFormatter);
    if (pChannel)
    {
      Poco::AutoPtr<Poco::ConsoleChannel> pCons(new Poco::ConsoleChannel());
      pChannel->setChannel(pCons);
      pChannel->open();
      Poco::Logger::root().setChannel(pChannel);
      Poco::Logger::root().setLevel("debug");
    }
  }

  HCE::sphinx::tests::homeDir = ".";// "/home/alexander/hce-node-tests";

  HCE::sphinx::tests::perfomanceData.dataFileName = "./test1000.dat";
  HCE::sphinx::tests::perfomanceData.indexCount = 10;

  HCE::sphinx::tests::stressTestData.sourceTestDir = "../tests/sphinx_data";
  HCE::sphinx::tests::stressTestData.indexName = "i003";
  HCE::sphinx::tests::stressTestData.needMakeIndex = true;
  HCE::sphinx::tests::stressTestData.needRemoveIndex = true;
  try
  {
    int rez=0;
    while((rez = getopt(argc,argv,"hHs:S:f:F:c:C:d:D:i:I:f:F:m:M:r:R:")) != -1)
    {
      switch(rez)
      {
        case 'h':
        case 'H': printUsageAndExit(argv[0]);
          break;
        case 's':
        case 'S': HCE::sphinx::tests::homeDir = optarg;
          break;
        case 'f':
        case 'F': HCE::sphinx::tests::perfomanceData.dataFileName = optarg;
          break;
        case 'c':
        case 'C': HCE::sphinx::tests::perfomanceData.indexCount = std::stoul(optarg);
          break;
        case 'd':
        case 'D': HCE::sphinx::tests::stressTestData.sourceTestDir = optarg;
          break;
        case 'i':
        case 'I': HCE::sphinx::tests::stressTestData.indexName = optarg;
          break;
        case 'm':
        case 'M': HCE::sphinx::tests::stressTestData.needMakeIndex = static_cast<bool>(std::stoul(optarg));
          break;
        case 'r':
        case 'R': HCE::sphinx::tests::stressTestData.needRemoveIndex = static_cast<bool>(std::stoul(optarg));
          break;
      };
    };
  }
  catch(std::exception& e)
  {
    std::cerr << "Error: " << e.what() << std::endl;
    printUsageAndExit(argv[0]);
  }

  testing::InitGoogleTest(&argc, argv);

  // Gets hold of the event listener list.
  testing::TestEventListeners& listeners = testing::UnitTest::GetInstance()->listeners();
  // Adds a listener to the end.  Google Test takes the ownership.
  listeners.Append(new HCE::sphinx::tests::SphinxTestPrinter);

  return RUN_ALL_TESTS();
}

/*
int main(void)
{
  HCE::sphinx::tests::homeDir = "/home/alexander/hce-node-tests";
  HCE::sphinx::SphinxFunctionalObject fObj;
  fObj.setHomeDir(HCE::sphinx::tests::homeDir);
//  fObj.setLogStream(std::cout);

//  HCE::sphinx::tests::SphinxFunctionalObjectTest::fullAdminCommandsTest(fObj);
//  HCE::sphinx::tests::SphinxFunctionalObjectTest::changeSearchIndexTest(fObj);
//  HCE::sphinx::tests::SphinxFunctionalObjectTest::autoGettingPortsSearchd(fObj);
//  HCE::sphinx::tests::SphinxFunctionalObjectTest::fullIndexerTest(fObj);
//  HCE::sphinx::tests::SphinxFunctionalObjectTest::fullSearcherTest(fObj); // restore implementation
//  HCE::sphinx::tests::SphinxFunctionalObjectTest::differentFiltersTest(fObj);
//  bool ret = HCE::sphinx::tests::SphinxFunctionalObjectTest::isUse64Bit(fObj);
//  std::cout << "Use 64 Bit = " << std::boolalpha << ret << std::endl;

//  const size_t indexCount = 10;
//  const std::string dataFileName = "./test1000.dat";
//  HCE::sphinx::tests::SphinxFunctionalObjectTest::testPerfomance(dataFileName, indexCount);

//  const std::string sourceTestDir = "../tests/sphinx_data";
//  const std::string indexName = "i003";
//  bool needMakeIndex = false;
//  bool needRemoveIndex = false;

//  HCE::sphinx::tests::SphinxFunctionalObjectTest::testStressGetBigResult(fObj, sourceTestDir, indexName, needMakeIndex);
//  HCE::sphinx::tests::SphinxFunctionalObjectTest::testGetResultUseOffset(fObj, sourceTestDir, indexName, needMakeIndex);

  std::cout << "Done...\n";
  return 0;
}
*/