main.cpp

Go to the documentation of this file.

 
/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#include "phoenix_assert.h"
#include "phoenix_check.h"
#include "DicoValue.h"
 
 
bool saveDico(const DicoValue & dv, const PPath & fileName){
        return dv.save(fileName.replace(".txt", ".dico").replace(CMAKE_CURRENT_TEST_DIR, CMAKE_CURRENT_BUILD_DIR));
}
 
 
bool checkConstDicoValue(const DicoValue & dico){
        bool b(true);
        b &= dico.getMap("NonExistingmap") == NULL;
        return b;
}
 
 
bool testDicoValue(const PPath & fileName){
        DicoValue dv;
        if(!dv.load(fileName)){
                std::cerr << "testDicoValue : cannot load file '"<<fileName<<"'" << std::endl;
                return false;
        }
        std::vector<DicoValue> & vecChild = dv.getVecChild();
        
        DicoValue & value = dv.getMapChild()["key"];
        bool b(true);
        b &= dv.getMap("NonExistingmap") == NULL;
        b &= checkConstDicoValue(dv);
        DicoValue dico;
        dico.setVecChild(dv.getVecChild());
        dico.setMapChild(dv.getMapChild());
        
        std::cout << "testDicoValue : value of key : '" << value.getValue() << "' with key '" << value.getKey() << "', vecChild.size = " << vecChild.size()  << std::endl;
        b &= value.getValue() == "value";
        b &= saveDico(dv, fileName);
        return b;
}
 
 
bool testDicoValueKey(const DicoValue & dv, int expectedValue){
//      std::cout << "testDicoValueKey : key '" << dv.getKey() << "' with value '" << dv.getValue() << "', hasKey = " << dv.hasKey() << "', hasMap = " << dv.hasMap()   << "', hasVec = " << dv.hasVec() << std::endl;
        return phoenix_check("testDicoValueKey", dv.getValue<int>(), expectedValue);
}
 
 
bool testDicoValue2(const PPath & fileName){
        DicoValue dv;
        if(!dv.load(fileName)){
                std::cerr << "testDicoValue2 : cannot load file '"<<fileName<<"'" << std::endl;
                return false;
        }
        bool b(testDicoValueKey(dv.getMapChild()["key1"], 1));
        b &= testDicoValueKey(dv.getMapChild()["key2"], 2);
        b &= testDicoValueKey(dv.getMapChild()["key3"], 3);
        b &= dv.isKeyExist("key3");
        
        b &= saveDico(dv, fileName);
        return b;
}
 
 
bool testDicoValueKeyPtr(const DicoValue * dv, int expectedValue){
        if(dv == NULL){
                std::cerr << "testDicoValueKeyPtr : DicoValue for value "<<expectedValue<<" not found!!!" << std::endl;
                return false;
        }
//      std::cout << "testDicoValueKeyPtr : key '" << dv->getKey() << "' with value '" << dv->getValue() << "'"  << std::endl;
        return dv->getValue<int>() == expectedValue;
}
 
 
bool testDicoValue3(const PPath & fileName){
        DicoValue dv;
        if(!dv.load(fileName)){
                std::cerr << "testDicoValue3 : cannot load file '"<<fileName<<"'" << std::endl;
                return false;
        }
        bool b(testDicoValueKeyPtr(dv.getMap("key1"), 1));
        b &= testDicoValueKeyPtr(dv.getMap("key2"), 2);
        b &= testDicoValueKeyPtr(dv.getMap("key3"), 3);
        b &= !testDicoValueKeyPtr(NULL, 0);
        b &= saveDico(dv, fileName);
        return b;
}
 
 
bool testDicoVecValueKeyPtr(const DicoValue * dv, int expectedValue){
        if(dv == NULL){
                std::cerr << "testDicoVecValueKeyPtr : DicoValue for value "<<expectedValue<<" not found!!!" << std::endl;
                return false;
        }
        const VecDicoValue & vecVal = dv->getVecChild();
        if(vecVal.size() != 3lu){
                std::cerr << "testDicoVecValueKeyPtr : expect 3 value for first value " << expectedValue << std::endl;
                return false;
        }
        bool b(true);
        for(int i(0); i < 3; ++i){
                std::cout << "testDicoVecValueKeyPtr : value["<<i<<"] = " << vecVal[i].getValue<int>() << ", expect = " << (i + expectedValue) << std::endl;
                b &= vecVal[i].getValue<int>() == expectedValue + i;
        }
        return b;
}
 
 
bool testDicoVecValue(const PPath & fileName){
        DicoValue dv;
        if(!dv.load(fileName)){
                std::cerr << "testDicoVecValue : cannot load file '"<<fileName<<"'" << std::endl;
                return false;
        }
        bool b(testDicoVecValueKeyPtr(dv.getMap("key1"), 1));
        b &= testDicoVecValueKeyPtr(dv.getMap("key2"), 2);
        b &= testDicoVecValueKeyPtr(dv.getMap("key3"), 3);
        b &= saveDico(dv, fileName);
        return b;
}
 
 
bool testDicoVecString(const PPath & fileName){
        DicoValue dv;
        if(!dv.load(fileName)){
                std::cerr << "testDicoVecString : cannot load file '"<<fileName<<"'" << std::endl;
                return false;
        }
        bool b(testDicoVecValueKeyPtr(dv.getMap("key1"), 1));
        b &= testDicoVecValueKeyPtr(dv.getMap("key2"), 2);
        b &= testDicoVecValueKeyPtr(dv.getMap("key3"), 3);
        
        b &= !testDicoVecValueKeyPtr(NULL, 0);
        DicoValue val;
        b &= !testDicoVecValueKeyPtr(&val, 0);
        
        b &= saveDico(dv, fileName);
        return b;
}
 
 
bool testDicoValueKey(const DicoValue * dv, int expectedValue){
        return phoenix_check("testDicoValueKey", dv->getValue<int>(), expectedValue);
}
 
 
bool testDicoDicoValueKeyPtr(const DicoValue * dv, int expectedValue){
        if(dv == NULL){
                std::cerr << "testDicoDicoValueKeyPtr : DicoValue for value "<<expectedValue<<" not found!!!" << std::endl;
                return false;
        }
        const MapDicoValue & mapVal = dv->getMapChild();
        if(mapVal.size() != 3lu){
                std::cerr << "testDicoDicoValueKeyPtr : expect 3 value for first value " << expectedValue << std::endl;
                return false;
        }
        bool b(true);
        b &= testDicoValueKey(dv->getMap("val1"), expectedValue);
        b &= testDicoValueKey(dv->getMap("val2"), 1 + expectedValue);
        b &= testDicoValueKey(dv->getMap("val3"), 2 + expectedValue);
        return b;
}
 
 
bool testDicoDicoString(const PPath & fileName){
        DicoValue dv;
        if(!dv.load(fileName)){
                std::cerr << "testDicoDicoString : cannot load file '"<<fileName<<"'" << std::endl;
                return false;
        }
        bool b(testDicoDicoValueKeyPtr(dv.getMap("key1"), 1));
        b &= testDicoDicoValueKeyPtr(dv.getMap("key2"), 2);
        b &= testDicoDicoValueKeyPtr(dv.getMap("key3"), 3);
        
        b &= !testDicoDicoValueKeyPtr(NULL, 0);
        DicoValue val;
        b &= !testDicoDicoValueKeyPtr(&val, 0);
        
        b &= saveDico(dv, fileName);
        return b;
}
 
 
bool testDicoGoodParsing(const PString & fileContent){
        PPath fileName("config.txt");
        bool b(true);
        b &= fileName.saveFileContent(fileContent);
        DicoValue dico;
        b &= dico.load(fileName);
        return b;
}
 
 
bool testDicoBadParsing(const PString & fileContent){
        PPath fileName("config.txt");
        bool b(true);
        b &= fileName.saveFileContent(fileContent);
        DicoValue dico;
        b &= !dico.load(fileName);
        return b;
}
 
 
bool testDicoSaveParsing(const PString & fileContent){
        PPath fileName("config_out.txt");
        bool b(true);
        DicoValue dico;
        dico.setValue(fileContent);
        b &= dico.save(fileName);
        return b;
}
 
void testFromJSonToJSon(){
        PPath fileName(CMAKE_CURRENT_TEST_DIR "/testInputDicoMapDico.json");
        
        DicoValue dv;
        phoenix_assert(dv.load(fileName));
        phoenix_assert(dv.save(fileName.getFileName(), "\""));
        
        DicoValue compact;
        phoenix_assert(compact.fromString("{\"key1\": \"1\", \"key2\": \"2\", \"key3\": \"3\" }"));
        phoenix_assert(phoenix_check("Test compact JSON", compact.toString("\"", "", ""), "{\"key1\": \"1\",\"key2\": \"2\",\"key3\": \"3\"}"));
}
 
int main(int argc, char** argv){
        PPath fileName0(CMAKE_CURRENT_TEST_DIR "/testInputDico.txt");
        
        phoenix_assert(testDicoValue(fileName0));
        phoenix_assert(!testDicoValue(PString(fileName0 + "whichDoesnotExist")));
        
        PPath fileName2(CMAKE_CURRENT_TEST_DIR "/testInputDicoValue.txt");
        phoenix_assert(testDicoValue2(fileName2));
        phoenix_assert(!testDicoValue2(PString(fileName2 + "whichDoesnotExist")));
        
        PPath fileName3(CMAKE_CURRENT_TEST_DIR "/testInputDicoValue.txt");
        phoenix_assert(testDicoValue3(fileName3));
        phoenix_assert(!testDicoValue3(PString(fileName3 + "whichDoesnotExist")));
        
        PPath fileNameVec(CMAKE_CURRENT_TEST_DIR "/testInputDicoVecValue.txt");
        phoenix_assert(testDicoVecValue(fileNameVec));
        phoenix_assert(!testDicoVecValue(PString(fileNameVec + "whichDoesnotExist")));
        
        PPath fileNameVecString(CMAKE_CURRENT_TEST_DIR "/testInputDicoVecString.txt");
        phoenix_assert(testDicoVecString(fileNameVecString));
        phoenix_assert(!testDicoVecString(PString(fileNameVecString + "whichDoesnotExist")));
        
        PPath fileNameDicoString(CMAKE_CURRENT_TEST_DIR "/testInputDicoMapDico.txt");
        phoenix_assert(testDicoDicoString(fileNameDicoString));
        phoenix_assert(!testDicoDicoString(PString(fileNameDicoString + "whichDoesnotExist")));
        
        //Test with a JSON
        phoenix_assert(testDicoDicoString(PPath(CMAKE_CURRENT_TEST_DIR "/testInputDicoMapDico.json")));
        
        phoenix_assert(testDicoBadParsing(""));
        phoenix_assert(testDicoGoodParsing("42"));
        phoenix_assert(testDicoGoodParsing("key other"));
        phoenix_assert(testDicoBadParsing("{  key1 {"));
        phoenix_assert(testDicoBadParsing("{  {"));
        phoenix_assert(testDicoBadParsing("{ °"));
        phoenix_assert(testDicoBadParsing("{  key1: °"));
        phoenix_assert(testDicoSaveParsing("Just some text"));
        phoenix_assert(testDicoSaveParsing("Just some text\nwith new line"));
        phoenix_assert(testDicoSaveParsing("Just some text with spécial char/"));
        testFromJSonToJSon();
        return 0;
}