main.cpp File Reference

#include <iostream>
#include "phoenix_assert.h"
#include "phoenix_check.h"
#include "PString.h"

Include dependency graph for main.cpp:

Go to the source code of this file.

Functions
void	checkCharToString ()
	Check phoenix_charToString. More...
void	checkCount ()
	Check count. More...
void	checkEraseChar ()
	Check erase char. More...
bool	checkEraseFirstChars (const std::string &testName, const std::string &strExpr, const std::string &strReference)
	Check the erase first chars. More...
bool	checkEraseFirstLastChars (const PString &testName, const PString &strExpr, const PString &strReference)
	Check the erase first last chars. More...
bool	checkEraseLastChars (const PString &testName, const PString &strExpr, const PString &strReference)
	Check the erase last chars. More...
void	checkFind ()
	Check the find method. More...
void	checkFormat ()
	Check format. More...
void	checkGetCommonBegining ()
	Check the getCommonBegining. More...
void	checkIsSameBegining ()
	Check isSameBegining. More...
void	checkPStringLowerUpper ()
	Test lower/upper to string. More...
void	checkPStringReplace ()
	Check PString Replace. More...
void	checkSplitMerge ()
	Check the split and merge. More...
bool	checkString (const std::string &testName, const std::string &strValue, const std::string &strReference)
	Check string lower expression. More...
void	checkValueToStringConvertion ()
	Test value to string and string to value. More...
int	main (int argc, char **argv)
void	testEscapeString ()
	Test the phoenix_escapeStr function. More...
void	testPString ()
	Test the PString. More...
void	testPStringConversion ()
	Test the PString conversion. More...

Function Documentation

checkCharToString()

void checkCharToString

(

)

Check phoenix_charToString.

Definition at line 171 of file main.cpp.

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

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:

checkCount()

void checkCount

(

)

Check count.

Definition at line 158 of file main.cpp.

                 {
        phoenix_assert(PString("").count('o') == 0lu);
        phoenix_assert(PString("some thing to count").count('o') == 3lu);
        phoenix_assert(PString("some thing to count").count('w') == 0lu);
        
        phoenix_assert(PString("some string with text").count("") == 0lu);
        phoenix_assert(PString("").count("nothing") == 0lu);
        phoenix_assert(PString("").count("") == 0lu);
        phoenix_assert(PString("some string with text").count("with") == 1lu);
        phoenix_assert(PString("one char and two chars").count("char") == 2lu);
}

References phoenix_assert.

Referenced by main().

Here is the caller graph for this function:

checkEraseChar()

void checkEraseChar

(

)

Check erase char.

Definition at line 251 of file main.cpp.

                     {
        phoenix_assert(checkString("Test eraseChar", PString("").eraseChar('o'), ""));
        phoenix_assert(checkString("Test eraseChar", PString("").eraseChar("o"), ""));
        phoenix_assert(checkString("Test eraseChar", PString("some string to be used").eraseChar('o'), "sme string t be used"));
        phoenix_assert(checkString("Test eraseChar", PString("some string to be used").eraseChar("o"), "sme string t be used"));
        phoenix_assert(checkString("Test eraseChar", PString("some string to be used").eraseChar("oxi"), "sme strng t be used"));
        
        phoenix_assert(checkString("Test eraseLastChar", PString("").eraseLastChar("afe"), ""));
        phoenix_assert(checkString("Test eraseLastChar", PString("").eraseLastChar("afe"), ""));
        
        phoenix_assert(checkEraseFirstChars("Erase first chars 1", "one thing", "one thing"));
        phoenix_assert(checkEraseFirstChars("Erase first chars 2", "   one thing", "one thing"));
        phoenix_assert(checkEraseFirstChars("Erase first chars 3", "one thing   ", "one thing   "));
        phoenix_assert(checkEraseFirstChars("Erase first chars 4", "  one thing  ", "one thing  "));
        
        phoenix_assert(checkEraseLastChars("Erase last chars 1", "one thing", "one thing"));
        phoenix_assert(checkEraseLastChars("Erase last chars 2", "   one thing", "   one thing"));
        phoenix_assert(checkEraseLastChars("Erase last chars 3", "one thing   ", "one thing"));
        phoenix_assert(checkEraseLastChars("Erase last chars 4", "  one thing  ", "  one thing"));
        
        phoenix_assert(checkEraseFirstLastChars("Erase first last chars 1", "one thing", "one thing"));
        phoenix_assert(checkEraseFirstLastChars("Erase first last chars 2", "   one thing", "one thing"));
        phoenix_assert(checkEraseFirstLastChars("Erase first last chars 3", "one thing   ", "one thing"));
        phoenix_assert(checkEraseFirstLastChars("Erase first last chars 4", "  one thing  ", "one thing"));
        
        PVecString vecIn;
        vecIn.push_back(" one thing  ");
        PVecString vecOut = eraseFirstLastChar(vecIn, " ");
        phoenix_assert(vecOut.size() == 1lu);
        phoenix_assert(vecOut.front() == "one thing");
}

References checkEraseFirstChars(), checkEraseFirstLastChars(), checkEraseLastChars(), checkString(), eraseFirstLastChar(), and phoenix_assert.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

checkEraseFirstChars()

bool checkEraseFirstChars	(	const std::string &	testName,
		const std::string &	strExpr,
		const std::string &	strReference
	)

Check the erase first chars.

Parameters

testName	: name of the test
strExpr	: string to be parsed to get a MathExpr
strReference	: reference string

Returns

true is both strings are equal, false otherwise

Definition at line 219 of file main.cpp.

                                                                                                                {
        PString tmp(strExpr);
        PString strErase(tmp.eraseFirstChar(" \t\n"));
        return phoenix_check(testName + "("+strExpr+")", strErase, strReference);
}

References PString::eraseFirstChar(), and phoenix_check().

Referenced by checkEraseChar().

Here is the call graph for this function:

Here is the caller graph for this function:

checkEraseFirstLastChars()

bool checkEraseFirstLastChars	(	const PString &	testName,
		const PString &	strExpr,
		const PString &	strReference
	)

Check the erase first last chars.

Parameters

testName	: name of the test
strExpr	: string to be parsed to get a MathExpr
strReference	: reference string

Returns

true is both strings are equal, false otherwise

Definition at line 243 of file main.cpp.

                                                                                                              {
        PString tmp(strExpr);
        PString strErase(tmp.eraseFirstLastChar(" \t\n"));
        return phoenix_check(testName + "("+strExpr+")", strErase, strReference);
}

References PString::eraseFirstLastChar(), and phoenix_check().

Referenced by checkEraseChar().

Here is the call graph for this function:

Here is the caller graph for this function:

checkEraseLastChars()

bool checkEraseLastChars	(	const PString &	testName,
		const PString &	strExpr,
		const PString &	strReference
	)

Check the erase last chars.

Parameters

testName	: name of the test
strExpr	: string to be parsed to get a MathExpr
strReference	: reference string

Returns

true is both strings are equal, false otherwise

Definition at line 231 of file main.cpp.

                                                                                                         {
        PString tmp(strExpr);
        PString strErase(tmp.eraseLastChar(" \t\n"));
        return phoenix_check(testName + "("+strExpr+")", strErase, strReference);
}

References PString::eraseLastChar(), and phoenix_check().

Referenced by checkEraseChar().

Here is the call graph for this function:

Here is the caller graph for this function:

checkFind()

void checkFind

(

)

Check the find method.

Definition at line 186 of file main.cpp.

                {
        phoenix_assert(!PString("").find('0'));
        phoenix_assert(!PString("123456").find('0'));
        phoenix_assert(PString("1230456").find('0'));
        
        phoenix_assert(!PString("").find("0"));
        phoenix_assert(!PString("some char").find(""));
        phoenix_assert(PString("some char").find("co"));
        phoenix_assert(!PString("some char").find("zwt"));
}

References phoenix_assert.

Referenced by main().

Here is the caller graph for this function:

checkFormat()

void checkFormat

(

)

Check format.

Definition at line 151 of file main.cpp.

                  {
        PString str3("Some {} to modify with other {}s");
        phoenix_assert(checkString("Check format", str3.format("sentence"), "Some sentence to modify with other {}s"));
        phoenix_assert(checkString("Check format", str3.format("violin"), "Some violin to modify with other {}s"));
}

References checkString(), PString::format(), and phoenix_assert.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

checkGetCommonBegining()

void checkGetCommonBegining

(

)

Check the getCommonBegining.

Definition at line 177 of file main.cpp.

                             {
        phoenix_assert(PString("").getCommonBegining("") == "");
        phoenix_assert(PString("someString").getCommonBegining("") == "");
        phoenix_assert(PString("").getCommonBegining("someString") == "");
        phoenix_assert(PString("someString").getCommonBegining("someOtherString") == "some");
        phoenix_assert(PString("someString").getCommonBegining("AndsomeOtherString") == "");
}

References phoenix_assert.

Referenced by main().

Here is the caller graph for this function:

checkIsSameBegining()

void checkIsSameBegining

(

)

Check isSameBegining.

Definition at line 142 of file main.cpp.

                          {
        phoenix_assert(PString("").isSameBegining(""));
        phoenix_assert(!PString("").isSameBegining("d"));
        phoenix_assert(PString("start").isSameBegining("start"));
        phoenix_assert(PString("start").isSameBegining("st"));
        phoenix_assert(!PString("st").isSameBegining("start"));
}

References phoenix_assert.

Referenced by main().

Here is the caller graph for this function:

checkPStringLowerUpper()

void checkPStringLowerUpper

(

)

Test lower/upper to string.

Definition at line 284 of file main.cpp.

                             {
        phoenix_assert(!PString("").isLowerCase());
        phoenix_assert(!PString("notOnlyLowerCase").isLowerCase());
        phoenix_assert(PString("fulllowercase").isLowerCase());
        phoenix_assert(!PString("").isUpperCase());
        phoenix_assert(!PString("NOToNLYuPPERcASE").isUpperCase());
        phoenix_assert(PString("FULLYUPPERCASE").isUpperCase());
        phoenix_assert(!PString("").isNumber());
        phoenix_assert(!PString("FULLYUPPERCASE").isNumber());
        phoenix_assert(PString("12345").isNumber());
        
        phoenix_assert(checkString("Test", PString("").toLower(), ""));
        phoenix_assert(checkString("Test", PString("StRiNg").toLower(), "string"));
        phoenix_assert(checkString("Test", PString("StRiNg1234").toLower(), "string1234"));
        phoenix_assert(checkString("Test", PString("ABCDEFGHIJKLMNOPQRSTUVWXYZ").toLower(), "abcdefghijklmnopqrstuvwxyz"));
        phoenix_assert(checkString("Test", PString("").toUpper(), ""));
        phoenix_assert(checkString("Test", PString("StRiNg").toUpper(), "STRING"));
        phoenix_assert(checkString("Test", PString("StRiNg1234").toUpper(), "STRING1234"));
        phoenix_assert(checkString("Test", PString("abcdefghijklmnopqrstuvwxyz").toUpper(), "ABCDEFGHIJKLMNOPQRSTUVWXYZ"));
        phoenix_assert(checkString("Test", PString("").firstToLower(), ""));
        phoenix_assert(checkString("Test", PString("ABC").firstToLower(), "aBC"));
        phoenix_assert(checkString("Test", PString("aBC").firstToLower(), "aBC"));
        phoenix_assert(checkString("Test", PString("Vec").firstToLower(), "vec"));
        phoenix_assert(checkString("Test", PString("").firstToUpper(), ""));
        phoenix_assert(checkString("Test", PString("ABC").firstToUpper(), "ABC"));
        phoenix_assert(checkString("Test", PString("Vec").firstToUpper(), "Vec"));
        phoenix_assert(checkString("Test", PString("aBC").firstToUpper(), "ABC"));
        phoenix_assert(checkString("Test", PString("vec").firstToUpper(), "Vec"));
        phoenix_assert(checkString("Test", PString("").toLowerUnderscore(), ""));
        phoenix_assert(checkString("Test", PString("StringType").toLowerUnderscore(), "stringtype"));
        phoenix_assert(checkString("Test", PString("String Type").toLowerUnderscore(), "string_type"));
}

References checkString(), and phoenix_assert.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

checkPStringReplace()

void checkPStringReplace

(

)

Check PString Replace.

Definition at line 125 of file main.cpp.

                          {
        PString str = "Some string to modify";
        phoenix_assert(checkString("Check replace", str.replace("string", "sentence"), "Some sentence to modify"));
        phoenix_assert(checkString("Check replace", PString("some string to modify").replace("string", "sentence"), "some sentence to modify"));
        
        PString str2("Some string to modify");
        phoenix_assert(checkString("Check replace", str2.replace("string", "sentence", 0lu), "Some string to modify"));
        phoenix_assert(checkString("Check replace", str2.replace("string", "sentence", 1lu), "Some sentence to modify"));
        
        PString str3("Some string to modify with other strings");
        phoenix_assert(checkString("Check replace", str3.replace("string", "sentence", 1lu), "Some sentence to modify with other strings"));
        phoenix_assert(checkString("Check replace", str3.replace("string", "violin", 1lu), "Some violin to modify with other strings"));
        
        phoenix_assert(checkString("Check replaceChar", PString("some string\nwith\tchar to replace").replaceChar(" \t\n", "_"), "some_string_with_char_to_replace"));
}

References checkString(), phoenix_assert, and PString::replace().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

checkSplitMerge()

void checkSplitMerge

(

)

Check the split and merge.

Definition at line 198 of file main.cpp.

                      {
        phoenix_assert(PString("").split(' ').size() == 0lu);
        PVecString vecStr(PString("Some String to split").split(' '));
        phoenix_assert(vecStr.size() == 4lu);
        phoenix_assert(PString("").merge(vecStr, " ") == "Some String to split");
        
        phoenix_assert(PString("").split("").size() == 0lu);
        phoenix_assert(PString("Some String").split("").size() == 0lu);
        phoenix_assert(PString("").split(" ").size() == 0lu);
        
        PVecString splitStr(PString("Some String to\tsplit").split(" \t"));
        phoenix_assert(splitStr.size() == 4lu);
        phoenix_assert(PString("").merge(splitStr, " ") == "Some String to split");
}

References phoenix_assert.

Referenced by main().

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 20 of file main.cpp.

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

References phoenix_check().

Here is the call graph for this function:

checkValueToStringConvertion()

void checkValueToStringConvertion

(

)

Test value to string and string to value.

Definition at line 117 of file main.cpp.

                                   {
        PString str;
        str.fromValue(3.14);
        phoenix_assert(checkString("Test fromValue", str, "3.14"));
        phoenix_assert(3.14 == str.toValue<double>());
}

References checkString(), PString::fromValue(), phoenix_assert, and PString::toValue().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 334 of file main.cpp.

                               {
        testPString();
        checkValueToStringConvertion();
        checkPStringReplace();
        checkIsSameBegining();
        checkFormat();
        checkCount();
        checkCharToString();
        checkGetCommonBegining();
        checkFind();
        checkSplitMerge();
        checkEraseChar();
        checkPStringLowerUpper();
        testEscapeString();
        return 0;
}

References checkCharToString(), checkCount(), checkEraseChar(), checkFind(), checkFormat(), checkGetCommonBegining(), checkIsSameBegining(), checkPStringLowerUpper(), checkPStringReplace(), checkSplitMerge(), checkValueToStringConvertion(), testEscapeString(), and testPString().

Here is the call graph for this function:

testEscapeString()

void testEscapeString

(

)

Test the phoenix_escapeStr function.

Definition at line 318 of file main.cpp.

                       {
        phoenix_assert(phoenix_check("PString::escapeStr", PString("some string with escape's \"char\"").escapeStr(" '\"", "\\"), "some\\ string\\ with\\ escape\\'s\\ \\\"char\\\""));
}

References phoenix_assert, and phoenix_check().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

testPString()

void testPString

(

)

Test the PString.

Definition at line 25 of file main.cpp.

                  {
        PString baseStr("baseString");
        phoenix_assert(checkString("Test constructor", baseStr, "baseString"));
        PString checkEqual;
        checkEqual = baseStr;
        phoenix_assert(checkString("Test equal", checkEqual, "baseString"));
        
        PString checkEqualStdString;
        checkEqualStdString = std::string("baseString");
        phoenix_assert(checkString("Test equal std::string", checkEqualStdString, "baseString"));
        
        PString checkConstructorStdString(std::string("baseString"));
        phoenix_assert(checkString("Test constructor std::string", checkConstructorStdString, "baseString"));
        
        PString copyString(baseStr);
        phoenix_assert(checkString("Test copy constructor", copyString, "baseString"));
        PString equalOperatorStr;
        equalOperatorStr = baseStr;
        phoenix_assert(checkString("Test equal operator str", equalOperatorStr, "baseString"));
        
        PString equalOperatorFluxStr;
        equalOperatorFluxStr = baseStr;
        phoenix_assert(checkString("Test << operator str", equalOperatorFluxStr, "baseString"));
        
        baseStr += " end";
        phoenix_assert(checkString("Test += string", baseStr, "baseString end"));
        
        PString valDouble;
        valDouble = 42.0;
        phoenix_assert(checkString("Test equal operator double", valDouble, "42"));
        
        PString valFloat;
        valFloat = 42.0f;
        phoenix_assert(checkString("Test equal operator float", valFloat, "42"));
        
        PString valDoubleFlux;
        valDoubleFlux << 42.0;
        phoenix_assert(checkString("Test << operator double", valDoubleFlux, "42"));
        
        PString strAndChar("strin");
        strAndChar += 'g';
        phoenix_assert(checkString("Test + operator char", strAndChar, "string"));
        
        PString valFloatFlux;
        valFloatFlux << 42.0f;
        phoenix_assert(checkString("Test << operator float", valFloatFlux, "42"));
        
        valDouble += 3.14;
        phoenix_assert(checkString("Test += operator double", valDouble, "423.14"));
        
        valFloat += 3.14f;
        phoenix_assert(checkString("Test += operator float", valFloat, "423.14"));
        
        PString resAdd = valDouble + valFloat;
        phoenix_assert(checkString("Test + operator PString", resAdd, "423.14423.14"));
        
        PString resAddDouble;
        resAddDouble = PString("double ") + PString::toString(3.14);
        phoenix_assert(checkString("Test + operator double", resAddDouble, "double 3.14"));
        
        PString resAddFloat;
        resAddFloat = PString("float ") + PString::toString(3.14);
        phoenix_assert(checkString("Test + operator float", resAddFloat, "float 3.14"));
        
        PString strA("str1"), strB("str2"), resResAB, resFluxAB;
        resResAB = strA + strB;
        phoenix_assert(checkString("Test + operator PString", resResAB, "str1str2"));
        resFluxAB << strA << strB;
        phoenix_assert(checkString("Test << operator PString", resFluxAB, "str1str2"));
        
        PString strAddStr("Some string");
        strAddStr += " other string";
        phoenix_assert(checkString("Test += operator std::string", strAddStr, "Some string other string"));
        
        PString strAddFluxStr("Some string");
        strAddFluxStr << " other string";
        phoenix_assert(checkString("Test << operator std::string", strAddFluxStr, "Some string other string"));
        
        PString strFlux;
        strFlux << strAddFluxStr;
        phoenix_assert(checkString("Test << operator PString", strFlux, "Some string other string"));
        
        strFlux += std::string(" and the end");
        phoenix_assert(checkString("Test += operator std::string", strFlux, "Some string other string and the end"));
        
        strFlux << std::string(".");
        phoenix_assert(checkString("Test += operator std::string", strFlux, "Some string other string and the end."));
        
        strA << (strFlux << strAddFluxStr);
}

References checkString(), phoenix_assert, and PString::toString().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

testPStringConversion()

void testPStringConversion

(

)

Test the PString conversion.

Definition at line 323 of file main.cpp.

                            {
        phoenix_assert(PString::toValue<int>("314") == 314);
        phoenix_assert(PString::toValue<std::string>("314") == "314");
        
        phoenix_assert(PString::toString(true) == "true");
        phoenix_assert(PString::toString(false) == "false");
        phoenix_assert(PString::toValue<bool>("true") == true);
        phoenix_assert(PString::toValue<bool>("false") == false);
        
}

References phoenix_assert, and PString::toString().

Here is the call graph for this function: