main.cpp File Reference

#include <iostream>
#include <vector>
#include "phoenix_assert.h"
#include "phoenix_check.h"
#include "string_function.h"

Include dependency graph for main.cpp:

Go to the source code of this file.

Functions
bool	checkReplaceListStrInStr (const std::string &inputStr, const std::list< std::string > &vecPattern, const std::string &replace, const std::string &strReference)
	Check the replaceVectorStrInStr function. More...
bool	checkReplaceVectorStrInStr (const std::string &inputStr, const std::vector< std::string > &vecPattern, const std::string &replace, const std::string &strReference)
	Check the replaceVectorStrInStr function. More...
bool	checkString (const std::string &testName, const std::string &strValue, const std::string &strReference)
	Check string lower expression. More...
int	main (int argc, char **argv)
void	testCharToString ()
	Test the phoenix_charToString function. More...
void	testEscapeString ()
	Test the phoenix_escapeStr function. More...
void	testFindInListString ()
	Test the find in list string filename function. More...
void	testGetCommonBegning ()
	Test the phoenix_getCommonBegining function. More...
void	testReplaceListStrInStr ()
	Test the replaceVectorStrInStr function. More...
void	testReplaceStrInStrMap ()
	Test the replace of str in str with map. More...
void	testReplaceVectorStrInStr ()
	Test the replaceVectorStrInStr function. More...
void	testStringFunction ()
	Test the string filename function. More...

Function Documentation

checkReplaceListStrInStr()

bool checkReplaceListStrInStr	(	const std::string &	inputStr,
		const std::list< std::string > &	vecPattern,
		const std::string &	replace,
		const std::string &	strReference
	)

Check the replaceVectorStrInStr function.

Parameters

inputStr	: input string
vecPattern	: list of patterns
replace	: substitution string
strReference	: expected result

Returns

true on success, false otherwise

Definition at line 181 of file main.cpp.

{
        std::string res(replaceListStrInStr(inputStr, vecPattern, replace));
        return phoenix_check("", res, strReference);
}

References phoenix_check(), and replaceListStrInStr().

Referenced by testReplaceListStrInStr().

Here is the call graph for this function:

Here is the caller graph for this function:

checkReplaceVectorStrInStr()

bool checkReplaceVectorStrInStr	(	const std::string &	inputStr,
		const std::vector< std::string > &	vecPattern,
		const std::string &	replace,
		const std::string &	strReference
	)

Check the replaceVectorStrInStr function.

Parameters

inputStr	: input string
vecPattern	: vector of patterns
replace	: substitution string
strReference	: expected result

Returns

true on success, false otherwise

Definition at line 155 of file main.cpp.

{
        std::string res(replaceVectorStrInStr(inputStr, vecPattern, replace));
        return phoenix_check("", res, strReference);
}

References phoenix_check(), and replaceVectorStrInStr().

Referenced by testReplaceVectorStrInStr().

Here is the call graph for this function:

Here is the caller graph for this function:

checkString()

bool checkString	(	const std::string &	testName,
		const std::string &	strValue,
		const std::string &	strReference
	)

Check string lower expression.

Parameters

testName	: name of the test
strValue	: string to be tested
strReference	: reference string

Returns

true is both strings are equal, false otherwise

Definition at line 21 of file main.cpp.

                                                                                                        {
        return phoenix_check(testName, strValue, strReference);
}

References phoenix_check().

Here is the call graph for this function:

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 229 of file main.cpp.

                               {
        testStringFunction();
        testFindInListString();
        testReplaceVectorStrInStr();
        testReplaceListStrInStr();
        testReplaceStrInStrMap();
        testCharToString();
        testEscapeString();
        testGetCommonBegning();
        return 0;
}

References testCharToString(), testEscapeString(), testFindInListString(), testGetCommonBegning(), testReplaceListStrInStr(), testReplaceStrInStrMap(), testReplaceVectorStrInStr(), and testStringFunction().

Here is the call graph for this function:

testCharToString()

void testCharToString

(

)

Test the phoenix_charToString function.

Definition at line 210 of file main.cpp.

                       {
        phoenix_assert(phoenix_charToString("some string") == "some string");
        phoenix_assert(phoenix_charToString(NULL) == "");
}

References phoenix_assert, and phoenix_charToString().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

testEscapeString()

void testEscapeString

(

)

Test the phoenix_escapeStr function.

Definition at line 216 of file main.cpp.

                       {
        phoenix_assert(phoenix_check("", phoenix_escapeStr("some string with escape's \"char\"", " '\"", "\\"), "some\\ string\\ with\\ escape\\'s\\ \\\"char\\\""));
}

References phoenix_assert, phoenix_check(), and phoenix_escapeStr().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

testFindInListString()

void testFindInListString

(

)

Test the find in list string filename function.

Definition at line 26 of file main.cpp.

                           {
        std::list<std::string> listStrRef;
        phoenix_assert(!findInListString(listStrRef, ""));
        listStrRef.push_back("one");
        phoenix_assert(!findInListString(listStrRef, ""));
        phoenix_assert(!findInListString(listStrRef, "other"));
        phoenix_assert(findInListString(listStrRef, "one"));
        listStrRef.push_back("two");
        phoenix_assert(!findInListString(listStrRef, "other"));
        phoenix_assert(findInListString(listStrRef, "two"));
        listStrRef.push_back("three");
        phoenix_assert(!findInListString(listStrRef, "other"));
        phoenix_assert(findInListString(listStrRef, "two"));
        phoenix_assert(findInListString(listStrRef, "three"));
        
        std::vector<std::string> vecStrRef;
        phoenix_assert(!findInVectorString(vecStrRef, ""));
        vecStrRef.push_back("one");
        phoenix_assert(!findInVectorString(vecStrRef, ""));
        phoenix_assert(!findInVectorString(vecStrRef, "other"));
        phoenix_assert(findInVectorString(vecStrRef, "one"));
        vecStrRef.push_back("two");
        phoenix_assert(!findInVectorString(vecStrRef, "other"));
        phoenix_assert(findInVectorString(vecStrRef, "two"));
        vecStrRef.push_back("three");
        phoenix_assert(!findInVectorString(vecStrRef, "other"));
        phoenix_assert(findInVectorString(vecStrRef, "two"));
        phoenix_assert(findInVectorString(vecStrRef, "three"));
        
        phoenix_assert(eraseLastCharsInStr("", "afe") == "");
        
        phoenix_assert(replaceStrInStr("", "", "") == "");
        phoenix_assert(replaceStrInStr("", "o", "") == "");
        phoenix_assert(replaceStrInStr("o", "", "") == "");
}

References eraseLastCharsInStr(), findInListString(), findInVectorString(), phoenix_assert, and replaceStrInStr().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

testGetCommonBegning()

void testGetCommonBegning

(

)

Test the phoenix_getCommonBegining function.

Definition at line 221 of file main.cpp.

                           {
        phoenix_assert(phoenix_getCommonBegining("", "") == "");
        phoenix_assert(phoenix_getCommonBegining("someString", "") == "");
        phoenix_assert(phoenix_getCommonBegining("", "someString") == "");
        phoenix_assert(phoenix_getCommonBegining("someString", "someOtherString") == "some");
        phoenix_assert(phoenix_getCommonBegining("someString", "AndsomeOtherString") == "");
}

References phoenix_assert, and phoenix_getCommonBegining().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

testReplaceListStrInStr()

void testReplaceListStrInStr

(

)

Test the replaceVectorStrInStr function.

Definition at line 189 of file main.cpp.

                              {
        std::list<std::string> vecStrPattern;
        phoenix_assert(checkReplaceListStrInStr("", vecStrPattern, "", ""));
        phoenix_assert(checkReplaceListStrInStr("something", vecStrPattern, "", "something"));
        vecStrPattern.push_back("key");
        phoenix_assert(checkReplaceListStrInStr("", vecStrPattern, "", ""));
        phoenix_assert(checkReplaceListStrInStr("convert value to key", vecStrPattern, "value", "convert value to value"));
        vecStrPattern.push_back("value");
        phoenix_assert(checkReplaceListStrInStr("convert value to key", vecStrPattern, "thing", "convert thing to thing"));
}

References checkReplaceListStrInStr(), and phoenix_assert.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

testReplaceStrInStrMap()

void testReplaceStrInStrMap

(

)

Test the replace of str in str with map.

Definition at line 201 of file main.cpp.

                             {
        std::map<std::string, std::string> mapReplace;
        phoenix_assert(replaceStrInStr("some string to convert", mapReplace) == "some string to convert");
        mapReplace["string"] = "value";
        mapReplace["convert"] = "replace";
        phoenix_assert(replaceStrInStr("some string to convert", mapReplace) == "some value to replace");
}

References phoenix_assert, and replaceStrInStr().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

testReplaceVectorStrInStr()

void testReplaceVectorStrInStr

(

)

Test the replaceVectorStrInStr function.

Definition at line 163 of file main.cpp.

                                {
        std::vector<std::string> vecStrPattern;
        phoenix_assert(checkReplaceVectorStrInStr("", vecStrPattern, "", ""));
        phoenix_assert(checkReplaceVectorStrInStr("something", vecStrPattern, "", "something"));
        vecStrPattern.push_back("key");
        phoenix_assert(checkReplaceVectorStrInStr("", vecStrPattern, "", ""));
        phoenix_assert(checkReplaceVectorStrInStr("convert value to key", vecStrPattern, "value", "convert value to value"));
        vecStrPattern.push_back("value");
        phoenix_assert(checkReplaceVectorStrInStr("convert value to key", vecStrPattern, "thing", "convert thing to thing"));
}

References checkReplaceVectorStrInStr(), and phoenix_assert.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

testStringFunction()

void testStringFunction

(

)

Test the string filename function.

Definition at line 63 of file main.cpp.

                         {
        std::string testString("some string to be used");
        
        phoenix_assert(checkString("Test replaceCharInStr", replaceCharInStr(testString, 'o', "O"), "sOme string tO be used"));
        phoenix_assert(checkString("Test replaceCharsInStr", replaceCharsInStr(testString, "ot", 'X'), "sXme sXring XX be used"));
        phoenix_assert(checkString("Test replaceStrInStr", replaceStrInStr(testString, "string", "text"), "some text to be used"));
        phoenix_assert(checkString("Test replaceStrInStr full", replaceStrInStr("string", "string", "text"), "text"));
        std::vector<std::string> vecStringToReplace;
        vecStringToReplace.push_back(testString);
        std::vector<std::string> vecReplacedString = replaceStrInStr(vecStringToReplace, "string", "text");
        phoenix_assert(checkString("Test replaceStrInStr vector", vecReplacedString[0], "some text to be used"));
        phoenix_assert(checkString("Test copyStr", copyStr("Some string", 2lu, 4lu), "me s"));
        phoenix_assert(checkString("Test eraseCharInStr", eraseCharInStr(testString, 'o'), "sme string t be used"));
        phoenix_assert(checkString("Test eraseCharInStr", eraseCharInStr("", 'o'), ""));
        phoenix_assert(checkString("Test eraseCharsInStr", eraseCharsInStr(testString, "o"), "sme string t be used"));
        phoenix_assert(checkString("Test eraseCharsInStr", eraseCharsInStr(testString, "oxi"), "sme strng t be used"));
        phoenix_assert(checkString("Test eraseCharsInStr", eraseCharsInStr("", "o"), ""));
        phoenix_assert(checkString("Test replaceCharsInStr", replaceCharsInStr("", "o", 'd'), ""));
        phoenix_assert(checkString("Test replaceCharsInStr", replaceCharsInStr("", "", 'd'), ""));
        phoenix_assert(checkString("Test replaceCharsInStr", replaceCharsInStr("o", "", 'd'), "o"));
        
        std::vector<std::string> vecStrRef;
        vecStrRef.push_back("one");
        vecStrRef.push_back("two");
        vecStrRef.push_back("three");
        
        std::list<std::string> listStr(cutStringList("one two three", ' '));
        std::vector<std::string> vecStr(cutStringVector("one two three", ' '));
        
        std::list<std::string> listSpaceStr(cutStringOnSpacesList("one two three"));
        std::vector<std::string> vecSpaceStr(cutStringOnSpacesVector("one two three"));
        
        std::list<std::string>::iterator itList(listStr.begin());
        std::list<std::string>::iterator itSpaceList(listSpaceStr.begin());
        std::vector<std::string>::iterator itVec(vecStr.begin());
        std::vector<std::string>::iterator itSpaceVec(vecSpaceStr.begin());
        std::vector<std::string>::iterator itVecRef(vecStrRef.begin());
        
        while(itList != listStr.end() && itVec != vecStr.end() && itVecRef != vecStrRef.end() && itSpaceList != listSpaceStr.end() && itSpaceVec != vecSpaceStr.end()){
                phoenix_assert(*itList == *itVec && *itVec ==* itVecRef);
                phoenix_assert(*itSpaceList == *itVec && *itSpaceVec == *itVec);
                
                ++itList;
                ++itVec;
                ++itVecRef;
                ++itSpaceList;
                ++itSpaceVec;
        }
        
        phoenix_assert(!findInString("", 'a'));
        phoenix_assert(findInString("abc", 'a'));
        phoenix_assert(findInString("abc", 'b'));
        phoenix_assert(findInString("abc", 'c'));
        phoenix_assert(!findInString("abc", 'd'));
        phoenix_assert(!findCharsInString("", ""));
        phoenix_assert(!findCharsInString("", "a"));
        phoenix_assert(!findCharsInString("abc", ""));
        phoenix_assert(findCharsInString("abc", "a"));
        phoenix_assert(findCharsInString("abc", "b"));
        phoenix_assert(findCharsInString("abc", "c"));
        phoenix_assert(!findCharsInString("abc", "d"));
        phoenix_assert(findCharsInString("abc", "xa"));
        phoenix_assert(findCharsInString("abc", "xb"));
        phoenix_assert(findCharsInString("abc", "xc"));
        phoenix_assert(!findCharsInString("abc", "xd"));
        phoenix_assert(findCharsInString("abc", "ax"));
        phoenix_assert(findCharsInString("abc", "bx"));
        phoenix_assert(findCharsInString("abc", "cx"));
        phoenix_assert(!findCharsInString("abc", "dx"));
        phoenix_assert(countNbChar("", 'o') == 0lu);
        phoenix_assert(countNbChar("some thing to count", 'o') == 3lu);
        phoenix_assert(countNbChar("some thing to count", 'w') == 0lu);
        phoenix_assert(isSameBegining("", ""));
        phoenix_assert(!isSameBegining("", "d"));
        phoenix_assert(isSameBegining("start", "start"));
        phoenix_assert(isSameBegining("start", "st"));
        phoenix_assert(!isSameBegining("st", "start"));
        
        phoenix_assert(countStrInStr("some string with text", "") == 0lu);
        phoenix_assert(countStrInStr("", "nothing") == 0lu);
        phoenix_assert(countStrInStr("", "") == 0lu);
        phoenix_assert(countStrInStr("some string with text", "with") == 1lu);
        phoenix_assert(countStrInStr("one char and two chars", "char") == 2lu);
}

References checkString(), copyStr(), countNbChar(), countStrInStr(), cutStringList(), cutStringOnSpacesList(), cutStringOnSpacesVector(), cutStringVector(), eraseCharInStr(), eraseCharsInStr(), findCharsInString(), findInString(), isSameBegining(), phoenix_assert, replaceCharInStr(), replaceCharsInStr(), and replaceStrInStr().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function: