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
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	testPString ()
	Test the is lower/upper case. More...

Function Documentation

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:

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 105 of file main.cpp.

                               {
        testPString();
        return 0;
}

References testPString().

Here is the call graph for this function:

testPString()

void testPString

(

)

Test the is lower/upper case.

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 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 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 ") + 3.14;
        phoenix_assert(checkString("Test + operator double", resAddDouble, "double 3.14"));
        
        PString resAddFloat;
        resAddFloat = PString("float ") + 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(), and phoenix_assert.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function: