a00025.html

 */

// //////////////////////////////////////////////////////////////////////

// Import section

// //////////////////////////////////////////////////////////////////////

// STL

#include <sstream>

#include <fstream>

#include <string>

// Boost MPL

#include <boost/mpl/push_back.hpp>

#include <boost/mpl/vector.hpp>

#include <boost/mpl/at.hpp>

#include <boost/mpl/assert.hpp>

#include <boost/type_traits/is_same.hpp>

// Boost Unit Test Framework (UTF)

#define BOOST_TEST_DYN_LINK

#define BOOST_TEST_MAIN

#define BOOST_TEST_MODULE StdAirTest

#if BOOST_VERSION >= 103900

#include <boost/test/unit_test.hpp>

#else  // BOOST_VERSION >= 103900

#include <boost/test/test_tools.hpp>

#include <boost/test/results_reporter.hpp>

#include <boost/test/unit_test_suite.hpp>

#include <boost/test/output_test_stream.hpp>

#include <boost/test/unit_test_log.hpp>

#include <boost/test/framework.hpp>

#include <boost/test/detail/unit_test_parameters.hpp>

#endif // BOOST_VERSION >= 103900

// Boost Serialisation

#include <boost/archive/text_oarchive.hpp>

#include <boost/archive/text_iarchive.hpp>

// StdAir

#include <stdair/stdair_inventory_types.hpp>

#include <stdair/service/Logger.hpp>

#include <stdair/STDAIR_Service.hpp>

#include <stdair/basic/float_utils.hpp>

#include <stdair/bom/BomDisplay.hpp>

#include <stdair/bom/BomRoot.hpp>

#include <stdair/bom/BomManager.hpp>

#include <stdair/factory/FacBom.hpp>

#include <stdair/factory/FacBomManager.hpp>

// StdAir Test Suite

#include <test/stdair/StdairTestLib.hpp>

#include <test/stdair/MPInventory.hpp>


namespace boost_utf = boost::unit_test;


#if BOOST_VERSION >= 103900


// (Boost) Unit Test XML Report

std::ofstream utfReportStream ("StandardAirlineITTestSuite_utfresults.xml");


struct UnitTestConfig {

  UnitTestConfig() {

    boost_utf::unit_test_log.set_stream (utfReportStream);

    boost_utf::unit_test_log.set_format (boost_utf::XML);

    boost_utf::unit_test_log.set_threshold_level (boost_utf::log_test_units);

    // boost_utf::unit_test_log.set_threshold_level (boost_utf::log_successful_tests);

  }


  ~UnitTestConfig() {

  }

};


// /////////////// Main: Unit Test Suite //////////////


// Set the UTF configuration (re-direct the output to a specific file)

BOOST_GLOBAL_FIXTURE (UnitTestConfig);


// Start the test suite

BOOST_AUTO_TEST_SUITE (master_test_suite)


BOOST_AUTO_TEST_CASE (float_comparison_test) {

  float a = 0.2f;

  a = 5*a;

  const float b = 1.0f;


  // Test the Boost way

  BOOST_CHECK_MESSAGE (a == b, "The two floats (" << a << " and " << b

                       << ") should be equal, but are not");

  BOOST_CHECK_CLOSE (a, b, 0.0001);


  // Test the Google way

  const FloatingPoint<float> lhs (a), rhs (b);

  BOOST_CHECK_MESSAGE (lhs.AlmostEquals (rhs),

                       "The two floats (" << a << " and " << b

                       << ") should be equal, but are not");

}


BOOST_AUTO_TEST_CASE (mpl_structure_test) {

  const stdair::ClassCode_T lBookingClassCodeA ("A");

  const stdair_test::BookingClass lA (lBookingClassCodeA);

  const stdair_test::Cabin lCabin (lA);


  BOOST_CHECK_EQUAL (lCabin.toString(), lBookingClassCodeA);

  BOOST_CHECK_MESSAGE (lCabin.toString() == lBookingClassCodeA,

                       "The cabin key, '" << lCabin.toString()

                       << "' is not equal to '" << lBookingClassCodeA << "'");


  // MPL

  typedef boost::mpl::vector<stdair_test::BookingClass> MPL_BookingClass;

  typedef boost::mpl::push_back<MPL_BookingClass,

                                stdair_test::Cabin>::type types;


  if (boost::is_same<stdair_test::BookingClass,

                     stdair_test::Cabin::child>::value == false) {

    BOOST_ERROR ("The two types mut be equal, but are not");

  }


  if (boost::is_same<boost::mpl::at_c<types, 1>::type,

                     stdair_test::Cabin>::value == false) {

    BOOST_ERROR ("The type must be stdair_test::Cabin, but is not");

  }

}


BOOST_AUTO_TEST_CASE (stdair_service_initialisation_test) {

  // Output log File

  const std::string lLogFilename ("StandardAirlineITTestSuite_init.log");


  // Set the log parameters

  std::ofstream logOutputFile;


  // Open and clean the log outputfile

  logOutputFile.open (lLogFilename.c_str());

  logOutputFile.clear();


  // Initialise the stdair BOM

  const stdair::BasLogParams lLogParams (stdair::LOG::DEBUG, logOutputFile);

  stdair::STDAIR_Service stdairService (lLogParams);


  // Retrieve (a reference on) the top of the persistent BOM tree

  stdair::BomRoot& lPersistentBomRoot = stdairService.getPersistentBomRoot();


  // Retrieve the BomRoot key, and compare it to the expected one

  const std::string& lBomRootKeyStr = lPersistentBomRoot.describeKey();

  const std::string lBomRootString (" -- ROOT -- ");


  // DEBUG

  STDAIR_LOG_DEBUG ("The BOM root key is '" << lBomRootKeyStr

                    << "'. It should be equal to '" << lBomRootString << "'");


  BOOST_CHECK_EQUAL (lBomRootKeyStr, lBomRootString);

  BOOST_CHECK_MESSAGE (lBomRootKeyStr == lBomRootString,

                       "The BOM root key, '" << lBomRootKeyStr

                       << "', should be equal to '" << lBomRootString

                       << "', but is not.");


  // Build a sample BOM tree

  stdairService.buildSampleBom();


  // DEBUG: Display the whole BOM tree

  const std::string& lCSVDump = stdairService.csvDisplay ();

  STDAIR_LOG_DEBUG (lCSVDump);


  // Close the Log outputFile

  logOutputFile.close();

}


BOOST_AUTO_TEST_CASE (bom_structure_instantiation_test) {

  // Step 0.0: initialisation

  // Create the root of a Bom tree (i.e., a BomRoot object)

  stdair::BomRoot& lBomRoot =

    stdair::FacBom<stdair::BomRoot>::instance().create();


  // Step 0.1: Inventory level

  // Create an Inventory (BA)

  const stdair::AirlineCode_T lBAAirlineCode ("BA");

  const stdair::InventoryKey lBAKey (lBAAirlineCode);

  myprovider::Inventory& lBAInv =

    stdair::FacBom<myprovider::Inventory>::instance().create (lBAKey);

  stdair::FacBomManager::addToList (lBomRoot, lBAInv);


  BOOST_CHECK_EQUAL (lBAInv.describeKey(), lBAAirlineCode);

  BOOST_CHECK_MESSAGE (lBAInv.describeKey() == lBAAirlineCode,

                       "The inventory key, '" << lBAInv.describeKey()

                       << "', should be equal to '" << lBAAirlineCode

                       << "', but is not");


  // Create an Inventory for AF

  const stdair::AirlineCode_T lAFAirlineCode ("AF");

  const stdair::InventoryKey lAFKey (lAFAirlineCode);

  myprovider::Inventory& lAFInv =

    stdair::FacBom<myprovider::Inventory>::instance().create (lAFKey);

  stdair::FacBomManager::addToList (lBomRoot, lAFInv);


  BOOST_CHECK_EQUAL (lAFInv.describeKey(), lAFAirlineCode);

  BOOST_CHECK_MESSAGE (lAFInv.describeKey() == lAFAirlineCode,

                       "The inventory key, '" << lAFInv.describeKey()

                       << "', should be equal to '" << lAFAirlineCode

                       << "', but is not");


  // Browse the inventories

  const myprovider::InventoryList_T& lInventoryList =

      stdair::BomManager::getList<myprovider::Inventory> (lBomRoot);

  const std::string lInventoryKeyArray[2] = {lBAAirlineCode, lAFAirlineCode};

  short idx = 0;

  for (myprovider::InventoryList_T::const_iterator itInv =

         lInventoryList.begin(); itInv != lInventoryList.end();

       ++itInv, ++idx) {

    const myprovider::Inventory* lInv_ptr = *itInv;

    BOOST_REQUIRE (lInv_ptr != NULL);


    BOOST_CHECK_EQUAL (lInventoryKeyArray[idx], lInv_ptr->describeKey());

    BOOST_CHECK_MESSAGE (lInventoryKeyArray[idx] == lInv_ptr->describeKey(),

                         "They inventory key, '" << lInventoryKeyArray[idx]

                         << "', does not match that of the Inventory object: '"

                         << lInv_ptr->describeKey() << "'");

  }

}


BOOST_AUTO_TEST_CASE (bom_structure_serialisation_test) {


  // Backup (thanks to Boost.Serialisation) file

  const std::string lBackupFilename = "StandardAirlineITTestSuite_serial.txt";


  // Output log File

  const std::string lLogFilename ("StandardAirlineITTestSuite_serial.log");


  // Set the log parameters

  std::ofstream logOutputFile;


  // Open and clean the log outputfile

  logOutputFile.open (lLogFilename.c_str());

  logOutputFile.clear();


  // Initialise the stdair BOM

  const stdair::BasLogParams lLogParams (stdair::LOG::DEBUG, logOutputFile);

  stdair::STDAIR_Service stdairService (lLogParams);


  // Build a sample BOM tree

  stdairService.buildSampleBom();


  // Retrieve (a reference on) the top of the persistent BOM tree

  stdair::BomRoot& lPersistentBomRoot = stdairService.getPersistentBomRoot();


  // DEBUG: Display the whole BOM tree

  const std::string& lCSVDump = stdairService.csvDisplay ();

  STDAIR_LOG_DEBUG (lCSVDump);


  // Clone the persistent BOM

  stdairService.clonePersistentBom ();


  // Retrieve the BomRoot key, and compare it to the expected one

  const std::string lBAInvKeyStr ("BA");

  stdair::Inventory* lBAInv_ptr =

    lPersistentBomRoot.getInventory (lBAInvKeyStr);


  // DEBUG

  STDAIR_LOG_DEBUG ("There should be an Inventory object corresponding to the '"

                    << lBAInvKeyStr << "' key.");


  BOOST_REQUIRE_MESSAGE (lBAInv_ptr != NULL,

                         "An Inventory object should exist with the key, '"

                         << lBAInvKeyStr << "'.");


  // create and open a character archive for output

  std::ofstream ofs (lBackupFilename.c_str());


  // save data to archive

  {

    boost::archive::text_oarchive oa (ofs);

    // write class instance to archive

    oa << lPersistentBomRoot;

    // archive and stream closed when destructors are called

  }


  // ... some time later restore the class instance to its orginal state

  stdair::BomRoot& lRestoredBomRoot =

    stdair::FacBom<stdair::BomRoot>::instance().create();

  {

    // create and open an archive for input

    std::ifstream ifs (lBackupFilename.c_str());

    boost::archive::text_iarchive ia(ifs);

    // read class state from archive

    ia >> lRestoredBomRoot;

    // archive and stream closed when destructors are called

  }


  // DEBUG: Display the whole restored BOM tree

  const std::string& lRestoredCSVDump =

    stdairService.csvDisplay(lRestoredBomRoot);

  STDAIR_LOG_DEBUG (lRestoredCSVDump);


  // Retrieve the BomRoot key, and compare it to the expected one

  const std::string& lBomRootKeyStr = lRestoredBomRoot.describeKey();

  const std::string lBomRootString (" -- ROOT -- ");


  // DEBUG

  STDAIR_LOG_DEBUG ("The BOM root key is '" << lBomRootKeyStr

                    << "'. It should be equal to '" << lBomRootString << "'");


  BOOST_CHECK_EQUAL (lBomRootKeyStr, lBomRootString);

  BOOST_CHECK_MESSAGE (lBomRootKeyStr == lBomRootString,

                       "The BOM root key, '" << lBomRootKeyStr

                       << "', should be equal to '" << lBomRootString

                       << "', but is not.");


  // Retrieve the Inventory

  stdair::Inventory* lRestoredBAInv_ptr =

    lRestoredBomRoot.getInventory (lBAInvKeyStr);


  // DEBUG

  STDAIR_LOG_DEBUG ("There should be an Inventory object corresponding to the '"

                    << lBAInvKeyStr << "' key in the restored BOM root.");


  BOOST_CHECK_MESSAGE (lRestoredBAInv_ptr != NULL,

                       "An Inventory object should exist with the key, '"

                       << lBAInvKeyStr << "' in the restored BOM root.");


  // Close the Log outputFile

  logOutputFile.close();

}


BOOST_AUTO_TEST_CASE (bom_structure_clone_test) {


  // Output log File

  const std::string lLogFilename ("StandardAirlineITTestSuite_clone.log");


  // Set the log parameters

  std::ofstream logOutputFile;


  // Open and clean the log outputfile

  logOutputFile.open (lLogFilename.c_str());

  logOutputFile.clear();


  // Initialise the stdair BOM

  const stdair::BasLogParams lLogParams (stdair::LOG::DEBUG, logOutputFile);

  stdair::STDAIR_Service stdairService (lLogParams);


  // Build a sample BOM tree

  stdairService.buildSampleBom();


  // Retrieve (a constant reference on) the top of the persistent BOM tree

  const stdair::BomRoot& lPersistentBomRoot =

    stdairService.getPersistentBomRoot();


  // DEBUG: Display the whole persistent BOM tree

  const std::string& lCSVDump = stdairService.csvDisplay ();

  STDAIR_LOG_DEBUG ("Display the persistent BOM tree.");

  STDAIR_LOG_DEBUG (lCSVDump);


  // Clone the persistent BOM

  stdairService.clonePersistentBom ();


  // Retrieve (a reference on) the top of the clone BOM tree

  stdair::BomRoot& lCloneBomRoot = stdairService.getBomRoot();


  // DEBUG: Display the clone BOM tree after the clone process.

  const std::string& lAfterCloneCSVDump =

    stdairService.csvDisplay(lCloneBomRoot);

  STDAIR_LOG_DEBUG ("Display the clone BOM tree after the clone process.");

  STDAIR_LOG_DEBUG (lAfterCloneCSVDump);


  // Retrieve the clone BomRoot key, and compare it to the persistent BomRoot

  // key.

  const std::string& lCloneBomRootKeyStr = lCloneBomRoot.describeKey();

  const std::string& lPersistentBomRootKeyStr =

    lPersistentBomRoot.describeKey();


  // DEBUG

  STDAIR_LOG_DEBUG ("The clone BOM root key is '" << lCloneBomRootKeyStr

                    << "'. It should be equal to '"

                    << lPersistentBomRootKeyStr << "'");


  BOOST_CHECK_EQUAL (lCloneBomRootKeyStr, lPersistentBomRootKeyStr);

  BOOST_CHECK_MESSAGE (lCloneBomRootKeyStr == lPersistentBomRootKeyStr,

                       "The clone BOM root key, '" << lCloneBomRootKeyStr

                       << "', should be equal to '" << lPersistentBomRootKeyStr

                       << "', but is not.");


  // Retrieve the BA inventory in the clone BOM root

  const std::string lBAInvKeyStr ("BA");

  stdair::Inventory* lCloneBAInv_ptr =

    lCloneBomRoot.getInventory (lBAInvKeyStr);


  // DEBUG

  STDAIR_LOG_DEBUG ("There should be an Inventory object corresponding to the '"

                    << lBAInvKeyStr << "' key in the clone BOM root.");


  BOOST_CHECK_MESSAGE (lCloneBAInv_ptr != NULL,

                       "An Inventory object should exist with the key, '"

                       << lBAInvKeyStr << "' in the clone BOM root.");


  // Close the Log outputFile

  logOutputFile.close();

}


// End the test suite

BOOST_AUTO_TEST_SUITE_END()


#else // BOOST_VERSION >= 103900

boost_utf::test_suite* init_unit_test_suite (int, char* []) {

  boost_utf::test_suite* test = BOOST_TEST_SUITE ("Unit test example 1");

  return test;

}

#endif // BOOST_VERSION >= 103900


/*!