wrapper_test.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#include "cmakelist_generator.h"
#include "type_utils.h"
#include "wrapper_test.h"


PString pythonGetDefaultTestValue(PString & type){
        if(type == "int" || type == "long" || type == "long int" || type == "size_t" || type == "unsigned int" || type == "unsigned short" || type == "char" || type == "unsigned char" || type == "long unsigned int"){
                return "42";
        }else if(type == "float" || type == "double"){
                return "42.0";
        }else if(type == "std::string"){
                return "\"Shadoko\"";
        }else if(type == "DataStreamMsg"){
                return "bytearray(b\"Shadoko\")";
        }else if(generator_typeIsList(type)){
                PString nestedType(generator_getListNestedType(type));
                PString nestedDefaultValue(pythonGetDefaultTestValue(nestedType));
                if(nestedDefaultValue != ""){
                        return "["+nestedDefaultValue+"]";
                }else{
                        return "[]";
                }
        }
        
        return "";
}


PString pythonDefaultTestValue(const PString & varName, const PClassAttribute & attr, const PString & moduleName, const PString & indentation,
                        const std::map<std::string, PClassConfig> & mapClass)
{
        PString type(attr.getType());
        PString body(indentation);
        
        PString initValue(pythonGetDefaultTestValue(type));
        if(initValue != ""){
                body += varName + "." + attr.getName() + " = "+initValue+"\n";
        }else if(attr.getIsEnum()){
                std::map<std::string, PClassConfig>::const_iterator it(mapClass.find(type));
                if(it != mapClass.end()){
                        //Let's take the last value so we are sure this is not a 0 or a default value
                        body += varName + "." + attr.getName() + " = "+moduleName+"."+type+"."+it->second.getListAttribute().back().getName()+"\n";
                }
        }else{
                return "";
        }
        return body;
}


PString pythonAssertTestValue(const PString & varName, const PClassAttribute & attr, const PString & moduleName, const PString & indentation,
                        const std::map<std::string, PClassConfig> & mapClass)
{
        PString type(attr.getType());
        PString body(indentation);
        
        PString initValue(pythonGetDefaultTestValue(type));
        if(initValue != ""){
                body += "assert " + varName + "." + attr.getName() + " == "+initValue+"\n";
        }else if(attr.getIsEnum()){
                std::map<std::string, PClassConfig>::const_iterator it(mapClass.find(type));
                if(it != mapClass.end()){
                        body += "assert " + varName + "." + attr.getName() + ".value == "+moduleName+"."+type+"."+it->second.getListAttribute().back().getName()+".value\n";
                }
        }else{
                return "";
        }
        return body;
}


bool project_wrapper_classTest(const PPath & testDirectory, const PString & moduleName, const PClassConfig & classConfig,
                        const std::map<std::string, PClassConfig> & mapClass)
{
        PString body, className(classConfig.getName());
        body += "\n";
        body += getCMakeListsHeader();
        body += "\n";
        if(!classConfig.getIsEnum()){
                body += "import "+moduleName+"\n";
        }
        body += "from "+moduleName+" import "+className+"\n";
        body += "\n";
        body += "#Unit Test of the " + className + "\n";
        body += "def test_"+className+"():\n";
        body += "\tassert "+className+".getTypeName() == \"" + className + "\"\n";
        if(!classConfig.getIsEnum()){
                body += "\t#Let's test the stream now\n";
                body += "\tshadok = "+moduleName+"."+className+"()\n";
                const std::vector<PClassAttribute> & vecAttr = classConfig.getListAttribute();
                for(std::vector<PClassAttribute>::const_iterator it(vecAttr.begin()); it != vecAttr.end(); ++it){
                        body += pythonDefaultTestValue("shadok", *it, moduleName, "\t", mapClass);
                }
                body += "\tstream = shadok.toBytes()\n";
                body += "\tassert len(stream) != 0\n";
                body += "\t\n";
                body += "\tother = "+moduleName+"."+className+"()\n";
                body += "\tother.fromBytes(stream)\n";
                for(std::vector<PClassAttribute>::const_iterator it(vecAttr.begin()); it != vecAttr.end(); ++it){
                        body += pythonAssertTestValue("other", *it, moduleName, "\t", mapClass);
                }
                body += "\t\n";
                body += "\t\n";
                body += "\t\n";
                body += "\t\n";
                body += "\t\n";
        }
        
        PPath fileName(testDirectory / PPath("test_" + className + ".py"));
        return fileName.saveFileContent(body);
}
 


bool project_wrapper_allClassTest(const PPath & testDirectory, const PString & moduleName, const std::vector<PClassConfig> & vecClassConfig){
        bool b(true);
        std::map<std::string, PClassConfig> mapClass;
        for(std::vector<PClassConfig>::const_iterator it(vecClassConfig.begin()); it != vecClassConfig.end() && b; ++it){
                mapClass[it->getName()] = *it;
        }
        for(std::vector<PClassConfig>::const_iterator it(vecClassConfig.begin()); it != vecClassConfig.end() && b; ++it){
                b &= project_wrapper_classTest(testDirectory, moduleName, *it, mapClass);
        }
        return b;
}


bool project_wrapper_moduleGeneratorTest(const PPath & projectPath, const ProjectConfig & projectConfig, const PString & moduleName, const std::vector<PClassConfig> & vecClassConfig, const PVecPath & vecInclude){
        PPath testDirectory(projectPath / PPath("tests"));
        if(!testDirectory.createDirectory()){
                std::cerr << "project_wrapper_generator : cannot create unit tests directory of project '"<<testDirectory<<"'" << std::endl;
                return false;
        }
        if(!project_wrapper_allClassTest(testDirectory, moduleName, vecClassConfig)){return false;}
        
        
        return true;
}