generic-library/jsoncpp
1
0
Fork 0
mirror of https://github.com/open-source-parsers/jsoncpp.git synced 2025-03-03 04:38:39 +01:00
Code Issues Projects Releases Wiki Activity

- changed SVN EOL properties so that HTML file are in Unix format, Visual Studio solution are always in Windows format, and sources are in native format.

Browse Source
This commit is contained in:
Baptiste Lepilleur 2010-02-23 08:23:41 +00:00
parent 1f4847cbd9
commit fcf145ecd4
4 changed files with 722 additions and 722 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

428
makefiles/vs71/lib_json.vcproj
View File

@ -1,214 +1,214 @@
<?xml version="1.0" encoding="Windows-1252"?> <?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject <VisualStudioProject
ProjectType="Visual C++" ProjectType="Visual C++"
Version="7.10" Version="7.10"
Name="lib_json" Name="lib_json"
ProjectGUID="{B84F7231-16CE-41D8-8C08-7B523FF4225B}" ProjectGUID="{B84F7231-16CE-41D8-8C08-7B523FF4225B}"
Keyword="Win32Proj"> Keyword="Win32Proj">
<Platforms> <Platforms>
<Platform <Platform
Name="Win32"/> Name="Win32"/>
</Platforms> </Platforms>
<Configurations> <Configurations>
<Configuration <Configuration
Name="Debug|Win32" Name="Debug|Win32"
OutputDirectory="../../build/vs71/debug/lib_json" OutputDirectory="../../build/vs71/debug/lib_json"
IntermediateDirectory="../../build/vs71/debug/lib_json" IntermediateDirectory="../../build/vs71/debug/lib_json"
ConfigurationType="4" ConfigurationType="4"
CharacterSet="2"> CharacterSet="2">
<Tool <Tool
Name="VCCLCompilerTool" Name="VCCLCompilerTool"
Optimization="0" Optimization="0"
AdditionalIncludeDirectories="../../include" AdditionalIncludeDirectories="../../include"
PreprocessorDefinitions="WIN32;_DEBUG;_LIB" PreprocessorDefinitions="WIN32;_DEBUG;_LIB"
StringPooling="TRUE" StringPooling="TRUE"
MinimalRebuild="TRUE" MinimalRebuild="TRUE"
BasicRuntimeChecks="3" BasicRuntimeChecks="3"
RuntimeLibrary="1" RuntimeLibrary="1"
EnableFunctionLevelLinking="TRUE" EnableFunctionLevelLinking="TRUE"
DisableLanguageExtensions="TRUE" DisableLanguageExtensions="TRUE"
ForceConformanceInForLoopScope="FALSE" ForceConformanceInForLoopScope="FALSE"
RuntimeTypeInfo="TRUE" RuntimeTypeInfo="TRUE"
UsePrecompiledHeader="0" UsePrecompiledHeader="0"
WarningLevel="3" WarningLevel="3"
Detect64BitPortabilityProblems="TRUE" Detect64BitPortabilityProblems="TRUE"
DebugInformationFormat="4"/> DebugInformationFormat="4"/>
<Tool <Tool
Name="VCCustomBuildTool"/> Name="VCCustomBuildTool"/>
<Tool <Tool
Name="VCLibrarianTool" Name="VCLibrarianTool"
OutputFile="$(OutDir)/json_vc71_libmtd.lib"/> OutputFile="$(OutDir)/json_vc71_libmtd.lib"/>
<Tool <Tool
Name="VCMIDLTool"/> Name="VCMIDLTool"/>
<Tool <Tool
Name="VCPostBuildEventTool"/> Name="VCPostBuildEventTool"/>
<Tool <Tool
Name="VCPreBuildEventTool"/> Name="VCPreBuildEventTool"/>
<Tool <Tool
Name="VCPreLinkEventTool"/> Name="VCPreLinkEventTool"/>
<Tool <Tool
Name="VCResourceCompilerTool"/> Name="VCResourceCompilerTool"/>
<Tool <Tool
Name="VCWebServiceProxyGeneratorTool"/> Name="VCWebServiceProxyGeneratorTool"/>
<Tool <Tool
Name="VCXMLDataGeneratorTool"/> Name="VCXMLDataGeneratorTool"/>
<Tool <Tool
Name="VCManagedWrapperGeneratorTool"/> Name="VCManagedWrapperGeneratorTool"/>
<Tool <Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/> Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration> </Configuration>
<Configuration <Configuration
Name="Release|Win32" Name="Release|Win32"
OutputDirectory="../../build/vs71/release/lib_json" OutputDirectory="../../build/vs71/release/lib_json"
IntermediateDirectory="../../build/vs71/release/lib_json" IntermediateDirectory="../../build/vs71/release/lib_json"
ConfigurationType="4" ConfigurationType="4"
CharacterSet="2" CharacterSet="2"
WholeProgramOptimization="TRUE"> WholeProgramOptimization="TRUE">
<Tool <Tool
Name="VCCLCompilerTool" Name="VCCLCompilerTool"
GlobalOptimizations="TRUE" GlobalOptimizations="TRUE"
EnableIntrinsicFunctions="TRUE" EnableIntrinsicFunctions="TRUE"
AdditionalIncludeDirectories="../../include" AdditionalIncludeDirectories="../../include"
PreprocessorDefinitions="WIN32;NDEBUG;_LIB" PreprocessorDefinitions="WIN32;NDEBUG;_LIB"
StringPooling="TRUE" StringPooling="TRUE"
RuntimeLibrary="0" RuntimeLibrary="0"
EnableFunctionLevelLinking="TRUE" EnableFunctionLevelLinking="TRUE"
DisableLanguageExtensions="TRUE" DisableLanguageExtensions="TRUE"
ForceConformanceInForLoopScope="FALSE" ForceConformanceInForLoopScope="FALSE"
RuntimeTypeInfo="TRUE" RuntimeTypeInfo="TRUE"
UsePrecompiledHeader="0" UsePrecompiledHeader="0"
AssemblerOutput="4" AssemblerOutput="4"
WarningLevel="3" WarningLevel="3"
Detect64BitPortabilityProblems="TRUE" Detect64BitPortabilityProblems="TRUE"
DebugInformationFormat="3"/> DebugInformationFormat="3"/>
<Tool <Tool
Name="VCCustomBuildTool"/> Name="VCCustomBuildTool"/>
<Tool <Tool
Name="VCLibrarianTool" Name="VCLibrarianTool"
OutputFile="$(OutDir)/json_vc71_libmt.lib"/> OutputFile="$(OutDir)/json_vc71_libmt.lib"/>
<Tool <Tool
Name="VCMIDLTool"/> Name="VCMIDLTool"/>
<Tool <Tool
Name="VCPostBuildEventTool"/> Name="VCPostBuildEventTool"/>
<Tool <Tool
Name="VCPreBuildEventTool"/> Name="VCPreBuildEventTool"/>
<Tool <Tool
Name="VCPreLinkEventTool"/> Name="VCPreLinkEventTool"/>
<Tool <Tool
Name="VCResourceCompilerTool"/> Name="VCResourceCompilerTool"/>
<Tool <Tool
Name="VCWebServiceProxyGeneratorTool"/> Name="VCWebServiceProxyGeneratorTool"/>
<Tool <Tool
Name="VCXMLDataGeneratorTool"/> Name="VCXMLDataGeneratorTool"/>
<Tool <Tool
Name="VCManagedWrapperGeneratorTool"/> Name="VCManagedWrapperGeneratorTool"/>
<Tool <Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/> Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration> </Configuration>
<Configuration <Configuration
Name="dummy|Win32" Name="dummy|Win32"
OutputDirectory="$(ConfigurationName)" OutputDirectory="$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)" IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="2" ConfigurationType="2"
CharacterSet="2" CharacterSet="2"
WholeProgramOptimization="TRUE"> WholeProgramOptimization="TRUE">
<Tool <Tool
Name="VCCLCompilerTool" Name="VCCLCompilerTool"
GlobalOptimizations="TRUE" GlobalOptimizations="TRUE"
EnableIntrinsicFunctions="TRUE" EnableIntrinsicFunctions="TRUE"
AdditionalIncludeDirectories="../../include" AdditionalIncludeDirectories="../../include"
PreprocessorDefinitions="WIN32;NDEBUG;_LIB" PreprocessorDefinitions="WIN32;NDEBUG;_LIB"
StringPooling="TRUE" StringPooling="TRUE"
RuntimeLibrary="4" RuntimeLibrary="4"
EnableFunctionLevelLinking="TRUE" EnableFunctionLevelLinking="TRUE"
DisableLanguageExtensions="TRUE" DisableLanguageExtensions="TRUE"
ForceConformanceInForLoopScope="FALSE" ForceConformanceInForLoopScope="FALSE"
RuntimeTypeInfo="TRUE" RuntimeTypeInfo="TRUE"
UsePrecompiledHeader="0" UsePrecompiledHeader="0"
AssemblerOutput="4" AssemblerOutput="4"
WarningLevel="3" WarningLevel="3"
Detect64BitPortabilityProblems="TRUE" Detect64BitPortabilityProblems="TRUE"
DebugInformationFormat="3"/> DebugInformationFormat="3"/>
<Tool <Tool
Name="VCCustomBuildTool"/> Name="VCCustomBuildTool"/>
<Tool <Tool
Name="VCLinkerTool" Name="VCLinkerTool"
GenerateDebugInformation="TRUE" GenerateDebugInformation="TRUE"
SubSystem="2" SubSystem="2"
OptimizeReferences="2" OptimizeReferences="2"
EnableCOMDATFolding="2" EnableCOMDATFolding="2"
TargetMachine="1"/> TargetMachine="1"/>
<Tool <Tool
Name="VCMIDLTool"/> Name="VCMIDLTool"/>
<Tool <Tool
Name="VCPostBuildEventTool"/> Name="VCPostBuildEventTool"/>
<Tool <Tool
Name="VCPreBuildEventTool"/> Name="VCPreBuildEventTool"/>
<Tool <Tool
Name="VCPreLinkEventTool"/> Name="VCPreLinkEventTool"/>
<Tool <Tool
Name="VCResourceCompilerTool"/> Name="VCResourceCompilerTool"/>
<Tool <Tool
Name="VCWebServiceProxyGeneratorTool"/> Name="VCWebServiceProxyGeneratorTool"/>
<Tool <Tool
Name="VCXMLDataGeneratorTool"/> Name="VCXMLDataGeneratorTool"/>
<Tool <Tool
Name="VCWebDeploymentTool"/> Name="VCWebDeploymentTool"/>
<Tool <Tool
Name="VCManagedWrapperGeneratorTool"/> Name="VCManagedWrapperGeneratorTool"/>
<Tool <Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/> Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration> </Configuration>
</Configurations> </Configurations>
<References> <References>
</References> </References>
<Files> <Files>
<File <File
RelativePath="..\..\include\json\autolink.h"> RelativePath="..\..\include\json\autolink.h">
</File> </File>
<File <File
RelativePath="..\..\include\json\config.h"> RelativePath="..\..\include\json\config.h">
</File> </File>
<File <File
RelativePath="..\..\include\json\features.h"> RelativePath="..\..\include\json\features.h">
</File> </File>
<File <File
RelativePath="..\..\include\json\forwards.h"> RelativePath="..\..\include\json\forwards.h">
</File> </File>
<File <File
RelativePath="..\..\include\json\json.h"> RelativePath="..\..\include\json\json.h">
</File> </File>
<File <File
RelativePath="..\..\src\lib_json\json_batchallocator.h"> RelativePath="..\..\src\lib_json\json_batchallocator.h">
</File> </File>
<File <File
RelativePath="..\..\src\lib_json\json_internalarray.inl"> RelativePath="..\..\src\lib_json\json_internalarray.inl">
</File> </File>
<File <File
RelativePath="..\..\src\lib_json\json_internalmap.inl"> RelativePath="..\..\src\lib_json\json_internalmap.inl">
</File> </File>
<File <File
RelativePath="..\..\src\lib_json\json_reader.cpp"> RelativePath="..\..\src\lib_json\json_reader.cpp">
</File> </File>
<File <File
RelativePath="..\..\src\lib_json\json_value.cpp"> RelativePath="..\..\src\lib_json\json_value.cpp">
</File> </File>
<File <File
RelativePath="..\..\src\lib_json\json_valueiterator.inl"> RelativePath="..\..\src\lib_json\json_valueiterator.inl">
</File> </File>
<File <File
RelativePath="..\..\src\lib_json\json_writer.cpp"> RelativePath="..\..\src\lib_json\json_writer.cpp">
</File> </File>
<File <File
RelativePath="..\..\include\json\reader.h"> RelativePath="..\..\include\json\reader.h">
</File> </File>
<File <File
RelativePath="..\..\include\json\value.h"> RelativePath="..\..\include\json\value.h">
</File> </File>
<File <File
RelativePath="..\..\include\json\writer.h"> RelativePath="..\..\include\json\writer.h">
</File> </File>
</Files> </Files>
<Globals> <Globals>
</Globals> </Globals>
</VisualStudioProject> </VisualStudioProject>

508
src/test_lib_json/jsontest.h
View File

@ -1,254 +1,254 @@
#ifndef JSONTEST_H_INCLUDED #ifndef JSONTEST_H_INCLUDED
# define JSONTEST_H_INCLUDED # define JSONTEST_H_INCLUDED
# include <json/config.h> # include <json/config.h>
# include <stdio.h> # include <stdio.h>
# include <deque> # include <deque>
# include <string> # include <string>
// ////////////////////////////////////////////////////////////////// // //////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////// // //////////////////////////////////////////////////////////////////
// Mini Unit Testing framework // Mini Unit Testing framework
// ////////////////////////////////////////////////////////////////// // //////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////// // //////////////////////////////////////////////////////////////////
/** \brief Unit testing framework. /** \brief Unit testing framework.
* \warning: all assertions are non-aborting, test case execution will continue * \warning: all assertions are non-aborting, test case execution will continue
* even if an assertion namespace. * even if an assertion namespace.
* This constraint is for portability: the framework needs to compile * This constraint is for portability: the framework needs to compile
* on Visual Studio 6 and must not require exception usage. * on Visual Studio 6 and must not require exception usage.
*/ */
namespace JsonTest { namespace JsonTest {
class Failure class Failure
{ {
public: public:
const char *file_; const char *file_;
unsigned int line_; unsigned int line_;
std::string expr_; std::string expr_;
std::string message_; std::string message_;
unsigned int nestingLevel_; unsigned int nestingLevel_;
}; };
/// Context used to create the assertion callstack on failure. /// Context used to create the assertion callstack on failure.
/// Must be a POD to allow inline initialisation without stepping /// Must be a POD to allow inline initialisation without stepping
/// into the debugger. /// into the debugger.
struct PredicateContext struct PredicateContext
{ {
typedef unsigned int Id; typedef unsigned int Id;
Id id_; Id id_;
const char *file_; const char *file_;
unsigned int line_; unsigned int line_;
const char *expr_; const char *expr_;
PredicateContext *next_; PredicateContext *next_;
/// Related Failure, set when the PredicateContext is converted /// Related Failure, set when the PredicateContext is converted
/// into a Failure. /// into a Failure.
Failure *failure_; Failure *failure_;
}; };
class TestResult class TestResult
{ {
public: public:
TestResult(); TestResult();
/// \internal Implementation detail for assertion macros /// \internal Implementation detail for assertion macros
/// Not encapsulated to prevent step into when debugging failed assertions /// Not encapsulated to prevent step into when debugging failed assertions
/// Incremented by one on assertion predicate entry, decreased by one /// Incremented by one on assertion predicate entry, decreased by one
/// by addPredicateContext(). /// by addPredicateContext().
PredicateContext::Id predicateId_; PredicateContext::Id predicateId_;
/// \internal Implementation detail for predicate macros /// \internal Implementation detail for predicate macros
PredicateContext *predicateStackTail_; PredicateContext *predicateStackTail_;
void setTestName( const std::string &name ); void setTestName( const std::string &name );
/// Adds an assertion failure. /// Adds an assertion failure.
TestResult &addFailure( const char *file, unsigned int line, TestResult &addFailure( const char *file, unsigned int line,
const char *expr = 0 ); const char *expr = 0 );
/// Removes the last PredicateContext added to the predicate stack /// Removes the last PredicateContext added to the predicate stack
/// chained list. /// chained list.
/// Next messages will be targed at the PredicateContext that was removed. /// Next messages will be targed at the PredicateContext that was removed.
TestResult &popPredicateContext(); TestResult &popPredicateContext();
bool failed() const; bool failed() const;
void printFailure( bool printTestName ) const; void printFailure( bool printTestName ) const;
TestResult &operator << ( bool value ); TestResult &operator << ( bool value );
TestResult &operator << ( int value ); TestResult &operator << ( int value );
TestResult &operator << ( unsigned int value ); TestResult &operator << ( unsigned int value );
TestResult &operator << ( double value ); TestResult &operator << ( double value );
TestResult &operator << ( const char *value ); TestResult &operator << ( const char *value );
TestResult &operator << ( const std::string &value ); TestResult &operator << ( const std::string &value );
private: private:
TestResult &addToLastFailure( const std::string &message ); TestResult &addToLastFailure( const std::string &message );
unsigned int getAssertionNestingLevel() const; unsigned int getAssertionNestingLevel() const;
/// Adds a failure or a predicate context /// Adds a failure or a predicate context
void addFailureInfo( const char *file, unsigned int line, void addFailureInfo( const char *file, unsigned int line,
const char *expr, unsigned int nestingLevel ); const char *expr, unsigned int nestingLevel );
static std::string indentText( const std::string &text, static std::string indentText( const std::string &text,
const std::string &indent ); const std::string &indent );
typedef std::deque<Failure> Failures; typedef std::deque<Failure> Failures;
Failures failures_; Failures failures_;
std::string name_; std::string name_;
PredicateContext rootPredicateNode_; PredicateContext rootPredicateNode_;
PredicateContext::Id lastUsedPredicateId_; PredicateContext::Id lastUsedPredicateId_;
/// Failure which is the target of the messages added using operator << /// Failure which is the target of the messages added using operator <<
Failure *messageTarget_; Failure *messageTarget_;
}; };
class TestCase class TestCase
{ {
public: public:
TestCase(); TestCase();
virtual ~TestCase(); virtual ~TestCase();
void run( TestResult &result ); void run( TestResult &result );
virtual const char *testName() const = 0; virtual const char *testName() const = 0;
protected: protected:
TestResult *result_; TestResult *result_;
private: private:
virtual void runTestCase() = 0; virtual void runTestCase() = 0;
}; };
/// Function pointer type for TestCase factory /// Function pointer type for TestCase factory
typedef TestCase *(*TestCaseFactory)(); typedef TestCase *(*TestCaseFactory)();
class Runner class Runner
{ {
public: public:
Runner(); Runner();
/// Adds a test to the suite /// Adds a test to the suite
Runner &add( TestCaseFactory factory ); Runner &add( TestCaseFactory factory );
/// Runs test as specified on the command-line /// Runs test as specified on the command-line
/// If no command-line arguments are provided, run all tests. /// If no command-line arguments are provided, run all tests.
/// If --list-tests is provided, then print the list of all test cases /// If --list-tests is provided, then print the list of all test cases
/// If --test <testname> is provided, then run test testname. /// If --test <testname> is provided, then run test testname.
int runCommandLine( int argc, const char *argv[] ) const; int runCommandLine( int argc, const char *argv[] ) const;
/// Runs all the test cases /// Runs all the test cases
bool runAllTest( bool printSummary ) const; bool runAllTest( bool printSummary ) const;
/// Returns the number of test case in the suite /// Returns the number of test case in the suite
unsigned int testCount() const; unsigned int testCount() const;
/// Returns the name of the test case at the specified index /// Returns the name of the test case at the specified index
std::string testNameAt( unsigned int index ) const; std::string testNameAt( unsigned int index ) const;
/// Runs the test case at the specified index using the specified TestResult /// Runs the test case at the specified index using the specified TestResult
void runTestAt( unsigned int index, TestResult &result ) const; void runTestAt( unsigned int index, TestResult &result ) const;
static void printUsage( const char *appName ); static void printUsage( const char *appName );
private: // prevents copy construction and assignment private: // prevents copy construction and assignment
Runner( const Runner &other ); Runner( const Runner &other );
Runner &operator =( const Runner &other ); Runner &operator =( const Runner &other );
private: private:
void listTests() const; void listTests() const;
bool testIndex( const std::string &testName, unsigned int &index ) const; bool testIndex( const std::string &testName, unsigned int &index ) const;
static void preventDialogOnCrash(); static void preventDialogOnCrash();
private: private:
typedef std::deque<TestCaseFactory> Factories; typedef std::deque<TestCaseFactory> Factories;
Factories tests_; Factories tests_;
}; };
template<typename T> template<typename T>
TestResult & TestResult &
checkEqual( TestResult &result, const T &expected, const T &actual, checkEqual( TestResult &result, const T &expected, const T &actual,
const char *file, unsigned int line, const char *expr ) const char *file, unsigned int line, const char *expr )
{ {
if ( expected != actual ) if ( expected != actual )
{ {
result.addFailure( file, line, expr ); result.addFailure( file, line, expr );
result << "Expected: " << expected << "\n"; result << "Expected: " << expected << "\n";
result << "Actual : " << actual; result << "Actual : " << actual;
} }
return result; return result;
} }
TestResult & TestResult &
checkStringEqual( TestResult &result, checkStringEqual( TestResult &result,
const std::string &expected, const std::string &actual, const std::string &expected, const std::string &actual,
const char *file, unsigned int line, const char *expr ); const char *file, unsigned int line, const char *expr );
} // namespace JsonTest } // namespace JsonTest
/// \brief Asserts that the given expression is true. /// \brief Asserts that the given expression is true.
/// JSONTEST_ASSERT( x == y ) << "x=" << x << ", y=" << y; /// JSONTEST_ASSERT( x == y ) << "x=" << x << ", y=" << y;
/// JSONTEST_ASSERT( x == y ); /// JSONTEST_ASSERT( x == y );
#define JSONTEST_ASSERT( expr ) \ #define JSONTEST_ASSERT( expr ) \
if ( condition ) \ if ( condition ) \
{ \ { \
} \ } \
else \ else \
result_->addFailure( __FILE__, __LINE__, #expr ) result_->addFailure( __FILE__, __LINE__, #expr )
/// \brief Asserts that the given predicate is true. /// \brief Asserts that the given predicate is true.
/// The predicate may do other assertions and be a member function of the fixture. /// The predicate may do other assertions and be a member function of the fixture.
#define JSONTEST_ASSERT_PRED( expr ) \ #define JSONTEST_ASSERT_PRED( expr ) \
{ \ { \
JsonTest::PredicateContext _minitest_Context = { \ JsonTest::PredicateContext _minitest_Context = { \
result_->predicateId_, __FILE__, __LINE__, #expr }; \ result_->predicateId_, __FILE__, __LINE__, #expr }; \
result_->predicateStackTail_->next_ = &_minitest_Context; \ result_->predicateStackTail_->next_ = &_minitest_Context; \
result_->predicateId_ += 1; \ result_->predicateId_ += 1; \
result_->predicateStackTail_ = &_minitest_Context; \ result_->predicateStackTail_ = &_minitest_Context; \
(expr); \ (expr); \
result_->popPredicateContext(); \ result_->popPredicateContext(); \
} \ } \
*result_ *result_
/// \brief Asserts that two values are equals. /// \brief Asserts that two values are equals.
#define JSONTEST_ASSERT_EQUAL( expected, actual ) \ #define JSONTEST_ASSERT_EQUAL( expected, actual ) \
JsonTest::checkEqual( *result_, expected, actual, \ JsonTest::checkEqual( *result_, expected, actual, \
__FILE__, __LINE__, \ __FILE__, __LINE__, \
#expected " == " #actual ) #expected " == " #actual )
/// \brief Asserts that two values are equals. /// \brief Asserts that two values are equals.
#define JSONTEST_ASSERT_STRING_EQUAL( expected, actual ) \ #define JSONTEST_ASSERT_STRING_EQUAL( expected, actual ) \
JsonTest::checkStringEqual( *result_, \ JsonTest::checkStringEqual( *result_, \
std::string(expected), std::string(actual), \ std::string(expected), std::string(actual), \
#expected " == " #actual ) #expected " == " #actual )
/// \brief Begin a fixture test case. /// \brief Begin a fixture test case.
#define JSONTEST_FIXTURE( FixtureType, name ) \ #define JSONTEST_FIXTURE( FixtureType, name ) \
class Test##FixtureType##name : public FixtureType \ class Test##FixtureType##name : public FixtureType \
{ \ { \
public: \ public: \
static JsonTest::TestCase *factory() \ static JsonTest::TestCase *factory() \
{ \ { \
return new Test##FixtureType##name(); \ return new Test##FixtureType##name(); \
} \ } \
public: /* overidden from TestCase */ \ public: /* overidden from TestCase */ \
virtual const char *testName() const \ virtual const char *testName() const \
{ \ { \
return #FixtureType "/" #name; \ return #FixtureType "/" #name; \
} \ } \
virtual void runTestCase(); \ virtual void runTestCase(); \
}; \ }; \
\ \
void Test##FixtureType##name::runTestCase() void Test##FixtureType##name::runTestCase()
#define JSONTEST_FIXTURE_FACTORY( FixtureType, name ) \ #define JSONTEST_FIXTURE_FACTORY( FixtureType, name ) \
&Test##FixtureType##name::factory &Test##FixtureType##name::factory
#define JSONTEST_REGISTER_FIXTURE( runner, FixtureType, name ) \ #define JSONTEST_REGISTER_FIXTURE( runner, FixtureType, name ) \
(runner).add( JSONTEST_FIXTURE_FACTORY( FixtureType, name ) ) (runner).add( JSONTEST_FIXTURE_FACTORY( FixtureType, name ) )
#endif // ifndef JSONTEST_H_INCLUDED #endif // ifndef JSONTEST_H_INCLUDED

488
src/test_lib_json/main.cpp
View File

@ -1,244 +1,244 @@
#include <json/json.h> #include <json/json.h>
#include "jsontest.h" #include "jsontest.h"
// TODO: // TODO:
// - boolean value returns that they are integral. Should not be. // - boolean value returns that they are integral. Should not be.
// - unsigned integer in integer range are not considered to be valid integer. Should check range. // - unsigned integer in integer range are not considered to be valid integer. Should check range.
// ////////////////////////////////////////////////////////////////// // //////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////// // //////////////////////////////////////////////////////////////////
// Json Library test cases // Json Library test cases
// ////////////////////////////////////////////////////////////////// // //////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////// // //////////////////////////////////////////////////////////////////
struct ValueTest : JsonTest::TestCase struct ValueTest : JsonTest::TestCase
{ {
Json::Value null_; Json::Value null_;
Json::Value emptyArray_; Json::Value emptyArray_;
Json::Value emptyObject_; Json::Value emptyObject_;
Json::Value integer_; Json::Value integer_;
Json::Value unsignedInteger_; Json::Value unsignedInteger_;
Json::Value smallUnsignedInteger_; Json::Value smallUnsignedInteger_;
Json::Value real_; Json::Value real_;
Json::Value array1_; Json::Value array1_;
Json::Value object1_; Json::Value object1_;
Json::Value emptyString_; Json::Value emptyString_;
Json::Value string1_; Json::Value string1_;
Json::Value string_; Json::Value string_;
Json::Value true_; Json::Value true_;
Json::Value false_; Json::Value false_;
ValueTest() ValueTest()
: emptyArray_( Json::arrayValue ) : emptyArray_( Json::arrayValue )
, emptyObject_( Json::objectValue ) , emptyObject_( Json::objectValue )
, integer_( 123456789 ) , integer_( 123456789 )
, smallUnsignedInteger_( Json::Value::UInt( Json::Value::maxInt ) ) , smallUnsignedInteger_( Json::Value::UInt( Json::Value::maxInt ) )
, unsignedInteger_( 34567890u ) , unsignedInteger_( 34567890u )
, real_( 1234.56789 ) , real_( 1234.56789 )
, emptyString_( "" ) , emptyString_( "" )
, string1_( "a" ) , string1_( "a" )
, string_( "sometext with space" ) , string_( "sometext with space" )
, true_( true ) , true_( true )
, false_( false ) , false_( false )
{ {
array1_.append( 1234 ); array1_.append( 1234 );
object1_["id"] = 1234; object1_["id"] = 1234;
} }
struct IsCheck struct IsCheck
{ {
/// Initialize all checks to \c false by default. /// Initialize all checks to \c false by default.
IsCheck(); IsCheck();
bool isObject_; bool isObject_;
bool isArray_; bool isArray_;
bool isBool_; bool isBool_;
bool isDouble_; bool isDouble_;
bool isInt_; bool isInt_;
bool isUInt_; bool isUInt_;
bool isIntegral_; bool isIntegral_;
bool isNumeric_; bool isNumeric_;
bool isString_; bool isString_;
bool isNull_; bool isNull_;
}; };
void checkConstMemberCount( const Json::Value &value, unsigned int expectedCount ); void checkConstMemberCount( const Json::Value &value, unsigned int expectedCount );
void checkMemberCount( Json::Value &value, unsigned int expectedCount ); void checkMemberCount( Json::Value &value, unsigned int expectedCount );
void checkIs( const Json::Value &value, const IsCheck &check ); void checkIs( const Json::Value &value, const IsCheck &check );
}; };
JSONTEST_FIXTURE( ValueTest, size ) JSONTEST_FIXTURE( ValueTest, size )
{ {
JSONTEST_ASSERT_PRED( checkMemberCount(emptyArray_, 0) ); JSONTEST_ASSERT_PRED( checkMemberCount(emptyArray_, 0) );
JSONTEST_ASSERT_PRED( checkMemberCount(emptyObject_, 0) ); JSONTEST_ASSERT_PRED( checkMemberCount(emptyObject_, 0) );
JSONTEST_ASSERT_PRED( checkMemberCount(array1_, 1) ); JSONTEST_ASSERT_PRED( checkMemberCount(array1_, 1) );
JSONTEST_ASSERT_PRED( checkMemberCount(object1_, 1) ); JSONTEST_ASSERT_PRED( checkMemberCount(object1_, 1) );
JSONTEST_ASSERT_PRED( checkMemberCount(null_, 0) ); JSONTEST_ASSERT_PRED( checkMemberCount(null_, 0) );
JSONTEST_ASSERT_PRED( checkMemberCount(integer_, 0) ); JSONTEST_ASSERT_PRED( checkMemberCount(integer_, 0) );
JSONTEST_ASSERT_PRED( checkMemberCount(real_, 0) ); JSONTEST_ASSERT_PRED( checkMemberCount(real_, 0) );
JSONTEST_ASSERT_PRED( checkMemberCount(emptyString_, 0) ); JSONTEST_ASSERT_PRED( checkMemberCount(emptyString_, 0) );
JSONTEST_ASSERT_PRED( checkMemberCount(string_, 0) ); JSONTEST_ASSERT_PRED( checkMemberCount(string_, 0) );
JSONTEST_ASSERT_PRED( checkMemberCount(true_, 0) ); JSONTEST_ASSERT_PRED( checkMemberCount(true_, 0) );
} }
JSONTEST_FIXTURE( ValueTest, isObject ) JSONTEST_FIXTURE( ValueTest, isObject )
{ {
IsCheck checks; IsCheck checks;
checks.isObject_ = true; checks.isObject_ = true;
JSONTEST_ASSERT_PRED( checkIs( emptyObject_, checks ) ); JSONTEST_ASSERT_PRED( checkIs( emptyObject_, checks ) );
JSONTEST_ASSERT_PRED( checkIs( object1_, checks ) ); JSONTEST_ASSERT_PRED( checkIs( object1_, checks ) );
} }
JSONTEST_FIXTURE( ValueTest, isArray ) JSONTEST_FIXTURE( ValueTest, isArray )
{ {
IsCheck checks; IsCheck checks;
checks.isArray_ = true; checks.isArray_ = true;
JSONTEST_ASSERT_PRED( checkIs( emptyArray_, checks ) ); JSONTEST_ASSERT_PRED( checkIs( emptyArray_, checks ) );
JSONTEST_ASSERT_PRED( checkIs( array1_, checks ) ); JSONTEST_ASSERT_PRED( checkIs( array1_, checks ) );
} }
JSONTEST_FIXTURE( ValueTest, isNull ) JSONTEST_FIXTURE( ValueTest, isNull )
{ {
IsCheck checks; IsCheck checks;
checks.isNull_ = true; checks.isNull_ = true;
checks.isObject_ = true; checks.isObject_ = true;
checks.isArray_ = true; checks.isArray_ = true;
JSONTEST_ASSERT_PRED( checkIs( null_, checks ) ); JSONTEST_ASSERT_PRED( checkIs( null_, checks ) );
} }
JSONTEST_FIXTURE( ValueTest, isString ) JSONTEST_FIXTURE( ValueTest, isString )
{ {
IsCheck checks; IsCheck checks;
checks.isString_ = true; checks.isString_ = true;
JSONTEST_ASSERT_PRED( checkIs( emptyString_, checks ) ); JSONTEST_ASSERT_PRED( checkIs( emptyString_, checks ) );
JSONTEST_ASSERT_PRED( checkIs( string_, checks ) ); JSONTEST_ASSERT_PRED( checkIs( string_, checks ) );
JSONTEST_ASSERT_PRED( checkIs( string1_, checks ) ); JSONTEST_ASSERT_PRED( checkIs( string1_, checks ) );
} }
JSONTEST_FIXTURE( ValueTest, isBool ) JSONTEST_FIXTURE( ValueTest, isBool )
{ {
IsCheck checks; IsCheck checks;
checks.isBool_ = true; checks.isBool_ = true;
checks.isIntegral_ = true; checks.isIntegral_ = true;
checks.isNumeric_ = true; checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED( checkIs( false_, checks ) ); JSONTEST_ASSERT_PRED( checkIs( false_, checks ) );
JSONTEST_ASSERT_PRED( checkIs( true_, checks ) ); JSONTEST_ASSERT_PRED( checkIs( true_, checks ) );
} }
JSONTEST_FIXTURE( ValueTest, isDouble ) JSONTEST_FIXTURE( ValueTest, isDouble )
{ {
IsCheck checks; IsCheck checks;
checks.isDouble_ = true; checks.isDouble_ = true;
checks.isNumeric_ = true; checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED( checkIs( real_, checks ) ); JSONTEST_ASSERT_PRED( checkIs( real_, checks ) );
} }
JSONTEST_FIXTURE( ValueTest, isInt ) JSONTEST_FIXTURE( ValueTest, isInt )
{ {
IsCheck checks; IsCheck checks;
checks.isInt_ = true; checks.isInt_ = true;
checks.isNumeric_ = true; checks.isNumeric_ = true;
checks.isIntegral_ = true; checks.isIntegral_ = true;
JSONTEST_ASSERT_PRED( checkIs( integer_, checks ) ); JSONTEST_ASSERT_PRED( checkIs( integer_, checks ) );
} }
JSONTEST_FIXTURE( ValueTest, isUInt ) JSONTEST_FIXTURE( ValueTest, isUInt )
{ {
IsCheck checks; IsCheck checks;
checks.isUInt_ = true; checks.isUInt_ = true;
checks.isNumeric_ = true; checks.isNumeric_ = true;
checks.isIntegral_ = true; checks.isIntegral_ = true;
JSONTEST_ASSERT_PRED( checkIs( unsignedInteger_, checks ) ); JSONTEST_ASSERT_PRED( checkIs( unsignedInteger_, checks ) );
JSONTEST_ASSERT_PRED( checkIs( smallUnsignedInteger_, checks ) ); JSONTEST_ASSERT_PRED( checkIs( smallUnsignedInteger_, checks ) );
} }
void void
ValueTest::checkConstMemberCount( const Json::Value &value, unsigned int expectedCount ) ValueTest::checkConstMemberCount( const Json::Value &value, unsigned int expectedCount )
{ {
unsigned int count = 0; unsigned int count = 0;
Json::Value::const_iterator itEnd = value.end(); Json::Value::const_iterator itEnd = value.end();
for ( Json::Value::const_iterator it = value.begin(); it != itEnd; ++it ) for ( Json::Value::const_iterator it = value.begin(); it != itEnd; ++it )
{ {
++count; ++count;
} }
JSONTEST_ASSERT_EQUAL( expectedCount, count ) << "Json::Value::const_iterator"; JSONTEST_ASSERT_EQUAL( expectedCount, count ) << "Json::Value::const_iterator";
} }
void void
ValueTest::checkMemberCount( Json::Value &value, unsigned int expectedCount ) ValueTest::checkMemberCount( Json::Value &value, unsigned int expectedCount )
{ {
JSONTEST_ASSERT_EQUAL( expectedCount, value.size() ); JSONTEST_ASSERT_EQUAL( expectedCount, value.size() );
unsigned int count = 0; unsigned int count = 0;
Json::Value::iterator itEnd = value.end(); Json::Value::iterator itEnd = value.end();
for ( Json::Value::iterator it = value.begin(); it != itEnd; ++it ) for ( Json::Value::iterator it = value.begin(); it != itEnd; ++it )
{ {
++count; ++count;
} }
JSONTEST_ASSERT_EQUAL( expectedCount, count ) << "Json::Value::iterator"; JSONTEST_ASSERT_EQUAL( expectedCount, count ) << "Json::Value::iterator";
JSONTEST_ASSERT_PRED( checkConstMemberCount(value, expectedCount) ); JSONTEST_ASSERT_PRED( checkConstMemberCount(value, expectedCount) );
} }
ValueTest::IsCheck::IsCheck() ValueTest::IsCheck::IsCheck()
: isObject_( false ) : isObject_( false )
, isArray_( false ) , isArray_( false )
, isBool_( false ) , isBool_( false )
, isDouble_( false ) , isDouble_( false )
, isInt_( false ) , isInt_( false )
, isUInt_( false ) , isUInt_( false )
, isIntegral_( false ) , isIntegral_( false )
, isNumeric_( false ) , isNumeric_( false )
, isString_( false ) , isString_( false )
, isNull_( false ) , isNull_( false )
{ {
} }
void void
ValueTest::checkIs( const Json::Value &value, const IsCheck &check ) ValueTest::checkIs( const Json::Value &value, const IsCheck &check )
{ {
JSONTEST_ASSERT_EQUAL( check.isObject_, value.isObject() ); JSONTEST_ASSERT_EQUAL( check.isObject_, value.isObject() );
JSONTEST_ASSERT_EQUAL( check.isArray_, value.isArray() ); JSONTEST_ASSERT_EQUAL( check.isArray_, value.isArray() );
JSONTEST_ASSERT_EQUAL( check.isBool_, value.isBool() ); JSONTEST_ASSERT_EQUAL( check.isBool_, value.isBool() );
JSONTEST_ASSERT_EQUAL( check.isDouble_, value.isDouble() ); JSONTEST_ASSERT_EQUAL( check.isDouble_, value.isDouble() );
JSONTEST_ASSERT_EQUAL( check.isInt_, value.isInt() ); JSONTEST_ASSERT_EQUAL( check.isInt_, value.isInt() );
JSONTEST_ASSERT_EQUAL( check.isUInt_, value.isUInt() ); JSONTEST_ASSERT_EQUAL( check.isUInt_, value.isUInt() );
JSONTEST_ASSERT_EQUAL( check.isIntegral_, value.isIntegral() ); JSONTEST_ASSERT_EQUAL( check.isIntegral_, value.isIntegral() );
JSONTEST_ASSERT_EQUAL( check.isNumeric_, value.isNumeric() ); JSONTEST_ASSERT_EQUAL( check.isNumeric_, value.isNumeric() );
JSONTEST_ASSERT_EQUAL( check.isString_, value.isString() ); JSONTEST_ASSERT_EQUAL( check.isString_, value.isString() );
JSONTEST_ASSERT_EQUAL( check.isNull_, value.isNull() ); JSONTEST_ASSERT_EQUAL( check.isNull_, value.isNull() );
} }
int main( int argc, const char *argv[] ) int main( int argc, const char *argv[] )
{ {
JsonTest::Runner runner; JsonTest::Runner runner;
JSONTEST_REGISTER_FIXTURE( runner, ValueTest, size ); JSONTEST_REGISTER_FIXTURE( runner, ValueTest, size );
JSONTEST_REGISTER_FIXTURE( runner, ValueTest, isObject ); JSONTEST_REGISTER_FIXTURE( runner, ValueTest, isObject );
JSONTEST_REGISTER_FIXTURE( runner, ValueTest, isArray ); JSONTEST_REGISTER_FIXTURE( runner, ValueTest, isArray );
JSONTEST_REGISTER_FIXTURE( runner, ValueTest, isBool ); JSONTEST_REGISTER_FIXTURE( runner, ValueTest, isBool );
JSONTEST_REGISTER_FIXTURE( runner, ValueTest, isInt ); JSONTEST_REGISTER_FIXTURE( runner, ValueTest, isInt );
JSONTEST_REGISTER_FIXTURE( runner, ValueTest, isUInt ); JSONTEST_REGISTER_FIXTURE( runner, ValueTest, isUInt );
JSONTEST_REGISTER_FIXTURE( runner, ValueTest, isDouble ); JSONTEST_REGISTER_FIXTURE( runner, ValueTest, isDouble );
JSONTEST_REGISTER_FIXTURE( runner, ValueTest, isString ); JSONTEST_REGISTER_FIXTURE( runner, ValueTest, isString );
JSONTEST_REGISTER_FIXTURE( runner, ValueTest, isNull ); JSONTEST_REGISTER_FIXTURE( runner, ValueTest, isNull );
return runner.runCommandLine( argc, argv ); return runner.runCommandLine( argc, argv );
} }

20
src/test_lib_json/sconscript
View File

@ -1,10 +1,10 @@
Import( 'env_testing buildUnitTests' ) Import( 'env_testing buildUnitTests' )
buildUnitTests( env_testing, Split( """ buildUnitTests( env_testing, Split( """
main.cpp main.cpp
jsontest.cpp jsontest.cpp
""" ), """ ),
'test_lib_json' ) 'test_lib_json' )
# For 'check' to work, 'libs' must be built first. # For 'check' to work, 'libs' must be built first.
env_testing.Depends('test_lib_json', '#libs') env_testing.Depends('test_lib_json', '#libs')