saveClassConfigTest.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#include "header_generator.h"
#include "cmakelist_generator.h"
#include "saveClassConfig.h"
#include "saveClassConfigTest.h"
 
 
PString getTestDefaultValueTypeInCpp(const PString & type){
        if(type == "PString"){
                return "\"Some string\"";
        }else if(type == "char"){
                return "8";
        }else if(type == "unsigned char"){
                return "32";
        }else if(type == "int" || type == "short" || type == "unsigned short"){
                return "42";
        }else if(type == "unsigned int"){
                return "32u";
        }else if(type == "long int" || type == "long" || type == "ssize_t"){
                return "328l";
        }else if(type == "size_t" || type == "long unsigned int"){
                return "3423420lu";
        }else if(type == "bool"){
                return "true";
        }else{
                return "";
        }
}
 
 
PString createCheckClassEquality(const PClassConfig & classConfig, bool isConst){
        PString body(""), name(classConfig.getName()), strConst("");
        if(isConst){
                strConst = "const ";
        }
        body += "///Check the equality between two "+name+" classes\n";
        body += "/**\t@param var : variable to be checked\n";
        body += " * \t@param reference : reference\n";
        body += " * \t@return true on success, false otherwise\n";
        body += "*/\n";
        body += "bool check"+name+"Equality";
        if(isConst){
                body += "Const";
        }
        body += "(" + strConst + name + " & var, " + strConst + name + " & reference){\n";
        body += "\tbool b(true);\n";
        
        const std::vector<PClassAttribute> & listAttr = classConfig.getListAttribute();
        for(std::vector<PClassAttribute>::const_iterator it(listAttr.begin()); it != listAttr.end(); ++it){
                PString attrName(it->getName().firstToUpper());
                bool isSimpleType = getIsSimpleType(it->getType());
                std::cout << "createCheckClassEquality : attrName = '"<<attrName<<"', isSimpleType = " << isSimpleType << ", it->getIsPointer() = " << it->getIsPointer() << ", it->getIsReference() = " << it->getIsReference() << std::endl;
                if(isSimpleType || it->getIsPointer() || it->getType() == "PString"){
                        body += "\tb &= var.get"+attrName+"() == reference.get"+attrName+"();\n";
                }
        }
        
        body += "\treturn b;\n";
        body += "}\n\n";
        return body;
}
 
 
PString createTestClassCopy(const PClassConfig & classConfig, bool enableTypeStream){
        PString body (""), name(classConfig.getName());
        
        body += "///Check copy of class "+name+"\n";
        body += "bool check"+name+"Copy(){\n";
        
        body += "\t"+name+" reference;\n";
        body += "\t//Let's use the setters\n";
        const std::vector<PClassAttribute> & listAttr = classConfig.getListAttribute();
        for(std::vector<PClassAttribute>::const_iterator it(listAttr.begin()); it != listAttr.end(); ++it){
                PString defaultValue(getTestDefaultValueTypeInCpp(it->getType())), attrName(it->getName().firstToUpper());;
                if(defaultValue != ""){
                        body += "\treference.set"+attrName+"("+defaultValue+");\n";
                }
        }
        
        body += "\t"+name+" varCopy(reference);\n";
        body += "\t"+name+" varEqual;\n";
        body += "\tvarEqual = reference;\n";
        body += "\tbool b(true);\n";
        body += "\tb &= check"+name+"Equality(varCopy, reference);\n";
        body += "\tb &= check"+name+"EqualityConst(varCopy, reference);\n";
        
        body += "\tb &= check"+name+"Equality(varEqual, reference);\n";
        body += "\tb &= check"+name+"EqualityConst(varEqual, reference);\n";
        body += "\tb &= phoenix_getTypeToStr<"+name+">() == \""+name+"\";\n";
        
        body += "\treturn b;\n";
        body += "}\n\n";
        
        return body;
}
 
 
 
bool saveClassTestMain(const PPath & outputCurrentTestDir, const PClassConfig & classConfig, const PPath & baseFileName, bool enableDataStream, bool enableTypeStream){
        PString body(""), name(classConfig.getName());
        body += licenceSaveStr() + "\n";
        
        body += "#include \"" + (baseFileName + ".h\"\n\n");
        
        body += createCheckClassEquality(classConfig, false);
        body += createCheckClassEquality(classConfig, true);
        
        body += createTestClassCopy(classConfig, enableTypeStream);
        
        body += "int main(int argc, char ** argv){\n";
        body += "\tbool b(check"+name+"Copy());\n";
        
        //Do other test if the enableDataStream is true
        
        body += "\treturn b - 1;\n";
        body += "}\n";
        
        return PPath(outputCurrentTestDir + PString("/main.cpp")).saveFileContent(body);
}
 
 
bool saveClassTestCMakeLists(const PPath & outputCurrentTestDir, const PString & libName, const PClassConfig & classConfig, bool enableDataStream, bool enableTypeStream){
        PString body(""), testName("test_class_" + classConfig.getName().toLowerUnderscore());
        body += getCMakeListsHeader();
        body += "add_executable("+testName+" main.cpp)\n";
        PString extraLib;
        extraLib += " " + libName;
        if(enableTypeStream){
                extraLib += " phoenix_type_stream";
        }
        if(enableDataStream){
                extraLib += " phoenix_data_stream";
        }
        if(extraLib.size() != 0lu){
                body += "target_link_libraries("+testName+extraLib+")\n";
        }
        body += "\n";
        body += "add_test(NAME "+testName.firstToUpper()+"\n";
        body += "\tCOMMAND ${CMAKE_CURRENT_BINARY_DIR}/"+testName+"\n";
        body += "\tWORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}\n";
        body += ")\n\n\n";
        
        return PPath(outputCurrentTestDir + PString("/CMakeLists.txt")).saveFileContent(body);
}
 
 
bool saveClassTest(const PPath & outputTestDir, const PString & libName, const PClassConfig & classConfig, const PPath & baseFileName, bool enableDataStream, bool enableTypeStream){
        PString name(classConfig.getName());
        PPath outputCurrentTestDir(outputTestDir + PString("/TEST_") + name.toUpper());
        if(!outputCurrentTestDir.createDirectory()){std::cerr << "saveClassTest : cannot create TEST directory '"<<outputCurrentTestDir<<"'" << std::endl;return false;}
        
        bool b(true);
        b &= saveClassTestCMakeLists(outputCurrentTestDir, libName, classConfig, enableDataStream, enableTypeStream);
        b &= saveClassTestMain(outputCurrentTestDir, classConfig, baseFileName, enableDataStream, enableTypeStream);
        
        return b;
}
 
 
 
bool saveClassTest(const PPath & outputTestDir, const PString & libName, const std::vector<PClassConfig> & classConfig, const PPath & baseFileName, bool enableDataStream, bool enableTypeStream){
        bool b(true);
        for(std::vector<PClassConfig>::const_iterator it(classConfig.begin()); it != classConfig.end(); ++it){
                b &= saveClassTest(outputTestDir, libName, *it, baseFileName, enableDataStream, enableTypeStream);
        }
        return b;
}