readertest.cpp File Reference

#include "unittest.h"
#include "rapidjson/reader.h"
#include "rapidjson/internal/dtoa.h"
#include "rapidjson/internal/itoa.h"
#include "rapidjson/memorystream.h"
#include <limits>
#include <sstream>

Include dependency graph for readertest.cpp:

Classes
struct	ParseBoolHandler< expect >
struct	ParseIntHandler
struct	ParseUintHandler
struct	ParseInt64Handler
struct	ParseUint64Handler
struct	ParseDoubleHandler
struct	ParseStringHandler< Encoding >
struct	ParseArrayHandler< count >
struct	ParseObjectHandler
struct	ParseEmptyObjectHandler
struct	ParseMultipleRootHandler
class	CustomStringStream< Encoding >
class	IStreamWrapper
struct	IterativeParsingReaderHandler< Encoding >
struct	HandlerTerminateAtStartObject
struct	HandlerTerminateAtStartArray
struct	HandlerTerminateAtEndObject
struct	HandlerTerminateAtEndArray
struct	TerminateHandler< e >
struct	NumbersAsStringsHandler

Macros
#define	TEST_INTEGER(Handler, str, x)
#define	TEST_DOUBLE(fullPrecision, str, x)
#define	TEST_NUMBER_ERROR(errorCode, str, errorOffset, streamPos)
#define	TEST_STRING(Encoding, e, x)
#define	ARRAY(...)   { __VA_ARGS__ }
#define	TEST_STRINGARRAY(Encoding, utype, array, x)
#define	TEST_STRINGARRAY2(Encoding, utype, earray, xarray)
#define	TEST_STRING_ERROR(errorCode, str, errorOffset, streamPos)
#define	ARRAY(...)   { __VA_ARGS__ }
#define	TEST_STRINGENCODING_ERROR(Encoding, TargetEncoding, utype, array)
#define	TEST_ARRAY_ERROR(errorCode, str, errorOffset)
#define	TEST_ERROR(errorCode, str, errorOffset)
#define	TESTERRORHANDLING(text, errorCode, offset)
#define	TEST_TERMINATION(e, json)
#define	TEST_NAN_INF(str, x)
#define	TEST_NAN_INF_ERROR(errorCode, str, errorOffset)

Functions
	TEST (Reader, ParseTrue)
	TEST (Reader, ParseFalse)
	TEST (Reader, ParseNumber_Integer)
template<bool fullPrecision>
static void	TestParseDouble ()
	TEST (Reader, ParseNumber_NormalPrecisionDouble)
	TEST (Reader, ParseNumber_FullPrecisionDouble)
	TEST (Reader, ParseNumber_NormalPrecisionError)
template<bool fullPrecision>
static void	TestParseNumberError ()
	TEST (Reader, ParseNumberError_NormalPrecisionDouble)
	TEST (Reader, ParseNumberError_FullPrecisionDouble)
	TEST (Reader, ParseString)
	TEST (Reader, ParseString_Transcoding)
	TEST (Reader, ParseString_TranscodingWithValidation)
	TEST (Reader, ParseString_NonDestructive)
template<typename Encoding >
ParseErrorCode	TestString (const typename Encoding::Ch *str)
	TEST (Reader, ParseString_Error)
	TEST (Reader, ParseEmptyArray)
	TEST (Reader, ParseArray)
	TEST (Reader, ParseArray_Error)
	TEST (Reader, ParseObject)
	TEST (Reader, Parse_EmptyObject)
template<unsigned parseFlags>
void	TestMultipleRoot ()
	TEST (Reader, Parse_MultipleRoot)
	TEST (Reader, ParseIterative_MultipleRoot)
template<unsigned parseFlags>
void	TestInsituMultipleRoot ()
	TEST (Reader, ParseInsitu_MultipleRoot)
	TEST (Reader, ParseInsituIterative_MultipleRoot)
	TEST (Reader, ParseDocument_Error)
	TEST (Reader, ParseValue_Error)
	TEST (Reader, ParseObject_Error)
	TEST (Reader, SkipWhitespace)
	TEST (Reader, CustomStringStream)
	TEST (Reader, Parse_IStreamWrapper_StringStream)
	TEST (Reader, IterativeParsing_ErrorHandling)
	TEST (Reader, IterativeParsing_General)
	TEST (Reader, IterativeParsing_Count)
	TEST (Reader, IterativePullParsing_General)
	TEST (Reader, IterativeParsing_ShortCircuit)
	TEST (Reader, BaseReaderHandler_Default)
	TEST (Reader, ParseTerminationByHandler)
	TEST (Reader, ParseComments)
	TEST (Reader, ParseEmptyInlineComment)
	TEST (Reader, ParseEmptyOnelineComment)
	TEST (Reader, ParseMultipleCommentsInARow)
	TEST (Reader, InlineCommentsAreDisabledByDefault)
	TEST (Reader, OnelineCommentsAreDisabledByDefault)
	TEST (Reader, EofAfterOneLineComment)
	TEST (Reader, IncompleteMultilineComment)
	TEST (Reader, IncompleteMultilineComment2)
	TEST (Reader, UnrecognizedComment)
	TEST (Reader, NumbersAsStrings)
template<unsigned extraFlags>
void	TestTrailingCommas ()
	TEST (Reader, TrailingCommas)
	TEST (Reader, TrailingCommasIterative)
template<unsigned extraFlags>
void	TestMultipleTrailingCommaErrors ()
	TEST (Reader, MultipleTrailingCommaErrors)
	TEST (Reader, MultipleTrailingCommaErrorsIterative)
template<unsigned extraFlags>
void	TestEmptyExceptForCommaErrors ()
	TEST (Reader, EmptyExceptForCommaErrors)
	TEST (Reader, EmptyExceptForCommaErrorsIterative)
template<unsigned extraFlags>
void	TestTrailingCommaHandlerTermination ()
	TEST (Reader, TrailingCommaHandlerTermination)
	TEST (Reader, TrailingCommaHandlerTerminationIterative)
	TEST (Reader, ParseNanAndInfinity)

Macro Definition Documentation

ARRAY [1/2]

#define ARRAY

(

...

)

{ __VA_ARGS__ }

ARRAY [2/2]

#define ARRAY

(

...

)

{ __VA_ARGS__ }

TEST_ARRAY_ERROR

#define TEST_ARRAY_ERROR	(		errorCode,
			str,
			errorOffset
	)

Value:

    { \
        int streamPos = errorOffset; \
        char buffer[1001]; \
        strncpy(buffer, str, 1000); \
        InsituStringStream s(buffer); \
        BaseReaderHandler<> h; \
        GenericReader<UTF8<>, UTF8<>, CrtAllocator> reader; \
        EXPECT_FALSE(reader.Parse(s, h)); \
        EXPECT_EQ(errorCode, reader.GetParseErrorCode());\
        EXPECT_EQ(errorOffset, reader.GetErrorOffset());\
        EXPECT_EQ(streamPos, s.Tell());\
    }

TEST_DOUBLE

#define TEST_DOUBLE	(		fullPrecision,
			str,
			x
	)

Value:

    { \
        StringStream s(str); \
        ParseDoubleHandler h; \
        Reader reader; \
        ASSERT_EQ(kParseErrorNone, reader.Parse<fullPrecision ? kParseFullPrecisionFlag : 0>(s, h).Code()); \
        EXPECT_EQ(1u, h.step_); \
        internal::Double e(x), a(h.actual_); \
        if (fullPrecision) { \
            EXPECT_EQ(e.Uint64Value(), a.Uint64Value()); \
            if (e.Uint64Value() != a.Uint64Value()) \
                printf("  String: %s\n  Actual: %.17g\nExpected: %.17g\n", str, h.actual_, x); \
        } \
        else { \
            EXPECT_EQ(e.Sign(), a.Sign()); /* for 0.0 != -0.0 */ \
            EXPECT_DOUBLE_EQ(x, h.actual_); \
        } \
    }

TEST_ERROR

#define TEST_ERROR	(		errorCode,
			str,
			errorOffset
	)

Value:

    { \
        int streamPos = errorOffset; \
        char buffer[1001]; \
        strncpy(buffer, str, 1000); \
        InsituStringStream s(buffer); \
        BaseReaderHandler<> h; \
        Reader reader; \
        EXPECT_FALSE(reader.Parse(s, h)); \
        EXPECT_EQ(errorCode, reader.GetParseErrorCode());\
        EXPECT_EQ(errorOffset, reader.GetErrorOffset());\
        EXPECT_EQ(streamPos, s.Tell());\
    }

TEST_INTEGER

#define TEST_INTEGER	(		Handler,
			str,
			x
	)

Value:

    { \
        StringStream s(str); \
        Handler h; \
        Reader reader; \
        reader.Parse(s, h); \
        EXPECT_EQ(1u, h.step_); \
        EXPECT_EQ(x, h.actual_); \
    }

TEST_NAN_INF

#define TEST_NAN_INF	(		str,
			x
	)

Value:

    { \
        { \
            StringStream s(str); \
            ParseDoubleHandler h; \
            Reader reader; \
            ASSERT_EQ(kParseErrorNone, reader.Parse<kParseNanAndInfFlag>(s, h).Code()); \
            EXPECT_EQ(1u, h.step_); \
            internal::Double e(x), a(h.actual_); \
            EXPECT_EQ(e.IsNan(), a.IsNan()); \
            EXPECT_EQ(e.IsInf(), a.IsInf()); \
            if (!e.IsNan()) \
                EXPECT_EQ(e.Sign(), a.Sign()); \
        } \
        { \
            const char* json = "{ \"naninfdouble\": " str " } "; \
            StringStream s(json); \
            NumbersAsStringsHandler h(str); \
            Reader reader; \
            EXPECT_TRUE(reader.Parse<kParseNumbersAsStringsFlag|kParseNanAndInfFlag>(s, h)); \
        } \
        { \
            char* json = StrDup("{ \"naninfdouble\": " str " } "); \
            InsituStringStream s(json); \
            NumbersAsStringsHandler h(str); \
            Reader reader; \
            EXPECT_TRUE(reader.Parse<kParseInsituFlag|kParseNumbersAsStringsFlag|kParseNanAndInfFlag>(s, h)); \
            free(json); \
        } \
    }

TEST_NAN_INF_ERROR

#define TEST_NAN_INF_ERROR	(		errorCode,
			str,
			errorOffset
	)

Value:

    { \
        int streamPos = errorOffset; \
        char buffer[1001]; \
        strncpy(buffer, str, 1000); \
        InsituStringStream s(buffer); \
        BaseReaderHandler<> h; \
        Reader reader; \
        EXPECT_FALSE(reader.Parse<kParseNanAndInfFlag>(s, h)); \
        EXPECT_EQ(errorCode, reader.GetParseErrorCode());\
        EXPECT_EQ(errorOffset, reader.GetErrorOffset());\
        EXPECT_EQ(streamPos, s.Tell());\
    }

TEST_NUMBER_ERROR

#define TEST_NUMBER_ERROR	(		errorCode,
			str,
			errorOffset,
			streamPos
	)

Value:

    { \
        char buffer[2048]; \
        ASSERT_LT(std::strlen(str), 2048u); \
        sprintf(buffer, "%s", str); \
        InsituStringStream s(buffer); \
        BaseReaderHandler<> h; \
        Reader reader; \
        EXPECT_FALSE(reader.Parse<fullPrecision ? kParseFullPrecisionFlag : 0>(s, h)); \
        EXPECT_EQ(errorCode, reader.GetParseErrorCode());\
        EXPECT_EQ(errorOffset, reader.GetErrorOffset());\
        EXPECT_EQ(streamPos, s.Tell());\
    }

TEST_STRING

#define TEST_STRING	(		Encoding,
			e,
			x
	)

Value:

    { \
        Encoding::Ch* buffer = StrDup(x); \
        GenericInsituStringStream<Encoding> is(buffer); \
        ParseStringHandler<Encoding> h; \
        GenericReader<Encoding, Encoding> reader; \
        reader.Parse<kParseInsituFlag | kParseValidateEncodingFlag>(is, h); \
        EXPECT_EQ(0, StrCmp<Encoding::Ch>(e, h.str_)); \
        EXPECT_EQ(StrLen(e), h.length_); \
        free(buffer); \
        GenericStringStream<Encoding> s(x); \
        ParseStringHandler<Encoding> h2; \
        GenericReader<Encoding, Encoding> reader2; \
        reader2.Parse(s, h2); \
        EXPECT_EQ(0, StrCmp<Encoding::Ch>(e, h2.str_)); \
        EXPECT_EQ(StrLen(e), h2.length_); \
    }

TEST_STRING_ERROR

#define TEST_STRING_ERROR	(		errorCode,
			str,
			errorOffset,
			streamPos
	)

Value:

{\
    GenericStringStream<UTF8<> > s(str);\
    BaseReaderHandler<UTF8<> > h;\
    GenericReader<UTF8<> , UTF8<> > reader;\
    reader.Parse<kParseValidateEncodingFlag>(s, h);\
    EXPECT_EQ(errorCode, reader.GetParseErrorCode());\
    EXPECT_EQ(errorOffset, reader.GetErrorOffset());\
    EXPECT_EQ(streamPos, s.Tell());\
}

TEST_STRINGARRAY

#define TEST_STRINGARRAY	(		Encoding,
			utype,
			array,
			x
	)

Value:

    { \
        static const utype ue[] = array; \
        static const Encoding::Ch* e = reinterpret_cast<const Encoding::Ch *>(&ue[0]); \
        TEST_STRING(Encoding, e, x); \
    }

TEST_STRINGARRAY2

#define TEST_STRINGARRAY2	(		Encoding,
			utype,
			earray,
			xarray
	)

Value:

    { \
        static const utype ue[] = earray; \
        static const utype xe[] = xarray; \
        static const Encoding::Ch* e = reinterpret_cast<const Encoding::Ch *>(&ue[0]); \
        static const Encoding::Ch* x = reinterpret_cast<const Encoding::Ch *>(&xe[0]); \
        TEST_STRING(Encoding, e, x); \
    }

TEST_STRINGENCODING_ERROR

#define TEST_STRINGENCODING_ERROR	(		Encoding,
			TargetEncoding,
			utype,
			array
	)

Value:

    { \
        static const utype ue[] = array; \
        static const Encoding::Ch* e = reinterpret_cast<const Encoding::Ch *>(&ue[0]); \
        EXPECT_EQ(kParseErrorStringInvalidEncoding, TestString<Encoding>(e));\
        /* decode error */\
        GenericStringStream<Encoding> s(e);\
        BaseReaderHandler<TargetEncoding> h;\
        GenericReader<Encoding, TargetEncoding> reader;\
        reader.Parse(s, h);\
        EXPECT_EQ(kParseErrorStringInvalidEncoding, reader.GetParseErrorCode());\
    }

TEST_TERMINATION

#define TEST_TERMINATION	(		e,
			json
	)

Value:

{\
    Reader reader;\
    TerminateHandler<e> h;\
    StringStream is(json);\
    EXPECT_FALSE(reader.Parse(is, h));\
    EXPECT_EQ(kParseErrorTermination, reader.GetParseErrorCode());\
}

TESTERRORHANDLING

#define TESTERRORHANDLING	(		text,
			errorCode,
			offset
	)

Value:

{\
    int streamPos = offset; \
    StringStream json(text); \
    BaseReaderHandler<> handler; \
    Reader reader; \
    reader.Parse<kParseIterativeFlag>(json, handler); \
    EXPECT_TRUE(reader.HasParseError()); \
    EXPECT_EQ(errorCode, reader.GetParseErrorCode()); \
    EXPECT_EQ(offset, reader.GetErrorOffset()); \
    EXPECT_EQ(streamPos, json.Tell()); \
}

Function Documentation

TEST() [1/55]

TEST	(	Reader	,
		BaseReaderHandler_Default
	)

TEST() [2/55]

TEST	(	Reader	,
		CustomStringStream
	)

TEST() [3/55]

TEST	(	Reader	,
		EmptyExceptForCommaErrors
	)

TEST() [4/55]

TEST	(	Reader	,
		EmptyExceptForCommaErrorsIterative
	)

TEST() [5/55]

TEST	(	Reader	,
		EofAfterOneLineComment
	)

TEST() [6/55]

TEST	(	Reader	,
		IncompleteMultilineComment
	)

TEST() [7/55]

TEST	(	Reader	,
		IncompleteMultilineComment2
	)

TEST() [8/55]

TEST	(	Reader	,
		InlineCommentsAreDisabledByDefault
	)

TEST() [9/55]

TEST	(	Reader	,
		IterativeParsing_Count
	)

TEST() [10/55]

TEST	(	Reader	,
		IterativeParsing_ErrorHandling
	)

TEST() [11/55]

TEST	(	Reader	,
		IterativeParsing_General
	)

TEST() [12/55]

TEST	(	Reader	,
		IterativeParsing_ShortCircuit
	)

TEST() [13/55]

TEST	(	Reader	,
		IterativePullParsing_General
	)

TEST() [14/55]

TEST	(	Reader	,
		MultipleTrailingCommaErrors
	)

TEST() [15/55]

TEST	(	Reader	,
		MultipleTrailingCommaErrorsIterative
	)

TEST() [16/55]

TEST	(	Reader	,
		NumbersAsStrings
	)

TEST() [17/55]

TEST	(	Reader	,
		OnelineCommentsAreDisabledByDefault
	)

TEST() [18/55]

TEST	(	Reader	,
		Parse_EmptyObject
	)

TEST() [19/55]

TEST	(	Reader	,
		Parse_IStreamWrapper_StringStream
	)

TEST() [20/55]

TEST	(	Reader	,
		Parse_MultipleRoot
	)

TEST() [21/55]

TEST	(	Reader	,
		ParseArray
	)

TEST() [22/55]

TEST	(	Reader	,
		ParseArray_Error
	)

TEST() [23/55]

TEST	(	Reader	,
		ParseComments
	)

TEST() [24/55]

TEST	(	Reader	,
		ParseDocument_Error
	)

TEST() [25/55]

TEST	(	Reader	,
		ParseEmptyArray
	)

TEST() [26/55]

TEST	(	Reader	,
		ParseEmptyInlineComment
	)

TEST() [27/55]

TEST	(	Reader	,
		ParseEmptyOnelineComment
	)

TEST() [28/55]

TEST	(	Reader	,
		ParseFalse
	)

TEST() [29/55]

TEST	(	Reader	,
		ParseInsitu_MultipleRoot
	)

TEST() [30/55]

TEST	(	Reader	,
		ParseInsituIterative_MultipleRoot
	)

TEST() [31/55]

TEST	(	Reader	,
		ParseIterative_MultipleRoot
	)

TEST() [32/55]

TEST	(	Reader	,
		ParseMultipleCommentsInARow
	)

TEST() [33/55]

TEST	(	Reader	,
		ParseNanAndInfinity
	)

TEST() [34/55]

TEST	(	Reader	,
		ParseNumber_FullPrecisionDouble
	)

TEST() [35/55]

TEST	(	Reader	,
		ParseNumber_Integer
	)

TEST() [36/55]

TEST	(	Reader	,
		ParseNumber_NormalPrecisionDouble
	)

TEST() [37/55]

TEST	(	Reader	,
		ParseNumber_NormalPrecisionError
	)

TEST() [38/55]

TEST	(	Reader	,
		ParseNumberError_FullPrecisionDouble
	)

TEST() [39/55]

TEST	(	Reader	,
		ParseNumberError_NormalPrecisionDouble
	)

TEST() [40/55]

TEST	(	Reader	,
		ParseObject
	)

TEST() [41/55]

TEST	(	Reader	,
		ParseObject_Error
	)

TEST() [42/55]

TEST	(	Reader	,
		ParseString
	)

TEST() [43/55]

TEST	(	Reader	,
		ParseString_Error
	)

TEST() [44/55]

TEST	(	Reader	,
		ParseString_NonDestructive
	)

TEST() [45/55]

TEST	(	Reader	,
		ParseString_Transcoding
	)

TEST() [46/55]

TEST	(	Reader	,
		ParseString_TranscodingWithValidation
	)

TEST() [47/55]

TEST	(	Reader	,
		ParseTerminationByHandler
	)

TEST() [48/55]

TEST	(	Reader	,
		ParseTrue
	)

TEST() [49/55]

TEST	(	Reader	,
		ParseValue_Error
	)

TEST() [50/55]

TEST	(	Reader	,
		SkipWhitespace
	)

TEST() [51/55]

TEST	(	Reader	,
		TrailingCommaHandlerTermination
	)

TEST() [52/55]

TEST	(	Reader	,
		TrailingCommaHandlerTerminationIterative
	)

TEST() [53/55]

TEST	(	Reader	,
		TrailingCommas
	)

TEST() [54/55]

TEST	(	Reader	,
		TrailingCommasIterative
	)

TEST() [55/55]

TEST	(	Reader	,
		UnrecognizedComment
	)

TestEmptyExceptForCommaErrors()

template<unsigned extraFlags>

void TestEmptyExceptForCommaErrors

(

)

TestInsituMultipleRoot()

template<unsigned parseFlags>

void TestInsituMultipleRoot

(

)

TestMultipleRoot()

template<unsigned parseFlags>

void TestMultipleRoot

(

)

TestMultipleTrailingCommaErrors()

template<unsigned extraFlags>

void TestMultipleTrailingCommaErrors

(

)

TestParseDouble()

template<bool fullPrecision>

static void TestParseDouble ( )

static

TestParseNumberError()

template<bool fullPrecision>

static void TestParseNumberError ( )

static

TestString()

template<typename Encoding >

ParseErrorCode TestString

(

const typename Encoding::Ch *

str

)

TestTrailingCommaHandlerTermination()

template<unsigned extraFlags>

void TestTrailingCommaHandlerTermination

(

)

TestTrailingCommas()

template<unsigned extraFlags>

void TestTrailingCommas

(

)