/* * Copyright (C) 2004, 2005, 2006, 2009, 2008, 2009, 2010 Savoir-Faire Linux Inc. * Author: Emmanuel Milou <emmanuel.milou@savoirfairelinux.com> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * Additional permission under GNU GPL version 3 section 7: * * If you modify this program, or any covered work, by linking or * combining it with the OpenSSL project's OpenSSL library (or a * modified version of that library), containing parts covered by the * terms of the OpenSSL or SSLeay licenses, Savoir-Faire Linux Inc. * grants you additional permission to convey the resulting work. * Corresponding Source for a non-source form of such a combination * shall include the source code for the parts of OpenSSL used as well * as that of the covered work. */ #include <stdio.h> #include <sstream> #include "historytest.h" #include "manager.h" #include "constants.h" #include "validator.h" using std::cout; using std::endl; void HistoryTest::setUp() { // Instanciate the cleaner singleton history = new HistoryManager(); } void HistoryTest::test_create_history_path() { _debug ("-------------------- HistoryTest::test_create_history_path --------------------\n"); int result; char *cpath; std::string path; cpath = getenv ("XDG_DATA_HOME"); (cpath != NULL) ? path = std::string (cpath) : path = std::string ("/") + HISTORY_SAMPLE; result = history->create_history_path(path); CPPUNIT_ASSERT (result == 0); CPPUNIT_ASSERT (!history->is_loaded ()); CPPUNIT_ASSERT (history->_history_path == path); } void HistoryTest::test_load_history_from_file() { _debug ("-------------------- HistoryTest::test_load_history_from_file --------------------\n"); bool res; Conf::ConfigTree history_list; history->create_history_path(HISTORY_SAMPLE); res = history->load_history_from_file (&history_list); CPPUNIT_ASSERT (history->is_loaded ()); CPPUNIT_ASSERT (res == true); } void HistoryTest::test_load_history_items_map() { _debug ("-------------------- HistoryTest::test_load_history_items_map --------------------\n"); std::string path; int nb_items; Conf::ConfigTree history_list; history->set_history_path (HISTORY_SAMPLE); history->load_history_from_file (&history_list); nb_items = history->load_history_items_map (&history_list, HUGE_HISTORY_LIMIT); CPPUNIT_ASSERT (nb_items == HISTORY_SAMPLE_SIZE); CPPUNIT_ASSERT (history->get_history_size () == HISTORY_SAMPLE_SIZE); } void HistoryTest::test_save_history_items_map() { _debug ("-------------------- HistoryTest::test_save_history_items_map --------------------\n"); std::string path; int nb_items_loaded, nb_items_saved; Conf::ConfigTree history_list, history_list2; history->set_history_path (HISTORY_SAMPLE); history->load_history_from_file (&history_list); nb_items_loaded = history->load_history_items_map (&history_list, HUGE_HISTORY_LIMIT); nb_items_saved = history->save_history_items_map (&history_list2); CPPUNIT_ASSERT (nb_items_loaded == nb_items_saved); } void HistoryTest::test_save_history_to_file() { _debug ("-------------------- HistoryTest::test_save_history_to_file --------------------\n"); std::string path; Conf::ConfigTree history_list, history_list2; std::map<std::string, std::string> res; std::map<std::string, std::string>::iterator iter; history->set_history_path (HISTORY_SAMPLE); history->load_history_from_file (&history_list); history->load_history_items_map (&history_list, HUGE_HISTORY_LIMIT); history->save_history_items_map (&history_list2); CPPUNIT_ASSERT (history->save_history_to_file (&history_list2)); } void HistoryTest::test_get_history_serialized() { _debug ("-------------------- HistoryTest::test_get_history_serialized --------------------\n"); std::map<std::string, std::string> res; std::map<std::string, std::string>::iterator iter; std::string tmp; CPPUNIT_ASSERT (history->load_history (HUGE_HISTORY_LIMIT, HISTORY_SAMPLE) == HISTORY_SAMPLE_SIZE); res = history->get_history_serialized(); CPPUNIT_ASSERT (res.size() ==HISTORY_SAMPLE_SIZE); // Warning - If you change the history-sample file, you must change the following lines also so that the tests could work // The reference here is the file history-sample in this test directory // The serialized form is: calltype%to%from%callid // Check the first tmp = "0|514-276-5468|Savoir-faire Linux|144562458|empty"; std::cout << res ["144562436"] << std::endl; CPPUNIT_ASSERT (Validator::isEqual (tmp, res ["144562436"])); // the account ID does not correspond to a loaded account tmp = "1|5143848557|empty|775354987|empty"; CPPUNIT_ASSERT (Validator::isEqual (tmp, res ["775354456"])); } void HistoryTest::test_set_serialized_history() { _debug ("-------------------- HistoryTest::test_set_serialized_history --------------------\n"); // We build a map to have an efficient test std::map<std::string, std::string> map_test; std::string tmp; Conf::ConfigTree history_list; map_test["144562436"] = "0|514-276-5468|Savoir-faire Linux|144562458|empty"; map_test["747638685"] = "2|136|Emmanuel Milou|747638765|Account:1239059899"; map_test["775354456"] = "1|5143848557|empty|775354987|Account:43789459478"; CPPUNIT_ASSERT (history->load_history (HUGE_HISTORY_LIMIT, HISTORY_SAMPLE) == HISTORY_SAMPLE_SIZE); // We use a large history limit to be able to interpret results CPPUNIT_ASSERT (history->set_serialized_history (map_test, HUGE_HISTORY_LIMIT) == 3); CPPUNIT_ASSERT (history->get_history_size () == 3); map_test.clear(); map_test = history->get_history_serialized(); CPPUNIT_ASSERT (map_test.size() ==3); // Check the first tmp = "0|514-276-5468|Savoir-faire Linux|144562458|empty"; CPPUNIT_ASSERT (Validator::isEqual (tmp, map_test ["144562436"])); // the account ID does not correspond to a loaded account tmp = "1|5143848557|empty|775354987|empty"; CPPUNIT_ASSERT (Validator::isEqual (tmp, map_test ["775354456"])); history->save_history_items_map (&history_list); CPPUNIT_ASSERT (history->save_history_to_file (&history_list)); } void HistoryTest::test_set_serialized_history_with_limit() { _debug ("-------------------- HistoryTest::test_set_serialized_history_with_limit --------------------\n"); // We build a map to have an efficient test std::map<std::string, std::string> map_test; std::string tmp; Conf::ConfigTree history_list; time_t current, day = 86400; // One day in unix timestamp std::stringstream current_1, current_2, current_3; (void) time (¤t); current_1 << (current - 2 * day) << std::endl; current_2 << (current - 5 * day) << std::endl; current_3 << (current - 11 * day) << std::endl; map_test[current_1.str() ] = "0|514-276-5468|Savoir-faire Linux|144562458|empty"; map_test[current_2.str() ] = "2|136|Emmanuel Milou|747638765|Account:1239059899"; map_test[current_3.str() ] = "1|5143848557|empty|775354987|Account:43789459478"; CPPUNIT_ASSERT (history->load_history (HUGE_HISTORY_LIMIT, HISTORY_SAMPLE) == HISTORY_SAMPLE_SIZE); // We use different value of history limit // 10 days - the last entry should not be saved CPPUNIT_ASSERT (history->set_serialized_history (map_test, 10) == 2); CPPUNIT_ASSERT (history->get_history_size () == 2); // 4 days - the two last entries should not be saved CPPUNIT_ASSERT (history->set_serialized_history (map_test, 4) == 1); CPPUNIT_ASSERT (history->get_history_size () == 1); // 1 day - no entry should not be saved CPPUNIT_ASSERT (history->set_serialized_history (map_test, 1) == 0); CPPUNIT_ASSERT (history->get_history_size () == 0); } void HistoryTest::tearDown() { // Delete the history object delete history; history = 0; }