main.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#include <iostream>
#include "phoenix_assert.h"
#include "BaseDaemon.h"
#include "Representation.h"
 
using namespace Swarm;

void testBaseDaemonGetMessageToConfirm() {
        BaseDaemon daemon;
        Message msg;
        msg.setId(123);
        msg.setSendTime(time(nullptr));
        msg.getVecRecver().push_back("receiver1");
        daemon.addMessageToConfirm(msg);
 
        Message retrieved;
        phoenix_assert(daemon.getMessageToConfirm(retrieved, 123));
        phoenix_assert(retrieved.getId() == 123);
 
        Message notFound;
        phoenix_assert(!daemon.getMessageToConfirm(notFound, 999));
}


void testBaseDaemonProcessConfirmedMessage(const PPath & fileName) {
        BaseDaemon daemon;
        daemon.load(fileName, "main");
 
        Message msg;
        msg.setId(456);
        msg.setSendTime(3lu);
        msg.setData(Data());
        msg.getVecRecver().push_back("receiver2");
        daemon.addMessageToConfirm(msg);
 
        // Confirm the message
        daemon.processConfirmedMessage(456, 5lu);
        Message shouldNotExist;
        phoenix_assert(!daemon.getMessageToConfirm(shouldNotExist, 456));
}

void testBaseDaemonMissingDaemonSectionTomlString(){
        PString invalidTomlConfig = R"(
[other_section]
name = "test"
value = 42
 
[another_section]
host = "localhost"
)";
        BaseDaemon daemon;
        PHOENIX_EXCEPTION_TYPE_ASSERT(Phoenix::ConfigException, daemon.load(invalidTomlConfig, "main", ConfigFormat::TOML));
}

void testBaseDaemonMissingDaemonSectionYmlString(){
        PString invalidYmlConfig = R"(
other_section:
  name: "test"
  value: 42
 
another_section:
  host: "localhost"
)";
        BaseDaemon daemon;
        PHOENIX_EXCEPTION_TYPE_ASSERT(Phoenix::ConfigException, daemon.load(invalidYmlConfig, "main", ConfigFormat::YAML));
}

void testBaseDaemonMissingDaemonSectionJsonString(){
        PString invalidJsonConfig = R"({
"other_section": {
        "name": "test",
        "value": 42
},
"another_section": {
        "host": "localhost"
}
})";
        BaseDaemon daemon;
        PHOENIX_EXCEPTION_TYPE_ASSERT(Phoenix::ConfigException, daemon.load(invalidJsonConfig, "main", ConfigFormat::JSON));
}

void testBaseDaemonMissingDaemonSectionTomlFile(){
        PPath tempFile = PPath("test_no_daemon_section.toml");
        PString invalidTomlConfig = R"(
[other_section]
name = "test"
value = 42
)";
        tempFile.saveFileContent(invalidTomlConfig);
        BaseDaemon daemon;
        PHOENIX_EXCEPTION_TYPE_ASSERT(Phoenix::ConfigException, daemon.load(tempFile, "main"));
}

void testBaseDaemonMissingDaemonSectionYmlFile(){
        PPath tempFile = PPath("test_no_daemon_section.yml");
        PString invalidYmlConfig = R"(
other_section:
  name: "test"
  value: 42
)";
        tempFile.saveFileContent(invalidYmlConfig);
        BaseDaemon daemon;
        PHOENIX_EXCEPTION_TYPE_ASSERT(Phoenix::ConfigException, daemon.load(tempFile, "main"));
}

void testBaseDaemonMissingDaemonSectionJsonFile(){
        PPath tempFile = PPath("test_no_daemon_section.json");
        PString invalidJsonConfig = R"({
"other_section": {
        "name": "test",
        "value": 42
}
})";
        tempFile.saveFileContent(invalidJsonConfig);
        BaseDaemon daemon;
        PHOENIX_EXCEPTION_TYPE_ASSERT(Phoenix::ConfigException, daemon.load(tempFile, "main"));
}


void testBaseDaemonLoadConfigToml(const PPath & fileName){
        BaseDaemon daemon;
        daemon.load(fileName, "main");
        phoenix_assert(daemon.isDaemonExist("other"));
        BaseDaemon daemon2;
        PHOENIX_EXCEPTION_TYPE_ASSERT(Phoenix::ConfigException, daemon2.load(fileName, "not_in_in_the_list"));
        BaseDaemon daemon3;
        PHOENIX_EXCEPTION_TYPE_ASSERT(Phoenix::ParserException, daemon3.load(PPath("unexisting_config.toml"), "main"));
}


void testBaseDaemonLoadConfigTomlString(const PPath & fileName){
        // Read toml file in a string
        PString tomlString = fileName.loadFileContent();
        BaseDaemon daemon;
        daemon.load(tomlString, "main", ConfigFormat::TOML);
        phoenix_assert(daemon.isDaemonExist("other"));
        BaseDaemon daemon2;
        PHOENIX_EXCEPTION_TYPE_ASSERT(Phoenix::ConfigException, daemon2.load(tomlString, "not_in_in_the_list", ConfigFormat::TOML));
}


void testBaseDaemonLoadConfigYml(const PPath & fileName){
        BaseDaemon daemon;
        daemon.load(fileName, "main");
        phoenix_assert(daemon.isDaemonExist("other"));
        BaseDaemon daemon2;
        PHOENIX_EXCEPTION_TYPE_ASSERT(Phoenix::ConfigException, daemon2.load(fileName, "not_in_in_the_list"));
        BaseDaemon daemon3;
        PHOENIX_EXCEPTION_TYPE_ASSERT(Phoenix::ParserException, daemon3.load(PPath("unexisting_config.yml"), "main"));
        BaseDaemon daemon4;
        PHOENIX_EXCEPTION_TYPE_ASSERT(Phoenix::ParserException, daemon4.load(PPath("file.nonextension"), "main"));
}


void testBaseDaemonLoadConfigYmlString(const PPath & fileName){
        // Read yaml file in a string
        PString ymlString = fileName.loadFileContent();
        BaseDaemon daemon;
        daemon.load(ymlString, "main", ConfigFormat::YAML);
        phoenix_assert(daemon.isDaemonExist("other"));
        BaseDaemon daemon2;
        PHOENIX_EXCEPTION_TYPE_ASSERT(Phoenix::ConfigException, daemon2.load(ymlString, "not_in_in_the_list", ConfigFormat::YAML));
}


void testBaseDaemonLoadConfigJson(const PPath & fileName){
        BaseDaemon daemon;
        phoenix_assert(daemon.load(fileName, "main"));
        phoenix_assert(daemon.isDaemonExist("other"));
        BaseDaemon daemon2;
        PHOENIX_EXCEPTION_TYPE_ASSERT(Phoenix::ConfigException, daemon2.load(fileName, "not_in_in_the_list"));
        BaseDaemon daemon3;
        PHOENIX_EXCEPTION_TYPE_ASSERT(Phoenix::ParserException, daemon3.load(PPath("unexisting_config.json"), "main"));
        BaseDaemon daemon4;
        PHOENIX_EXCEPTION_TYPE_ASSERT(Phoenix::ParserException, daemon4.load(PPath("file.nonextension"), "main"));
}


void testBaseDaemonLoadConfigJsonString(const PPath & fileName){
        // Read json file in a string
        PString jsonString = fileName.loadFileContent();
        BaseDaemon daemon;
        daemon.load(jsonString, "main", ConfigFormat::JSON);
        phoenix_assert(daemon.isDaemonExist("other"));
        BaseDaemon daemon2;
        PHOENIX_EXCEPTION_TYPE_ASSERT(Phoenix::ConfigException, daemon2.load(jsonString, "not_in_in_the_list", ConfigFormat::JSON));
}


void testBaseDaemonParseArgument(const char* configFile, const char* daemonName) {
        const char* argv[] = {
                "phoenix_daemon",
                "--daemonconfig", configFile,
                "--daemonname", daemonName
        };
        int argc = sizeof(argv) / sizeof(argv[0]);
        BaseDaemon daemon;
        phoenix_assert(daemon.parseArgument(argc, const_cast<char**>(argv)));
        daemon.stop();
        phoenix_assert(daemon.isDaemonExist("other"));
}

void testUpdateStatAccumulator(){
        BaseDaemon daemon;
        StatAccumulator stat;
        stat.setHistLowerBound(0.0f);
        stat.setHistUpperBound(10.0f);
        stat.setVecHistogram(std::vector<size_t>(5, 0lu)); //5 bins
        
        daemon.updateStatAccumulator(stat, 2.0f);
        phoenix_assert(stat.getNbEvent() == 1lu);
        phoenix_assert(stat.getMin() == 2.0f);
        phoenix_assert(stat.getMax() == 2.0f);
        phoenix_assert(stat.getSum() == 2.0f);
        phoenix_assert(stat.getVecHistogram()[1] == 1lu); //bin size = 2.0, so 2.0 goes to bin 1
 
        daemon.updateStatAccumulator(stat, 8.0f);
        phoenix_assert(stat.getNbEvent() == 2lu);
        phoenix_assert(stat.getMin() == 2.0f);
        phoenix_assert(stat.getMax() == 8.0f);
        phoenix_assert(stat.getSum() == 10.0f);
        phoenix_assert(stat.getVecHistogram()[4] == 1lu); //8.0 goes to bin 4
 
        daemon.updateStatAccumulator(stat, -1.0f); //below lower bound
        phoenix_assert(stat.getNbEvent() == 3lu);
        phoenix_assert(stat.getNbEventBelowLowerBound() == 1lu);
 
        daemon.updateStatAccumulator(stat, 12.0f); //above upper bound
        phoenix_assert(stat.getNbEvent() == 4lu);
        phoenix_assert(stat.getNbEventAboveUpperBound() == 1lu);
}

void testClearStatAccumulator(){
        BaseDaemon daemon;
        StatAccumulator stat;
        stat.setHistLowerBound(0.0f);
        stat.setHistUpperBound(10.0f);
        stat.setVecHistogram(std::vector<size_t>(5, 0lu)); //5 bins
 
        daemon.getConfig().getDaemonStatAccumulator().getMapStatComputing()["stat_name"] = stat;
        daemon.getConfig().getDaemonStatAccumulator().getMapStatCommunication()["daemon_name"]["stat_name"] = stat;
 
        phoenix_assert(!daemon.getConfig().getDaemonStatAccumulator().getMapStatComputing().empty());
        phoenix_assert(!daemon.getConfig().getDaemonStatAccumulator().getMapStatCommunication().empty());
 
        daemon.clearStat();
        for(MapStatAccumulator::const_iterator it = daemon.getConfig().getDaemonStatAccumulator().getMapStatComputing().begin();
                it != daemon.getConfig().getDaemonStatAccumulator().getMapStatComputing().end(); ++it)
        {
                phoenix_assert(it->second.getNbEvent() == 0lu);
                for(std::vector<size_t>::const_iterator vit = it->second.getVecHistogram().begin();
                        vit != it->second.getVecHistogram().end(); ++vit) {
                        phoenix_assert(*vit == 0lu);
                }
        }
        for(MapDaemonStatAccumulator::const_iterator itMap = daemon.getConfig().getDaemonStatAccumulator().getMapStatCommunication().begin();
                itMap != daemon.getConfig().getDaemonStatAccumulator().getMapStatCommunication().end(); ++itMap)
        {
                for(MapStatAccumulator::const_iterator it = itMap->second.begin(); it != itMap->second.end(); ++it) {
                        phoenix_assert(it->second.getNbEvent() == 0lu);
                        for(std::vector<size_t>::const_iterator vit = it->second.getVecHistogram().begin();
                                vit != it->second.getVecHistogram().end(); ++vit) {
                                phoenix_assert(*vit == 0lu);
                        }
                }
        }
}


StatAccumulator createTestStatAccumulator() {
        StatAccumulator stat;
        stat.setNbEvent(4lu);
        stat.setMin(2.0f);
        stat.setMax(8.0f);
        stat.setSum(20.0f);
        stat.setNbEventBelowLowerBound(1lu);
        stat.setNbEventAboveUpperBound(1lu);
        stat.setHistLowerBound(0.0f);
        stat.setHistUpperBound(10.0f);
        stat.setVecHistogram(std::vector<size_t>(5, 0lu));
        stat.getVecHistogram()[1] = 1lu; //bin for 2.0
        stat.getVecHistogram()[4] = 1lu; //bin for 8.0
        return stat;
}

class TestBaseDaemon : public BaseDaemon{
        public:
                using BaseDaemon::fillVecStat;
                using BaseDaemon::fillDaemonStat;
};

void testFillVecStat(){
        TestBaseDaemon daemon;
        StatAccumulator stat = createTestStatAccumulator();
        time_t startTime = 1000lu;
        time_t endTime = 2000lu;
        
        VecStat vecStat = daemon.fillVecStat(stat, startTime, endTime);
        phoenix_assert(vecStat.getNbEvent().size() == 1lu);
        phoenix_assert(vecStat.getNbEvent()[0] == 4lu);
        phoenix_assert(vecStat.getMin().size() == 1lu);
        phoenix_assert(vecStat.getMin()[0] == 2.0f);
        phoenix_assert(vecStat.getMax().size() == 1lu);
        phoenix_assert(vecStat.getMax()[0] == 8.0f);
        phoenix_assert(vecStat.getAverage().size() == 1lu);
        phoenix_assert(vecStat.getAverage()[0] == 5.0f); //20.0 / 4
 
        phoenix_assert(vecStat.getStartTimestamp().size() == 1lu);
        phoenix_assert(vecStat.getStartTimestamp()[0] == startTime);
        phoenix_assert(vecStat.getEndTimestamp().size() == 1lu);
        phoenix_assert(vecStat.getEndTimestamp()[0] == endTime);
        phoenix_assert(vecStat.getRate().size() == 1lu);
        phoenix_assert(vecStat.getRateEventBelowLowerBound().size() == 1lu);
        phoenix_assert(vecStat.getRateEventAboveUpperBound().size() == 1lu);
        phoenix_assert(vecStat.getVecRateQuantile().size() == 5lu);
}

void testFillDaemonStat(){
        TestBaseDaemon daemon;
        StatAccumulator stat1 = createTestStatAccumulator();
        daemon.getConfig().getDaemonStatAccumulator().getMapStatComputing()["stat1"] = stat1;
        StatAccumulator stat2 = createTestStatAccumulator();
        daemon.getConfig().getDaemonStatAccumulator().getMapStatCommunication()["other"]["stat2"] = stat2;
 
        Stat daemonStat;
        time_t startTime = 1000lu;
        time_t endTime = 2000lu;
        daemon.fillDaemonStat(daemonStat, startTime, endTime);
 
        phoenix_assert(daemonStat.getMapStatComputing().find("stat1") != daemonStat.getMapStatComputing().end());
        phoenix_assert(daemonStat.getMapStatCommunication().find("other") != daemonStat.getMapStatCommunication().end());
        phoenix_assert(daemonStat.getMapStatCommunication()["other"].find("stat2") != daemonStat.getMapStatCommunication()["other"].end());
        phoenix_assert(daemonStat.getMapStatComputing().find("bad_stat") == daemonStat.getMapStatComputing().end());
}
 
int main(int argc, char** argv){
        
        testBaseDaemonMissingDaemonSectionTomlString();
        testBaseDaemonMissingDaemonSectionYmlString();
        testBaseDaemonMissingDaemonSectionJsonString();
        
        testBaseDaemonMissingDaemonSectionTomlFile();
        testBaseDaemonMissingDaemonSectionYmlFile();
        testBaseDaemonMissingDaemonSectionJsonFile();
        
        testBaseDaemonLoadConfigToml(PPath(DAEMON_CONFIG_OK_TOML));
        testBaseDaemonLoadConfigTomlString(PPath(DAEMON_CONFIG_OK_TOML));
        testBaseDaemonLoadConfigYml(PPath(DAEMON_CONFIG_OK_YAML));
        testBaseDaemonLoadConfigYmlString(PPath(DAEMON_CONFIG_OK_YAML));
        testBaseDaemonLoadConfigJson(PPath(DAEMON_CONFIG_OK_JSON));
        testBaseDaemonLoadConfigJsonString(PPath(DAEMON_CONFIG_OK_JSON));
        testBaseDaemonParseArgument(DAEMON_CONFIG_OK_TOML, "main");
        testBaseDaemonProcessConfirmedMessage(PPath(DAEMON_CONFIG_OK_TOML));
        testBaseDaemonGetMessageToConfirm();
        testUpdateStatAccumulator();
        testClearStatAccumulator();
        testFillVecStat();
        testFillDaemonStat();
        return 0;
}