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 "PFileParser.h"
 
void testPFileParserPartern(){
        PFileParser parser;
        parser.setFileContent("Les GPUs\\dots{} pour quoi faire ?}\\label{chapGPU}\n");
        
        PString res(parser.getUntilKeyWithoutPatern("}"));
        phoenix_assert(phoenix_check("testPFileParserPartern", res, "Les GPUs\\dots{"));
}
 
void testPFileParserParternExclude(){
        PFileParser parser;
        parser.setFileContent("Les GPUs\\dots{} pour quoi faire ?}\\label{chapGPU}\n");
        
        PString res(parser.getUntilKeyWithoutPaternExclude("}", "{"));
        phoenix_assert(phoenix_check("testPFileParserParternExclude", res, "Les GPUs\\dots{} pour quoi faire ?"));
}
 
void testPFileParserParternRecurse(){
        PFileParser parser;
        parser.setFileContent("Les GPUs\\dots{} pour quoi faire ?}\\label{chapGPU}\n");
        
        PString res(parser.getUntilKeyWithoutPaternRecurse("}", "{"));
        phoenix_assert(phoenix_check("testPFileParserParternRecurse", res, "Les GPUs\\dots{} pour quoi faire ?"));
}
 
void testPFileParserParternRecurse2(){
        PFileParser parser;
        parser.setFileContent("des trucs \"a dire\" et d'autres chose");
        
        PString res(parser.getUntilKeyWithoutPaternRecurse("\"", "\""));
        phoenix_assert(phoenix_check("testPFileParserParternRecurse2", res, "des trucs "));
}
 
void testPFileParserParternRecurseAllowChar(){
        PFileParser parser;
        parser.setFileContent("Les GPUs\\dots{} pour quoi faire ?}\\label{chapGPU}\n");
        
        PString res(parser.getUntilKeyWithoutPaternRecurse("}", "{", "} \\abcdefhijklmnopqrstuvwxyz"));
        phoenix_assert(phoenix_check("testPFileParserParternRecurseAllowChar", res, "Les GPUs\\dots{} pour quoi faire ?"));
}
 
void testPFileParserParternRecurseExcludeEnd(){
        PFileParser parser;
        parser.setFileContent("des trucs \\\"a\\\" dire\" et d'autres chose");
        
        PString res(parser.getUntilKeyWithoutPaternRecurseExclude("\"", "\"", "\\"));
        phoenix_assert(phoenix_check("testPFileParserParternRecurseExcludeEnd", res, "des trucs \\\"a\\\" dire"));
}
 
void testPFileParserParternRecurseExcludeEnd2(){
        PFileParser parser;
        parser.setFileContent("des trucs \"a dire\" et d'autres chose");
        
        PString res(parser.getUntilKeyWithoutPaternRecurseExclude("\"", "\"", "\\"));
        phoenix_assert(phoenix_check("testPFileParserParternRecurseExcludeEnd2", res, "des trucs "));
}
 
void testPFileParserSeq(){
        PParseSeq seq;
                PParseStep stepBegin;
                stepBegin.setIsOptional(false);
                        PParseCmd cmdBegin;
                        cmdBegin.setIsMatch(true);
                        cmdBegin.setStr("\\begin");
                stepBegin.getVecCmd().push_back(cmdBegin);
        seq.getVecStep().push_back(stepBegin);
                PParseStep stepOpenBrace;
                        stepOpenBrace.setIsOptional(false);
                        PParseCmd cmdOpenBrace;
                        cmdOpenBrace.setIsMatch(true);
                        cmdOpenBrace.setStr("{");
                stepOpenBrace.getVecCmd().push_back(cmdOpenBrace);
        seq.getVecStep().push_back(stepOpenBrace);
                PParseStep stepEnvName;
                        stepEnvName.setIsOptional(false);
                        PParseCmd cmdEnvName;
                        cmdEnvName.setIsMatch(true);
                        cmdEnvName.setStr("envName");
                stepEnvName.getVecCmd().push_back(cmdEnvName);
        seq.getVecStep().push_back(stepEnvName);
                PParseStep stepEndBrace;
                        stepEndBrace.setIsOptional(false);
                        PParseCmd cmdEndBrace;
                        cmdEndBrace.setIsMatch(true);
                        cmdEndBrace.setStr("}");
                stepEndBrace.getVecCmd().push_back(cmdEndBrace);
        seq.getVecStep().push_back(stepEndBrace);
        
        PFileParser parser;
        parser.setFileContent("\\begin { envName } des trucs\n");
        PString res = parser.isMatch(seq);
        phoenix_assert(phoenix_check("testPFileParserSeq", res, "\\begin{envName}"));
}
 
void testPFileParserMatchSeq(){
        PVecString vecPatern;
        vecPatern.push_back("\\begin");
        vecPatern.push_back("{");
        vecPatern.push_back("envName");
        vecPatern.push_back("}");
        
        PFileParser parser;
        parser.setFileContent("\\begin { envName } des trucs\n");
        phoenix_assert(parser.isMatchSeq(vecPatern));
}
 
 
void testPFileParserSeqOneStep(){
        PParseSeq seq;
                PParseStep step;
                step.setIsOptional(false);
                        PParseCmd cmdBegin;
                        cmdBegin.setIsMatch(true);
                        cmdBegin.setStr("\\begin");
                step.getVecCmd().push_back(cmdBegin);
                        PParseCmd cmdEnvName;
                        cmdEnvName.setIsMatch(true);
                        cmdEnvName.setStr("envName");
                step.getVecCmd().push_back(cmdEnvName);
                        PParseCmd cmdEndBrace;
                        cmdEndBrace.setIsMatch(true);
                        cmdEndBrace.setStr("}");
                step.getVecCmd().push_back(cmdEndBrace);
        seq.getVecStep().push_back(step);
 
        PFileParser parser;
        parser.setFileContent("\\begin { envName } des trucs\n");
        PString res = parser.isMatch(seq);
        phoenix_assert( phoenix_check("testPFileParserSeqOneStep", res, "\\begin"));
}
 
void testPFileParserIsMatch(){
        PFileParser parser;
        parser.setFileContent(" Les GPUs\\dots{} pour quoi faire ?}\\label{chapGPU}\n");
        phoenix_assert(!parser.isMatch("Autre"));
        phoenix_assert(parser.isMatch("Les"));
        phoenix_assert(parser.isMatch("GPU"));
}
 
 
bool testPFileParserGetUntilKey(const PString & inputStr, const PString & search, const PString & result){
        bool b(true);
        PFileParser parser2;
        parser2.setFileContent(inputStr);
        
        PString strFound(parser2.getUntilKey(search));
//      std::cout << "testPFileParserGetUntilKey : inputStr = '" << inputStr << "', search = '"<<search<<"', strFound = '" << strFound << "', expectedResult = '" << result << "'" << std::endl;
        
        b &= phoenix_check("testPFileParserGetUntilKey", strFound, result);
//      phoenix_functionOk("testPFileParserGetUntilKey", b);
        return b;
}
 
void testNextChar(){
        PFileParser parser;
        parser.setFileContent("hello");
        
        phoenix_assert(parser.getCurrentCh() == 'h');
        phoenix_assert(parser.getNextChar() == 'e');
        phoenix_assert(parser.getNextChar() == 'l');
        phoenix_assert(parser.getNextChar() == 'l');
        phoenix_assert(parser.getNextChar() == 'o');
}
 
void testPFileParserBase(){
        PFileParser parser;
        parser.setFileContent("e :e");
        parser.setSeparator(":");
        parser.setWhiteSpace(" ");
        parser.setLocation(PLocation(PPath("fileName"), 42, 23));
        parser.setLine(24);
        parser.setColumn(2);
        parser.popPosition();
        parser.getEscapeChar();
        parser.getFileName();
        parser.clear();
        
        phoenix_assert(!parser.isChSpace());
        phoenix_assert(!parser.isChSeparator());
        std::cout << "testPFileParserBase : next char '" << parser.getNextChar() << "'" << std::endl;
        phoenix_assert(parser.isChSpace());
        std::cout << "testPFileParserBase : next char '" << parser.getNextChar() << "'" << std::endl;
        phoenix_assert(parser.isChSeparator());
        std::cout << "testPFileParserBase : next char '" << parser.getNextChar() << "'" << std::endl;
        phoenix_assert(!parser.isChSpace());
        phoenix_assert(!parser.isChSeparator());
}
 
void testPFileParserGetCurrentRow(){
        PFileParser parser;
        parser.setFileContent("one row\none other row");
        phoenix_assert(parser.getCurrentRow() == "one row");
}
 
void testPFileParserVecIsMatch(){
        PFileParser parser;
        parser.setFileContent("one row\none other row");
        
        std::vector<PString> vecToken;
        phoenix_assert(parser.isMatch(vecToken) == "");
        vecToken.push_back("other");
        phoenix_assert(parser.isMatch(vecToken) == "");
        vecToken.push_back("one");
        phoenix_assert(parser.isMatch(vecToken) == "one");
}
 
void testPFileParserVecIsMatchToken(){
        PFileParser parser;
        parser.setFileContent("one row\none other row");
        
        std::vector<PString> vecToken;
        phoenix_assert(parser.isMatchToken(vecToken) == "");
        vecToken.push_back("other");
        phoenix_assert(parser.isMatchToken(vecToken) == "");
        vecToken.push_back("one");
        phoenix_assert(parser.isMatchToken(vecToken) == "one");
}
 
void testPFileParserMapIsMatchToken(){
        PFileParser parser;
        parser.setFileContent("one row\none other row");
        
        std::map<PString, int> mapToken;
        PString matchKey("");
        int matchValue(0);
        phoenix_assert(!parser.isMatchToken(matchKey, matchValue, mapToken));
        mapToken["other"] = 23;
        phoenix_assert(!parser.isMatchToken(matchKey, matchValue, mapToken));
        
        mapToken["one"] = 1;
        phoenix_assert(parser.isMatchToken(matchKey, matchValue, mapToken));
        phoenix_assert(matchKey == "one");
        phoenix_assert(matchValue == 1);
}
 
void testPFileParserVecVecIsMatch(){
        PFileParser parser;
        parser.setFileContent("one row\none other row");
        
        std::vector<std::vector<PString> > patern;
        phoenix_assert(parser.isMatch(patern) == "");
        PVecString vecPatern;
        vecPatern.push_back("other");
        patern.push_back(vecPatern);
        phoenix_assert(parser.isMatch(patern) == "");
        vecPatern.push_back("one");
        patern.push_back(vecPatern);
        phoenix_assert(parser.isMatch(patern) == "one");
        phoenix_assert(parser.isWhiteSpace());
        phoenix_assert(parser.getSeparator() != "");
        phoenix_assert(parser.getCurrentCh() == 'r');
        phoenix_assert(parser.getPrevCh() == ' ');
        phoenix_assert(parser.getLine() == 1lu);
        phoenix_assert(parser.getCurrentCharIdx() == 4lu);
        std::cout << parser << std::endl;
}
 
void testPFileParserGetNextToken(){
        PFileParser parser;
        parser.setFileContent("e : e");
        parser.setWhiteSpace(" ");
        parser.setSeparator(":");
        
        PString token1(parser.getNextToken());
        phoenix_assert(token1 == "e");
//      std::cout << "testPFileParserGetNextToken : b = " << b << ", token1 = '" << token1 << "'" << std::endl;
        PString token2(parser.getNextToken());
        phoenix_assert(token2 == ":");
//      std::cout << "testPFileParserGetNextToken : b = " << b << ", token2 = '" << token2 << "'" << std::endl;
        PString token3(parser.getNextToken());
        phoenix_assert(token3 == "e");
//      std::cout << "testPFileParserGetNextToken : b = " << b << ", token3 = '" << token3 << "'" << std::endl;
        phoenix_assert(parser.getNextToken() == "");
}
 
void testPFileParserGetNextToken2(){
        PFileParser parser;
        parser.setFileContent("e : e");
        parser.setWhiteSpace(" ");
        parser.setSeparator(":");
        
        PString skippedStr("");
        PString token1(parser.getNextToken(skippedStr));
        phoenix_assert(token1 == "e");
//      std::cout << "testPFileParserGetNextToken2 : b = " << b << ", token1 = '" << token1 << "'" << std::endl;
        phoenix_assert(skippedStr == "");
//      std::cout << "testPFileParserGetNextToken2 : b = " << b << ", skippedStr = '" << skippedStr << "'" << std::endl;
        
        skippedStr = "";
        PString token2(parser.getNextToken(skippedStr));
        phoenix_assert(token2 == ":");
//      std::cout << "testPFileParserGetNextToken2 : b = " << b << ", token2 = '" << token2 << "'" << std::endl;
        phoenix_assert(skippedStr == " ");
//      std::cout << "testPFileParserGetNextToken2 : b = " << b << ", skippedStr = '" << skippedStr << "'" << std::endl;
        
        skippedStr = "";
        PString token3(parser.getNextToken(skippedStr));
        phoenix_assert(token3 == "e");
//      std::cout << "testPFileParserGetNextToken2 : b = " << b << ", token3 = '" << token3 << "'" << std::endl;
        phoenix_assert(skippedStr == " ");
//      std::cout << "testPFileParserGetNextToken2 : b = " << b << ", skippedStr = '" << skippedStr << "'" << std::endl;
        phoenix_assert(parser.getNextToken(skippedStr) == "");
}
 
int main(int argc, char** argv){
        testPFileParserPartern();
        testPFileParserParternExclude();
        testPFileParserParternRecurse();
        testPFileParserParternRecurse2();
        testPFileParserParternRecurseAllowChar();
        testPFileParserParternRecurseExcludeEnd();
        testPFileParserParternRecurseExcludeEnd2();
        testPFileParserSeq();
        testPFileParserMatchSeq();
        testPFileParserSeqOneStep();
        testPFileParserIsMatch();
        testNextChar();
        testPFileParserBase();
        
        phoenix_assert(testPFileParserGetUntilKey("let's test a string", "", ""));
        phoenix_assert(testPFileParserGetUntilKey("let's test a string", "some", "let's test a stringsome"));
        phoenix_assert(testPFileParserGetUntilKey("let's test a string", "test", "let's test"));
        
        testPFileParserGetCurrentRow();
        testPFileParserVecIsMatch();
        testPFileParserVecIsMatchToken();
        testPFileParserMapIsMatchToken();
        testPFileParserVecVecIsMatch();
        testPFileParserGetNextToken();
        testPFileParserGetNextToken2();
        return 0;
}