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:

Go to the source code of this file.

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(...)
#define	TEST_STRINGARRAY(Encoding, utype, array, x)
#define	TEST_STRINGARRAY2(Encoding, utype, earray, xarray)
#define	TEST_STRING_ERROR(errorCode, str, errorOffset, streamPos)
#define	ARRAY(...)
#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)
	TEST (Reader, ParseNumber_NormalPrecisionDouble)
	TEST (Reader, ParseNumber_FullPrecisionDouble)
	TEST (Reader, ParseNumber_NormalPrecisionError)
	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

(

...

)

Value:

{ __VA_ARGS__ }

ARRAY [2/2]

#define ARRAY

(

...

)

Value:

{ __VA_ARGS__ }

TEST_ARRAY_ERROR

#define TEST_ARRAY_ERROR	(		errorCode,
			str,
			errorOffset )

Value:

    { \
        unsigned 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:

    { \
        unsigned 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());\
    }

Definition at line 1231 of file readertest.cpp.

#define TEST_ERROR(errorCode, str, errorOffset) \
    { \
        unsigned 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:

    { \
        unsigned 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());\
}

Definition at line 1727 of file readertest.cpp.

#define TEST_TERMINATION(e, json)\
{\
    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:

{\
    unsigned 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()); \
}

Definition at line 1406 of file readertest.cpp.

#define TESTERRORHANDLING(text, errorCode, offset)\
{\
    unsigned 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	)

Definition at line 1702 of file readertest.cpp.

                                        {
    BaseReaderHandler<> h;
    Reader reader;
    StringStream is("[null, true, -1, 1, -1234567890123456789, 1234567890123456789, 3.14, \"s\", { \"a\" : 1 }]");
    EXPECT_TRUE(reader.Parse(is, h));
}

Here is the call graph for this function:

TEST() [2/55]

TEST	(	Reader	,
		CustomStringStream	)

Definition at line 1351 of file readertest.cpp.

                                 {
    const char* json = "{ \"hello\" : \"world\", \"t\" : true , \"f\" : false, \"n\": null, \"i\":123, \"pi\": 3.1416, \"a\":[1, 2, 3] } ";
    CustomStringStream<UTF8<char> > s(json);
    ParseObjectHandler h;
    Reader reader;
    reader.Parse(s, h);
    EXPECT_EQ(20u, h.step_);
}

Here is the call graph for this function:

TEST() [3/55]

TEST	(	Reader	,
		EmptyExceptForCommaErrors	)

Definition at line 2096 of file readertest.cpp.

                                        {
    TestEmptyExceptForCommaErrors<kParseNoFlags>();
}

Here is the call graph for this function:

TEST() [4/55]

TEST	(	Reader	,
		EmptyExceptForCommaErrorsIterative	)

Definition at line 2100 of file readertest.cpp.

                                                 {
    TestEmptyExceptForCommaErrors<kParseIterativeFlag>();
}

Here is the call graph for this function:

TEST() [5/55]

TEST	(	Reader	,
		EofAfterOneLineComment	)

Definition at line 1839 of file readertest.cpp.

                                     {
    const char* json = "{\"hello\" : \"world\" // EOF is here -->\0 \n}";
 
    StringStream s(json);
    ParseObjectHandler h;
    Reader reader;
    EXPECT_FALSE(reader.Parse<kParseCommentsFlag>(s, h));
    EXPECT_EQ(kParseErrorObjectMissCommaOrCurlyBracket, reader.GetParseErrorCode());
}

Here is the call graph for this function:

TEST() [6/55]

TEST	(	Reader	,
		IncompleteMultilineComment	)

Definition at line 1849 of file readertest.cpp.

                                         {
    const char* json = "{\"hello\" : \"world\" /* EOF is here -->\0 */}";
 
    StringStream s(json);
    ParseObjectHandler h;
    Reader reader;
    EXPECT_FALSE(reader.Parse<kParseCommentsFlag>(s, h));
    EXPECT_EQ(kParseErrorUnspecificSyntaxError, reader.GetParseErrorCode());
}

Here is the call graph for this function:

TEST() [7/55]

TEST	(	Reader	,
		IncompleteMultilineComment2	)

Definition at line 1859 of file readertest.cpp.

                                          {
    const char* json = "{\"hello\" : \"world\" /* *\0 */}";
 
    StringStream s(json);
    ParseObjectHandler h;
    Reader reader;
    EXPECT_FALSE(reader.Parse<kParseCommentsFlag>(s, h));
    EXPECT_EQ(kParseErrorUnspecificSyntaxError, reader.GetParseErrorCode());
}

Here is the call graph for this function:

TEST() [8/55]

TEST	(	Reader	,
		InlineCommentsAreDisabledByDefault	)

Definition at line 1807 of file readertest.cpp.

                                                 {
    {
        const char* json = "{/* Inline comment. */\"hello\" : \"world\", \"t\" : true, \"f\" : false, \"n\": null, \"i\":123, \"pi\": 3.1416, \"a\":[1, 2, 3] }";
 
        StringStream s(json);
        ParseObjectHandler h;
        Reader reader;
        EXPECT_FALSE(reader.Parse<kParseDefaultFlags>(s, h));
    }
 
    {
        const char* json =
        "{\"hello\" : /* Multiline comment starts here\n"
        " continues here\n"
        " and ends here */\"world\", \"t\" :true , \"f\" : false, \"n\": null, \"i\":123, \"pi\": 3.1416, \"a\":[1, 2, 3] }";
 
        StringStream s(json);
        ParseObjectHandler h;
        Reader reader;
        EXPECT_FALSE(reader.Parse<kParseDefaultFlags>(s, h));
    }
}

Here is the call graph for this function:

TEST() [9/55]

TEST	(	Reader	,
		IterativeParsing_Count	)

Definition at line 1554 of file readertest.cpp.

                                     {
    {
        StringStream is("[{}, {\"k\": 1}, [1], []]");
        Reader reader;
        IterativeParsingReaderHandler<> handler;
 
        ParseResult r = reader.Parse<kParseIterativeFlag>(is, handler);
 
        EXPECT_FALSE(r.IsError());
        EXPECT_FALSE(reader.HasParseError());
 
        uint32_t e[] = {
            handler.LOG_STARTARRAY,
            handler.LOG_STARTOBJECT,
            handler.LOG_ENDOBJECT | 0,
            handler.LOG_STARTOBJECT,
            handler.LOG_KEY,
            handler.LOG_INT,
            handler.LOG_ENDOBJECT | 1,
            handler.LOG_STARTARRAY,
            handler.LOG_INT,
            handler.LOG_ENDARRAY | 1,
            handler.LOG_STARTARRAY,
            handler.LOG_ENDARRAY | 0,
            handler.LOG_ENDARRAY | 4
        };
 
        EXPECT_EQ(sizeof(e) / sizeof(int), handler.LogCount);
 
        for (size_t i = 0; i < handler.LogCount; ++i) {
            EXPECT_EQ(e[i], handler.Logs[i]) << "i = " << i;
        }
    }
}

Here is the call graph for this function:

TEST() [10/55]

TEST	(	Reader	,
		IterativeParsing_ErrorHandling	)

Definition at line 1419 of file readertest.cpp.

                                             {
    TESTERRORHANDLING("{\"a\": a}", kParseErrorValueInvalid, 6u);
 
    TESTERRORHANDLING("", kParseErrorDocumentEmpty, 0u);
    TESTERRORHANDLING("{}{}", kParseErrorDocumentRootNotSingular, 2u);
 
    TESTERRORHANDLING("{1}", kParseErrorObjectMissName, 1u);
    TESTERRORHANDLING("{\"a\", 1}", kParseErrorObjectMissColon, 4u);
    TESTERRORHANDLING("{\"a\"}", kParseErrorObjectMissColon, 4u);
    TESTERRORHANDLING("{\"a\": 1", kParseErrorObjectMissCommaOrCurlyBracket, 7u);
    TESTERRORHANDLING("[1 2 3]", kParseErrorArrayMissCommaOrSquareBracket, 3u);
    TESTERRORHANDLING("{\"a: 1", kParseErrorStringMissQuotationMark, 6u);
    TESTERRORHANDLING("{\"a\":}", kParseErrorValueInvalid, 5u);
    TESTERRORHANDLING("{\"a\":]", kParseErrorValueInvalid, 5u);
    TESTERRORHANDLING("[1,2,}", kParseErrorValueInvalid, 5u);
    TESTERRORHANDLING("[}]", kParseErrorValueInvalid, 1u);
    TESTERRORHANDLING("[,]", kParseErrorValueInvalid, 1u);
    TESTERRORHANDLING("[1,,]", kParseErrorValueInvalid, 3u);
 
    // Trailing commas are not allowed without kParseTrailingCommasFlag
    TESTERRORHANDLING("{\"a\": 1,}", kParseErrorObjectMissName, 8u);
    TESTERRORHANDLING("[1,2,3,]", kParseErrorValueInvalid, 7u);
 
    // Any JSON value can be a valid root element in RFC7159.
    TESTERRORHANDLING("\"ab", kParseErrorStringMissQuotationMark, 3u);
    TESTERRORHANDLING("truE", kParseErrorValueInvalid, 3u);
    TESTERRORHANDLING("False", kParseErrorValueInvalid, 0u);
    TESTERRORHANDLING("true, false", kParseErrorDocumentRootNotSingular, 4u);
    TESTERRORHANDLING("false, false", kParseErrorDocumentRootNotSingular, 5u);
    TESTERRORHANDLING("nulL", kParseErrorValueInvalid, 3u);
    TESTERRORHANDLING("null , null", kParseErrorDocumentRootNotSingular, 5u);
    TESTERRORHANDLING("1a", kParseErrorDocumentRootNotSingular, 1u);
}

TEST() [11/55]

TEST	(	Reader	,
		IterativeParsing_General	)

Definition at line 1517 of file readertest.cpp.

                                       {
    {
        StringStream is("[1, {\"k\": [1, 2]}, null, false, true, \"string\", 1.2]");
        Reader reader;
        IterativeParsingReaderHandler<> handler;
 
        ParseResult r = reader.Parse<kParseIterativeFlag>(is, handler);
 
        EXPECT_FALSE(r.IsError());
        EXPECT_FALSE(reader.HasParseError());
 
        uint32_t e[] = {
            handler.LOG_STARTARRAY,
            handler.LOG_INT,
            handler.LOG_STARTOBJECT,
            handler.LOG_KEY,
            handler.LOG_STARTARRAY,
            handler.LOG_INT,
            handler.LOG_INT,
            handler.LOG_ENDARRAY | 2,
            handler.LOG_ENDOBJECT | 1,
            handler.LOG_NULL,
            handler.LOG_BOOL,
            handler.LOG_BOOL,
            handler.LOG_STRING,
            handler.LOG_DOUBLE,
            handler.LOG_ENDARRAY | 7
        };
 
        EXPECT_EQ(sizeof(e) / sizeof(int), handler.LogCount);
 
        for (size_t i = 0; i < handler.LogCount; ++i) {
            EXPECT_EQ(e[i], handler.Logs[i]) << "i = " << i;
        }
    }
}

Here is the call graph for this function:

TEST() [12/55]

TEST	(	Reader	,
		IterativeParsing_ShortCircuit	)

Definition at line 1651 of file readertest.cpp.

                                            {
    {
        HandlerTerminateAtStartObject handler;
        Reader reader;
        StringStream is("[1, {}]");
 
        ParseResult r = reader.Parse<kParseIterativeFlag>(is, handler);
 
        EXPECT_TRUE(reader.HasParseError());
        EXPECT_EQ(kParseErrorTermination, r.Code());
        EXPECT_EQ(4u, r.Offset());
    }
 
    {
        HandlerTerminateAtStartArray handler;
        Reader reader;
        StringStream is("{\"a\": []}");
 
        ParseResult r = reader.Parse<kParseIterativeFlag>(is, handler);
 
        EXPECT_TRUE(reader.HasParseError());
        EXPECT_EQ(kParseErrorTermination, r.Code());
        EXPECT_EQ(6u, r.Offset());
    }
 
    {
        HandlerTerminateAtEndObject handler;
        Reader reader;
        StringStream is("[1, {}]");
 
        ParseResult r = reader.Parse<kParseIterativeFlag>(is, handler);
 
        EXPECT_TRUE(reader.HasParseError());
        EXPECT_EQ(kParseErrorTermination, r.Code());
        EXPECT_EQ(5u, r.Offset());
    }
 
    {
        HandlerTerminateAtEndArray handler;
        Reader reader;
        StringStream is("{\"a\": []}");
 
        ParseResult r = reader.Parse<kParseIterativeFlag>(is, handler);
 
        EXPECT_TRUE(reader.HasParseError());
        EXPECT_EQ(kParseErrorTermination, r.Code());
        EXPECT_EQ(7u, r.Offset());
    }
}

Here is the call graph for this function:

TEST() [13/55]

TEST	(	Reader	,
		IterativePullParsing_General	)

Definition at line 1589 of file readertest.cpp.

                                           {
    {
        IterativeParsingReaderHandler<> handler;
        uint32_t e[] = {
            handler.LOG_STARTARRAY,
            handler.LOG_INT,
            handler.LOG_STARTOBJECT,
            handler.LOG_KEY,
            handler.LOG_STARTARRAY,
            handler.LOG_INT,
            handler.LOG_INT,
            handler.LOG_ENDARRAY | 2,
            handler.LOG_ENDOBJECT | 1,
            handler.LOG_NULL,
            handler.LOG_BOOL,
            handler.LOG_BOOL,
            handler.LOG_STRING,
            handler.LOG_DOUBLE,
            handler.LOG_ENDARRAY | 7
        };
 
        StringStream is("[1, {\"k\": [1, 2]}, null, false, true, \"string\", 1.2]");
        Reader reader;
 
        reader.IterativeParseInit();
        while (!reader.IterativeParseComplete()) {
            size_t oldLogCount = handler.LogCount;
            EXPECT_TRUE(oldLogCount < sizeof(e) / sizeof(int)) << "overrun";
 
            EXPECT_TRUE(reader.IterativeParseNext<kParseDefaultFlags>(is, handler)) << "parse fail";
            EXPECT_EQ(handler.LogCount, oldLogCount + 1) << "handler should be invoked exactly once each time";
            EXPECT_EQ(e[oldLogCount], handler.Logs[oldLogCount]) << "wrong event returned";
        }
 
        EXPECT_FALSE(reader.HasParseError());
        EXPECT_EQ(sizeof(e) / sizeof(int), handler.LogCount) << "handler invoked wrong number of times";
 
        // The handler should not be invoked when the JSON has been fully read, but it should not fail
        size_t oldLogCount = handler.LogCount;
        EXPECT_TRUE(reader.IterativeParseNext<kParseDefaultFlags>(is, handler)) << "parse-next past complete is allowed";
        EXPECT_EQ(handler.LogCount, oldLogCount) << "parse-next past complete should not invoke handler";
        EXPECT_FALSE(reader.HasParseError()) << "parse-next past complete should not generate parse error";
    }
}

Here is the call graph for this function:

TEST() [14/55]

TEST	(	Reader	,
		MultipleTrailingCommaErrors	)

Definition at line 2064 of file readertest.cpp.

                                          {
    TestMultipleTrailingCommaErrors<kParseNoFlags>();
}

Here is the call graph for this function:

TEST() [15/55]

TEST	(	Reader	,
		MultipleTrailingCommaErrorsIterative	)

Definition at line 2068 of file readertest.cpp.

                                                   {
    TestMultipleTrailingCommaErrors<kParseIterativeFlag>();
}

Here is the call graph for this function:

TEST() [16/55]

TEST	(	Reader	,
		NumbersAsStrings	)

Definition at line 1909 of file readertest.cpp.

                               {
    {
        const char* json = "{ \"pi\": 3.1416 } ";
        StringStream s(json);
        NumbersAsStringsHandler h("3.1416");
        Reader reader;
        EXPECT_TRUE(reader.Parse<kParseNumbersAsStringsFlag>(s, h));
    }
    {
        char* json = StrDup("{ \"pi\": 3.1416 } ");
        InsituStringStream s(json);
        NumbersAsStringsHandler h("3.1416");
        Reader reader;
        EXPECT_TRUE(reader.Parse<kParseInsituFlag|kParseNumbersAsStringsFlag>(s, h));
        free(json);
    }
    {
        const char* json = "{ \"gigabyte\": 1.0e9 } ";
        StringStream s(json);
        NumbersAsStringsHandler h("1.0e9");
        Reader reader;
        EXPECT_TRUE(reader.Parse<kParseNumbersAsStringsFlag>(s, h));
    }
    {
        char* json = StrDup("{ \"gigabyte\": 1.0e9 } ");
        InsituStringStream s(json);
        NumbersAsStringsHandler h("1.0e9");
        Reader reader;
        EXPECT_TRUE(reader.Parse<kParseInsituFlag|kParseNumbersAsStringsFlag>(s, h));
        free(json);
    }
    {
        const char* json = "{ \"pi\": 314.159e-2 } ";
        StringStream s(json);
        NumbersAsStringsHandler h("314.159e-2");
        Reader reader;
        EXPECT_TRUE(reader.Parse<kParseNumbersAsStringsFlag>(s, h));
    }
    {
        char* json = StrDup("{ \"gigabyte\": 314.159e-2 } ");
        InsituStringStream s(json);
        NumbersAsStringsHandler h("314.159e-2");
        Reader reader;
        EXPECT_TRUE(reader.Parse<kParseInsituFlag|kParseNumbersAsStringsFlag>(s, h));
        free(json);
    }
    {
        const char* json = "{ \"negative\": -1.54321 } ";
        StringStream s(json);
        NumbersAsStringsHandler h("-1.54321");
        Reader reader;
        EXPECT_TRUE(reader.Parse<kParseNumbersAsStringsFlag>(s, h));
    }
    {
        char* json = StrDup("{ \"negative\": -1.54321 } ");
        InsituStringStream s(json);
        NumbersAsStringsHandler h("-1.54321");
        Reader reader;
        EXPECT_TRUE(reader.Parse<kParseInsituFlag|kParseNumbersAsStringsFlag>(s, h));
        free(json);
    }
    {
        const char* json = "{ \"pi\": 314.159e-2 } ";
        std::stringstream ss(json);
        IStreamWrapper s(ss);
        NumbersAsStringsHandler h("314.159e-2");
        Reader reader;
        EXPECT_TRUE(reader.Parse<kParseNumbersAsStringsFlag>(s, h));
    }
    {
        char n1e319[321];   // '1' followed by 319 '0'
        n1e319[0] = '1';
        for (int i = 1; i < 320; i++)
            n1e319[i] = '0';
        n1e319[320] = '\0';
        StringStream s(n1e319);
        NumbersAsStringsHandler h(n1e319);
        Reader reader;
        EXPECT_TRUE(reader.Parse<kParseNumbersAsStringsFlag>(s, h));
    }
}

Here is the call graph for this function:

TEST() [17/55]

TEST	(	Reader	,
		OnelineCommentsAreDisabledByDefault	)

Definition at line 1830 of file readertest.cpp.

                                                  {
    const char* json = "{// One-line comment\n\"hello\" : \"world\", \"t\" : true , \"f\" : false, \"n\": null, \"i\":123, \"pi\": 3.1416, \"a\":[1, 2, 3] }";
 
    StringStream s(json);
    ParseObjectHandler h;
    Reader reader;
    EXPECT_FALSE(reader.Parse<kParseDefaultFlags>(s, h));
}

Here is the call graph for this function:

TEST() [18/55]

TEST	(	Reader	,
		Parse_EmptyObject	)

Definition at line 1167 of file readertest.cpp.

                                {
    StringStream s("{ } ");
    ParseEmptyObjectHandler h;
    Reader reader;
    reader.Parse(s, h);
    EXPECT_EQ(2u, h.step_);
}

Here is the call graph for this function:

TEST() [19/55]

TEST	(	Reader	,
		Parse_IStreamWrapper_StringStream	)

Definition at line 1392 of file readertest.cpp.

                                                {
    const char* json = "[1,2,3,4]";
 
    std::stringstream ss(json);
    IStreamWrapper is(ss);
 
    Reader reader;
    ParseArrayHandler<4> h;
    reader.Parse(is, h);
    EXPECT_FALSE(reader.HasParseError());
}

Here is the call graph for this function:

TEST() [20/55]

TEST	(	Reader	,
		Parse_MultipleRoot	)

Definition at line 1200 of file readertest.cpp.

                                 {
    TestMultipleRoot<kParseStopWhenDoneFlag>();
}

Here is the call graph for this function:

TEST() [21/55]

TEST	(	Reader	,
		ParseArray	)

Definition at line 1052 of file readertest.cpp.

                         {
    char *json = StrDup("[1, 2, 3, 4]");
    InsituStringStream s(json);
    ParseArrayHandler<4> h;
    Reader reader;
    reader.Parse(s, h);
    EXPECT_EQ(6u, h.step_);
    free(json);
}

Here is the call graph for this function:

TEST() [22/55]

TEST	(	Reader	,
		ParseArray_Error	)

Definition at line 1062 of file readertest.cpp.

                               {
#define TEST_ARRAY_ERROR(errorCode, str, errorOffset) \
    { \
        unsigned 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());\
    }
 
    // Missing a comma or ']' after an array element.
    TEST_ARRAY_ERROR(kParseErrorArrayMissCommaOrSquareBracket, "[1", 2u);
    TEST_ARRAY_ERROR(kParseErrorArrayMissCommaOrSquareBracket, "[1}", 2u);
    TEST_ARRAY_ERROR(kParseErrorArrayMissCommaOrSquareBracket, "[1 2]", 3u);
 
    // Array cannot have a trailing comma (without kParseTrailingCommasFlag);
    // a value must follow a comma
    TEST_ARRAY_ERROR(kParseErrorValueInvalid, "[1,]", 3u);
 
#undef TEST_ARRAY_ERROR
}

TEST() [23/55]

TEST	(	Reader	,
		ParseComments	)

Definition at line 1756 of file readertest.cpp.

                            {
    const char* json =
    "// Here is a one-line comment.\n"
    "{// And here's another one\n"
    "   /*And here's an in-line one.*/\"hello\" : \"world\","
    "   \"t\" :/* And one with '*' symbol*/true ,"
    "/* A multiline comment\n"
    "   goes here*/"
    "   \"f\" : false, \"n\": null, \"i\":123, \"pi\": 3.1416, \"a\":[1, 2, 3]"
    "}/*And the last one to be sure */";
 
    StringStream s(json);
    ParseObjectHandler h;
    Reader reader;
    EXPECT_TRUE(reader.Parse<kParseCommentsFlag>(s, h));
    EXPECT_EQ(20u, h.step_);
}

Here is the call graph for this function:

TEST() [24/55]

TEST	(	Reader	,
		ParseDocument_Error	)

Definition at line 1245 of file readertest.cpp.

                                  {
    // The document is empty.
    TEST_ERROR(kParseErrorDocumentEmpty, "", 0u);
    TEST_ERROR(kParseErrorDocumentEmpty, " ", 1u);
    TEST_ERROR(kParseErrorDocumentEmpty, " \n", 2u);
 
    // The document root must not follow by other values.
    TEST_ERROR(kParseErrorDocumentRootNotSingular, "[] 0", 3u);
    TEST_ERROR(kParseErrorDocumentRootNotSingular, "{} 0", 3u);
    TEST_ERROR(kParseErrorDocumentRootNotSingular, "null []", 5u);
    TEST_ERROR(kParseErrorDocumentRootNotSingular, "0 {}", 2u);
}

TEST() [25/55]

TEST	(	Reader	,
		ParseEmptyArray	)

Definition at line 1042 of file readertest.cpp.

                              {
    char *json = StrDup("[ ] ");
    InsituStringStream s(json);
    ParseArrayHandler<0> h;
    Reader reader;
    reader.Parse(s, h);
    EXPECT_EQ(2u, h.step_);
    free(json);
}

Here is the call graph for this function:

TEST() [26/55]

TEST	(	Reader	,
		ParseEmptyInlineComment	)

Definition at line 1774 of file readertest.cpp.

                                      {
    const char* json = "{/**/\"hello\" : \"world\", \"t\" : true, \"f\" : false, \"n\": null, \"i\":123, \"pi\": 3.1416, \"a\":[1, 2, 3] }";
 
    StringStream s(json);
    ParseObjectHandler h;
    Reader reader;
    EXPECT_TRUE(reader.Parse<kParseCommentsFlag>(s, h));
    EXPECT_EQ(20u, h.step_);
}

Here is the call graph for this function:

TEST() [27/55]

TEST	(	Reader	,
		ParseEmptyOnelineComment	)

Definition at line 1784 of file readertest.cpp.

                                       {
    const char* json = "{//\n\"hello\" : \"world\", \"t\" : true, \"f\" : false, \"n\": null, \"i\":123, \"pi\": 3.1416, \"a\":[1, 2, 3] }";
 
    StringStream s(json);
    ParseObjectHandler h;
    Reader reader;
    EXPECT_TRUE(reader.Parse<kParseCommentsFlag>(s, h));
    EXPECT_EQ(20u, h.step_);
}

Here is the call graph for this function:

TEST() [28/55]

TEST	(	Reader	,
		ParseFalse	)

Definition at line 60 of file readertest.cpp.

                         {
    StringStream s("false");
    ParseBoolHandler<false> h;
    Reader reader;
    reader.Parse(s, h);
    EXPECT_EQ(1u, h.step_);
}

Here is the call graph for this function:

TEST() [29/55]

TEST	(	Reader	,
		ParseInsitu_MultipleRoot	)

Definition at line 1223 of file readertest.cpp.

                                       {
    TestInsituMultipleRoot<kParseStopWhenDoneFlag>();
}

Here is the call graph for this function:

TEST() [30/55]

TEST	(	Reader	,
		ParseInsituIterative_MultipleRoot	)

Definition at line 1227 of file readertest.cpp.

                                                {
    TestInsituMultipleRoot<kParseIterativeFlag | kParseStopWhenDoneFlag>();
}

Here is the call graph for this function:

TEST() [31/55]

TEST	(	Reader	,
		ParseIterative_MultipleRoot	)

Definition at line 1204 of file readertest.cpp.

                                          {
    TestMultipleRoot<kParseIterativeFlag | kParseStopWhenDoneFlag>();
}

Here is the call graph for this function:

TEST() [32/55]

TEST	(	Reader	,
		ParseMultipleCommentsInARow	)

Definition at line 1794 of file readertest.cpp.

                                          {
    const char* json =
    "{/* first comment *//* second */\n"
    "/* third */ /*fourth*/// last one\n"
    "\"hello\" : \"world\", \"t\" : true, \"f\" : false, \"n\": null, \"i\":123, \"pi\": 3.1416, \"a\":[1, 2, 3] }";
 
    StringStream s(json);
    ParseObjectHandler h;
    Reader reader;
    EXPECT_TRUE(reader.Parse<kParseCommentsFlag>(s, h));
    EXPECT_EQ(20u, h.step_);
}

Here is the call graph for this function:

TEST() [33/55]

TEST	(	Reader	,
		ParseNanAndInfinity	)

Definition at line 2134 of file readertest.cpp.

                                  {
#define TEST_NAN_INF(str, x) \
    { \
        { \
            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); \
        } \
    }
#define TEST_NAN_INF_ERROR(errorCode, str, errorOffset) \
    { \
        unsigned 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());\
    }
 
    double nan = std::numeric_limits<double>::quiet_NaN();
    double inf = std::numeric_limits<double>::infinity();
 
    TEST_NAN_INF("NaN", nan);
    TEST_NAN_INF("-NaN", nan);
    TEST_NAN_INF("Inf", inf);
    TEST_NAN_INF("Infinity", inf);
    TEST_NAN_INF("-Inf", -inf);
    TEST_NAN_INF("-Infinity", -inf);
    TEST_NAN_INF_ERROR(kParseErrorValueInvalid, "NInf", 1u);
    TEST_NAN_INF_ERROR(kParseErrorValueInvalid, "NaInf", 2u);
    TEST_NAN_INF_ERROR(kParseErrorValueInvalid, "INan", 1u);
    TEST_NAN_INF_ERROR(kParseErrorValueInvalid, "InNan", 2u);
    TEST_NAN_INF_ERROR(kParseErrorValueInvalid, "nan", 1u);
    TEST_NAN_INF_ERROR(kParseErrorValueInvalid, "-nan", 1u);
    TEST_NAN_INF_ERROR(kParseErrorValueInvalid, "NAN", 1u);
    TEST_NAN_INF_ERROR(kParseErrorValueInvalid, "-Infinty", 6u);
 
#undef TEST_NAN_INF_ERROR
#undef TEST_NAN_INF
}

TEST() [34/55]

TEST	(	Reader	,
		ParseNumber_FullPrecisionDouble	)

Definition at line 591 of file readertest.cpp.

                                              {
    TestParseDouble<true>();
}

TEST() [35/55]

TEST	(	Reader	,
		ParseNumber_Integer	)

Definition at line 113 of file readertest.cpp.

                                  {
#define TEST_INTEGER(Handler, str, x) \
    { \
        StringStream s(str); \
        Handler h; \
        Reader reader; \
        reader.Parse(s, h); \
        EXPECT_EQ(1u, h.step_); \
        EXPECT_EQ(x, h.actual_); \
    }
 
    TEST_INTEGER(ParseUintHandler, "0", 0u);
    TEST_INTEGER(ParseUintHandler, "123", 123u);
    TEST_INTEGER(ParseUintHandler, "2147483648", 2147483648u);       // 2^31 - 1 (cannot be stored in int)
    TEST_INTEGER(ParseUintHandler, "4294967295", 4294967295u);
 
    TEST_INTEGER(ParseIntHandler, "-123", -123);
    TEST_INTEGER(ParseIntHandler, "-2147483648", static_cast<int32_t>(0x80000000));     // -2^31 (min of int)
 
    TEST_INTEGER(ParseUint64Handler, "4294967296", RAPIDJSON_UINT64_C2(1, 0));   // 2^32 (max of unsigned + 1, force to use uint64_t)
    TEST_INTEGER(ParseUint64Handler, "18446744073709551615", RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0xFFFFFFFF));   // 2^64 - 1 (max of uint64_t)
 
    TEST_INTEGER(ParseInt64Handler, "-2147483649", static_cast<int64_t>(RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x7FFFFFFF)));   // -2^31 -1 (min of int - 1, force to use int64_t)
    TEST_INTEGER(ParseInt64Handler, "-9223372036854775808", static_cast<int64_t>(RAPIDJSON_UINT64_C2(0x80000000, 0x00000000)));       // -2^63 (min of int64_t)
 
    // Random test for uint32_t/int32_t
    {
        union {
            uint32_t u;
            int32_t i;
        }u;
        Random r;
 
        for (unsigned i = 0; i < 100000; i++) {
            u.u = r();
 
            char buffer[32];
            *internal::u32toa(u.u, buffer) = '\0';
            TEST_INTEGER(ParseUintHandler, buffer, u.u);
 
            if (u.i < 0) {
                *internal::i32toa(u.i, buffer) = '\0';
                TEST_INTEGER(ParseIntHandler, buffer, u.i);
            }
        }
    }
 
    // Random test for uint64_t/int64_t
    {
        union {
            uint64_t u;
            int64_t i;
        }u;
        Random r;
 
        for (unsigned i = 0; i < 100000; i++) {
            u.u = uint64_t(r()) << 32;
            u.u |= r();
 
            char buffer[32];
            if (u.u > uint64_t(4294967295u)) {
                *internal::u64toa(u.u, buffer) = '\0';
                TEST_INTEGER(ParseUint64Handler, buffer, u.u);
            }
 
            if (u.i < -int64_t(2147483648u)) {
                *internal::i64toa(u.i, buffer) = '\0';
                TEST_INTEGER(ParseInt64Handler, buffer, u.i);
            }
        }
    }
#undef TEST_INTEGER
}

Here is the call graph for this function:

TEST() [36/55]

TEST	(	Reader	,
		ParseNumber_NormalPrecisionDouble	)

Definition at line 587 of file readertest.cpp.

                                                {
    TestParseDouble<false>();
}

TEST() [37/55]

TEST	(	Reader	,
		ParseNumber_NormalPrecisionError	)

Definition at line 595 of file readertest.cpp.

                                               {
    static unsigned count = 1000000;
    Random r;
 
    double ulpSum = 0.0;
    double ulpMax = 0.0;
    for (unsigned i = 0; i < count; i++) {
        internal::Double e, a;
        do {
            // Need to call r() in two statements for cross-platform coherent sequence.
            uint64_t u = uint64_t(r()) << 32;
            u |= uint64_t(r());
            e = u;
        } while (e.IsNan() || e.IsInf() || !e.IsNormal());
 
        char buffer[32];
        *internal::dtoa(e.Value(), buffer) = '\0';
 
        StringStream s(buffer);
        ParseDoubleHandler h;
        Reader reader;
        ASSERT_EQ(kParseErrorNone, reader.Parse(s, h).Code());
        EXPECT_EQ(1u, h.step_);
 
        a = h.actual_;
        uint64_t bias1 = e.ToBias();
        uint64_t bias2 = a.ToBias();
        double ulp = static_cast<double>(bias1 >= bias2 ? bias1 - bias2 : bias2 - bias1);
        ulpMax = (std::max)(ulpMax, ulp);
        ulpSum += ulp;
    }
    printf("ULP Average = %g, Max = %g \n", ulpSum / count, ulpMax);
}

Here is the call graph for this function:

TEST() [38/55]

TEST	(	Reader	,
		ParseNumberError_FullPrecisionDouble	)

Definition at line 751 of file readertest.cpp.

                                                   {
    TestParseNumberError<true>();
}

TEST() [39/55]

TEST	(	Reader	,
		ParseNumberError_NormalPrecisionDouble	)

Definition at line 747 of file readertest.cpp.

                                                     {
    TestParseNumberError<false>();
}

TEST() [40/55]

TEST	(	Reader	,
		ParseObject	)

Definition at line 1133 of file readertest.cpp.

                          {
    const char* json = "{ \"hello\" : \"world\", \"t\" : true , \"f\" : false, \"n\": null, \"i\":123, \"pi\": 3.1416, \"a\":[1, 2, 3] } ";
 
    // Insitu
    {
        char* json2 = StrDup(json);
        InsituStringStream s(json2);
        ParseObjectHandler h;
        Reader reader;
        reader.Parse<kParseInsituFlag>(s, h);
        EXPECT_EQ(20u, h.step_);
        free(json2);
    }
 
    // Normal
    {
        StringStream s(json);
        ParseObjectHandler h;
        Reader reader;
        reader.Parse(s, h);
        EXPECT_EQ(20u, h.step_);
    }
}

Here is the call graph for this function:

TEST() [41/55]

TEST	(	Reader	,
		ParseObject_Error	)

Definition at line 1267 of file readertest.cpp.

                                {
    // Missing a name for object member.
    TEST_ERROR(kParseErrorObjectMissName, "{1}", 1u);
    TEST_ERROR(kParseErrorObjectMissName, "{:1}", 1u);
    TEST_ERROR(kParseErrorObjectMissName, "{null:1}", 1u);
    TEST_ERROR(kParseErrorObjectMissName, "{true:1}", 1u);
    TEST_ERROR(kParseErrorObjectMissName, "{false:1}", 1u);
    TEST_ERROR(kParseErrorObjectMissName, "{1:1}", 1u);
    TEST_ERROR(kParseErrorObjectMissName, "{[]:1}", 1u);
    TEST_ERROR(kParseErrorObjectMissName, "{{}:1}", 1u);
    TEST_ERROR(kParseErrorObjectMissName, "{xyz:1}", 1u);
 
    // Missing a colon after a name of object member.
    TEST_ERROR(kParseErrorObjectMissColon, "{\"a\" 1}", 5u);
    TEST_ERROR(kParseErrorObjectMissColon, "{\"a\",1}", 4u);
 
    // Must be a comma or '}' after an object member
    TEST_ERROR(kParseErrorObjectMissCommaOrCurlyBracket, "{\"a\":1]", 6u);
 
    // Object cannot have a trailing comma (without kParseTrailingCommasFlag);
    // an object member name must follow a comma
    TEST_ERROR(kParseErrorObjectMissName, "{\"a\":1,}", 7u);
 
    // This tests that MemoryStream is checking the length in Peek().
    {
        MemoryStream ms("{\"a\"", 1);
        BaseReaderHandler<> h;
        Reader reader;
        EXPECT_FALSE(reader.Parse<kParseStopWhenDoneFlag>(ms, h));
        EXPECT_EQ(kParseErrorObjectMissName, reader.GetParseErrorCode());
    }
}

Here is the call graph for this function:

TEST() [42/55]

TEST	(	Reader	,
		ParseString	)

Definition at line 782 of file readertest.cpp.

                          {
#define TEST_STRING(Encoding, e, x) \
    { \
        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_); \
    }
 
    // String constant L"\xXX" can only specify character code in bytes, which is not endianness-neutral.
    // And old compiler does not support u"" and U"" string literal. So here specify string literal by array of Ch.
    // In addition, GCC 4.8 generates -Wnarrowing warnings when character code >= 128 are assigned to signed integer types.
    // Therefore, utype is added for declaring unsigned array, and then cast it to Encoding::Ch.
#define ARRAY(...) { __VA_ARGS__ }
#define TEST_STRINGARRAY(Encoding, utype, array, x) \
    { \
        static const utype ue[] = array; \
        static const Encoding::Ch* e = reinterpret_cast<const Encoding::Ch *>(&ue[0]); \
        TEST_STRING(Encoding, e, x); \
    }
 
#define TEST_STRINGARRAY2(Encoding, utype, earray, xarray) \
    { \
        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_STRING(UTF8<>, "", "\"\"");
    TEST_STRING(UTF8<>, "Hello", "\"Hello\"");
    TEST_STRING(UTF8<>, "Hello\nWorld", "\"Hello\\nWorld\"");
    TEST_STRING(UTF8<>, "\"\\/\b\f\n\r\t", "\"\\\"\\\\/\\b\\f\\n\\r\\t\"");
    TEST_STRING(UTF8<>, "\x24", "\"\\u0024\"");         // Dollar sign U+0024
    TEST_STRING(UTF8<>, "\xC2\xA2", "\"\\u00A2\"");     // Cents sign U+00A2
    TEST_STRING(UTF8<>, "\xE2\x82\xAC", "\"\\u20AC\""); // Euro sign U+20AC
    TEST_STRING(UTF8<>, "\xF0\x9D\x84\x9E", "\"\\uD834\\uDD1E\"");  // G clef sign U+1D11E
 
    // UTF16
    TEST_STRING(UTF16<>, L"", L"\"\"");
    TEST_STRING(UTF16<>, L"Hello", L"\"Hello\"");
    TEST_STRING(UTF16<>, L"Hello\nWorld", L"\"Hello\\nWorld\"");
    TEST_STRING(UTF16<>, L"\"\\/\b\f\n\r\t", L"\"\\\"\\\\/\\b\\f\\n\\r\\t\"");
    TEST_STRINGARRAY(UTF16<>, wchar_t, ARRAY(0x0024, 0x0000), L"\"\\u0024\"");
    TEST_STRINGARRAY(UTF16<>, wchar_t, ARRAY(0x00A2, 0x0000), L"\"\\u00A2\"");  // Cents sign U+00A2
    TEST_STRINGARRAY(UTF16<>, wchar_t, ARRAY(0x20AC, 0x0000), L"\"\\u20AC\"");  // Euro sign U+20AC
    TEST_STRINGARRAY(UTF16<>, wchar_t, ARRAY(0xD834, 0xDD1E, 0x0000), L"\"\\uD834\\uDD1E\"");   // G clef sign U+1D11E
 
    // UTF32
    TEST_STRINGARRAY2(UTF32<>, unsigned, ARRAY('\0'), ARRAY('\"', '\"', '\0'));
    TEST_STRINGARRAY2(UTF32<>, unsigned, ARRAY('H', 'e', 'l', 'l', 'o', '\0'), ARRAY('\"', 'H', 'e', 'l', 'l', 'o', '\"', '\0'));
    TEST_STRINGARRAY2(UTF32<>, unsigned, ARRAY('H', 'e', 'l', 'l', 'o', '\n', 'W', 'o', 'r', 'l', 'd', '\0'), ARRAY('\"', 'H', 'e', 'l', 'l', 'o', '\\', 'n', 'W', 'o', 'r', 'l', 'd', '\"', '\0'));
    TEST_STRINGARRAY2(UTF32<>, unsigned, ARRAY('\"', '\\', '/', '\b', '\f', '\n', '\r', '\t', '\0'), ARRAY('\"', '\\', '\"', '\\', '\\', '/', '\\', 'b', '\\', 'f', '\\', 'n', '\\', 'r', '\\', 't', '\"', '\0'));
    TEST_STRINGARRAY2(UTF32<>, unsigned, ARRAY(0x00024, 0x0000), ARRAY('\"', '\\', 'u', '0', '0', '2', '4', '\"', '\0'));
    TEST_STRINGARRAY2(UTF32<>, unsigned, ARRAY(0x000A2, 0x0000), ARRAY('\"', '\\', 'u', '0', '0', 'A', '2', '\"', '\0'));   // Cents sign U+00A2
    TEST_STRINGARRAY2(UTF32<>, unsigned, ARRAY(0x020AC, 0x0000), ARRAY('\"', '\\', 'u', '2', '0', 'A', 'C', '\"', '\0'));   // Euro sign U+20AC
    TEST_STRINGARRAY2(UTF32<>, unsigned, ARRAY(0x1D11E, 0x0000), ARRAY('\"', '\\', 'u', 'D', '8', '3', '4', '\\', 'u', 'D', 'D', '1', 'E', '\"', '\0'));    // G clef sign U+1D11E
 
#undef TEST_STRINGARRAY
#undef ARRAY
#undef TEST_STRING
 
    // Support of null character in string
    {
        StringStream s("\"Hello\\u0000World\"");
        const char e[] = "Hello\0World";
        ParseStringHandler<UTF8<> > h;
        Reader reader;
        reader.Parse(s, h);
        EXPECT_EQ(0, memcmp(e, h.str_, h.length_ + 1));
        EXPECT_EQ(11u, h.length_);
    }
}

Here is the call graph for this function:

TEST() [43/55]

TEST	(	Reader	,
		ParseString_Error	)

Definition at line 907 of file readertest.cpp.

                                {
#define TEST_STRING_ERROR(errorCode, str, errorOffset, streamPos)\
{\
    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());\
}
 
#define ARRAY(...) { __VA_ARGS__ }
#define TEST_STRINGENCODING_ERROR(Encoding, TargetEncoding, utype, array) \
    { \
        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());\
    }
 
    // Invalid escape character in string.
    TEST_STRING_ERROR(kParseErrorStringEscapeInvalid, "[\"\\a\"]", 2u, 3u);
 
    // Incorrect hex digit after \\u escape in string.
    TEST_STRING_ERROR(kParseErrorStringUnicodeEscapeInvalidHex, "[\"\\uABCG\"]", 2u, 7u);
 
    // Quotation in \\u escape in string (Issue #288)
    TEST_STRING_ERROR(kParseErrorStringUnicodeEscapeInvalidHex, "[\"\\uaaa\"]", 2u, 7u);
    TEST_STRING_ERROR(kParseErrorStringUnicodeEscapeInvalidHex, "[\"\\uD800\\uFFF\"]", 2u, 13u);
 
    // The surrogate pair in string is invalid.
    TEST_STRING_ERROR(kParseErrorStringUnicodeSurrogateInvalid, "[\"\\uD800X\"]", 2u, 8u);
    TEST_STRING_ERROR(kParseErrorStringUnicodeSurrogateInvalid, "[\"\\uD800\\uFFFF\"]", 2u, 14u);
 
    // Missing a closing quotation mark in string.
    TEST_STRING_ERROR(kParseErrorStringMissQuotationMark, "[\"Test]", 7u, 7u);
 
    // http://www.cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-test.txt
 
    // 3  Malformed sequences
 
    // 3.1 Unexpected continuation bytes
    {
         char e[] = { '[', '\"', 0, '\"', ']', '\0' };
         for (unsigned char c = 0x80u; c <= 0xBFu; c++) {
            e[2] = static_cast<char>(c);
            ParseErrorCode error = TestString<UTF8<> >(e);
            EXPECT_EQ(kParseErrorStringInvalidEncoding, error);
            if (error != kParseErrorStringInvalidEncoding)
                std::cout << static_cast<unsigned>(c) << std::endl;
         }
    }
 
    // 3.2 Lonely start characters, 3.5 Impossible bytes
    {
        char e[] = { '[', '\"', 0, ' ', '\"', ']', '\0' };
        for (unsigned c = 0xC0u; c <= 0xFFu; c++) {
            e[2] = static_cast<char>(c);
            unsigned streamPos;
            if (c <= 0xC1u)
                streamPos = 3; // 0xC0 - 0xC1
            else if (c <= 0xDFu)
                streamPos = 4; // 0xC2 - 0xDF
            else if (c <= 0xEFu)
                streamPos = 5; // 0xE0 - 0xEF
            else if (c <= 0xF4u)
                streamPos = 6; // 0xF0 - 0xF4
            else
                streamPos = 3; // 0xF5 - 0xFF
            TEST_STRING_ERROR(kParseErrorStringInvalidEncoding, e, 2u, streamPos);
        }
    }
 
    // 4  Overlong sequences
 
    // 4.1  Examples of an overlong ASCII character
    TEST_STRINGENCODING_ERROR(UTF8<>, UTF16<>, unsigned char, ARRAY('[', '\"', 0xC0u, 0xAFu, '\"', ']', '\0'));
    TEST_STRINGENCODING_ERROR(UTF8<>, UTF16<>, unsigned char, ARRAY('[', '\"', 0xE0u, 0x80u, 0xAFu, '\"', ']', '\0'));
    TEST_STRINGENCODING_ERROR(UTF8<>, UTF16<>, unsigned char, ARRAY('[', '\"', 0xF0u, 0x80u, 0x80u, 0xAFu, '\"', ']', '\0'));
 
    // 4.2  Maximum overlong sequences
    TEST_STRINGENCODING_ERROR(UTF8<>, UTF16<>, unsigned char, ARRAY('[', '\"', 0xC1u, 0xBFu, '\"', ']', '\0'));
    TEST_STRINGENCODING_ERROR(UTF8<>, UTF16<>, unsigned char, ARRAY('[', '\"', 0xE0u, 0x9Fu, 0xBFu, '\"', ']', '\0'));
    TEST_STRINGENCODING_ERROR(UTF8<>, UTF16<>, unsigned char, ARRAY('[', '\"', 0xF0u, 0x8Fu, 0xBFu, 0xBFu, '\"', ']', '\0'));
 
    // 4.3  Overlong representation of the NUL character
    TEST_STRINGENCODING_ERROR(UTF8<>, UTF16<>, unsigned char, ARRAY('[', '\"', 0xC0u, 0x80u, '\"', ']', '\0'));
    TEST_STRINGENCODING_ERROR(UTF8<>, UTF16<>, unsigned char, ARRAY('[', '\"', 0xE0u, 0x80u, 0x80u, '\"', ']', '\0'));
    TEST_STRINGENCODING_ERROR(UTF8<>, UTF16<>, unsigned char, ARRAY('[', '\"', 0xF0u, 0x80u, 0x80u, 0x80u, '\"', ']', '\0'));
 
    // 5  Illegal code positions
 
    // 5.1 Single UTF-16 surrogates
    TEST_STRINGENCODING_ERROR(UTF8<>, UTF16<>, unsigned char, ARRAY('[', '\"', 0xEDu, 0xA0u, 0x80u, '\"', ']', '\0'));
    TEST_STRINGENCODING_ERROR(UTF8<>, UTF16<>, unsigned char, ARRAY('[', '\"', 0xEDu, 0xADu, 0xBFu, '\"', ']', '\0'));
    TEST_STRINGENCODING_ERROR(UTF8<>, UTF16<>, unsigned char, ARRAY('[', '\"', 0xEDu, 0xAEu, 0x80u, '\"', ']', '\0'));
    TEST_STRINGENCODING_ERROR(UTF8<>, UTF16<>, unsigned char, ARRAY('[', '\"', 0xEDu, 0xAFu, 0xBFu, '\"', ']', '\0'));
    TEST_STRINGENCODING_ERROR(UTF8<>, UTF16<>, unsigned char, ARRAY('[', '\"', 0xEDu, 0xB0u, 0x80u, '\"', ']', '\0'));
    TEST_STRINGENCODING_ERROR(UTF8<>, UTF16<>, unsigned char, ARRAY('[', '\"', 0xEDu, 0xBEu, 0x80u, '\"', ']', '\0'));
    TEST_STRINGENCODING_ERROR(UTF8<>, UTF16<>, unsigned char, ARRAY('[', '\"', 0xEDu, 0xBFu, 0xBFu, '\"', ']', '\0'));
 
    // Malform UTF-16 sequences
    TEST_STRINGENCODING_ERROR(UTF16<>, UTF8<>, wchar_t, ARRAY('[', '\"', 0xDC00, 0xDC00, '\"', ']', '\0'));
    TEST_STRINGENCODING_ERROR(UTF16<>, UTF8<>, wchar_t, ARRAY('[', '\"', 0xD800, 0xD800, '\"', ']', '\0'));
 
    // Malform UTF-32 sequence
    TEST_STRINGENCODING_ERROR(UTF32<>, UTF8<>, unsigned, ARRAY('[', '\"', 0x110000, '\"', ']', '\0'));
 
    // Malform ASCII sequence
    TEST_STRINGENCODING_ERROR(ASCII<>, UTF8<>, char, ARRAY('[', '\"', char(0x80u), '\"', ']', '\0'));
    TEST_STRINGENCODING_ERROR(ASCII<>, UTF8<>, char, ARRAY('[', '\"', char(0x01u), '\"', ']', '\0'));
    TEST_STRINGENCODING_ERROR(ASCII<>, UTF8<>, char, ARRAY('[', '\"', char(0x1Cu), '\"', ']', '\0'));
 
#undef ARRAY
#undef TEST_STRINGARRAY_ERROR
}

Here is the call graph for this function:

TEST() [44/55]

TEST	(	Reader	,
		ParseString_NonDestructive	)

Definition at line 889 of file readertest.cpp.

                                         {
    StringStream s("\"Hello\\nWorld\"");
    ParseStringHandler<UTF8<> > h;
    Reader reader;
    reader.Parse(s, h);
    EXPECT_EQ(0, StrCmp("Hello\nWorld", h.str_));
    EXPECT_EQ(11u, h.length_);
}

Here is the call graph for this function:

TEST() [45/55]

TEST	(	Reader	,
		ParseString_Transcoding	)

Definition at line 867 of file readertest.cpp.

                                      {
    const char* x = "\"Hello\"";
    const wchar_t* e = L"Hello";
    GenericStringStream<UTF8<> > is(x);
    GenericReader<UTF8<>, UTF16<> > reader;
    ParseStringHandler<UTF16<> > h;
    reader.Parse(is, h);
    EXPECT_EQ(0, StrCmp<UTF16<>::Ch>(e, h.str_));
    EXPECT_EQ(StrLen(e), h.length_);
}

Here is the call graph for this function:

TEST() [46/55]

TEST	(	Reader	,
		ParseString_TranscodingWithValidation	)

Definition at line 878 of file readertest.cpp.

                                                    {
    const char* x = "\"Hello\"";
    const wchar_t* e = L"Hello";
    GenericStringStream<UTF8<> > is(x);
    GenericReader<UTF8<>, UTF16<> > reader;
    ParseStringHandler<UTF16<> > h;
    reader.Parse<kParseValidateEncodingFlag>(is, h);
    EXPECT_EQ(0, StrCmp<UTF16<>::Ch>(e, h.str_));
    EXPECT_EQ(StrLen(e), h.length_);
}

Here is the call graph for this function:

TEST() [47/55]

TEST	(	Reader	,
		ParseTerminationByHandler	)

Definition at line 1736 of file readertest.cpp.

                                        {
    TEST_TERMINATION(0, "[null");
    TEST_TERMINATION(1, "[true");
    TEST_TERMINATION(1, "[false");
    TEST_TERMINATION(2, "[-1");
    TEST_TERMINATION(3, "[1");
    TEST_TERMINATION(4, "[-1234567890123456789");
    TEST_TERMINATION(5, "[1234567890123456789");
    TEST_TERMINATION(6, "[0.5]");
    // RawNumber() is never called
    TEST_TERMINATION(8, "[\"a\"");
    TEST_TERMINATION(9, "[{");
    TEST_TERMINATION(10, "[{\"a\"");
    TEST_TERMINATION(11, "[{}");
    TEST_TERMINATION(11, "[{\"a\":1}"); // non-empty object
    TEST_TERMINATION(12, "{\"a\":[");
    TEST_TERMINATION(13, "{\"a\":[]");
    TEST_TERMINATION(13, "{\"a\":[1]"); // non-empty array
}

TEST() [48/55]

TEST	(	Reader	,
		ParseTrue	)

Definition at line 52 of file readertest.cpp.

                        {
    StringStream s("true");
    ParseBoolHandler<true> h;
    Reader reader;
    reader.Parse(s, h);
    EXPECT_EQ(1u, h.step_);
}

Here is the call graph for this function:

TEST() [49/55]

TEST	(	Reader	,
		ParseValue_Error	)

Definition at line 1258 of file readertest.cpp.

                               {
    // Invalid value.
    TEST_ERROR(kParseErrorValueInvalid, "nulL", 3u);
    TEST_ERROR(kParseErrorValueInvalid, "truE", 3u);
    TEST_ERROR(kParseErrorValueInvalid, "falsE", 4u);
    TEST_ERROR(kParseErrorValueInvalid, "a]", 0u);
    TEST_ERROR(kParseErrorValueInvalid, ".1", 0u);
}

TEST() [50/55]

TEST	(	Reader	,
		SkipWhitespace	)

Definition at line 1302 of file readertest.cpp.

                             {
    StringStream ss(" A \t\tB\n \n\nC\r\r \rD \t\n\r E");
    const char* expected = "ABCDE";
    for (size_t i = 0; i < 5; i++) {
        SkipWhitespace(ss);
        EXPECT_EQ(expected[i], ss.Take());
    }
}

Here is the call graph for this function:

TEST() [51/55]

TEST	(	Reader	,
		TrailingCommaHandlerTermination	)

Definition at line 2126 of file readertest.cpp.

                                              {
    TestTrailingCommaHandlerTermination<kParseNoFlags>();
}

Here is the call graph for this function:

TEST() [52/55]

TEST	(	Reader	,
		TrailingCommaHandlerTerminationIterative	)

Definition at line 2130 of file readertest.cpp.

                                                       {
    TestTrailingCommaHandlerTermination<kParseIterativeFlag>();
}

Here is the call graph for this function:

TEST() [53/55]

TEST	(	Reader	,
		TrailingCommas	)

Definition at line 2031 of file readertest.cpp.

                             {
    TestTrailingCommas<kParseNoFlags>();
}

Here is the call graph for this function:

TEST() [54/55]

TEST	(	Reader	,
		TrailingCommasIterative	)

Definition at line 2035 of file readertest.cpp.

                                      {
    TestTrailingCommas<kParseIterativeFlag>();
}

Here is the call graph for this function:

TEST() [55/55]

TEST	(	Reader	,
		UnrecognizedComment	)

Definition at line 1869 of file readertest.cpp.

                                  {
    const char* json = "{\"hello\" : \"world\" /! }";
 
    StringStream s(json);
    ParseObjectHandler h;
    Reader reader;
    EXPECT_FALSE(reader.Parse<kParseCommentsFlag>(s, h));
    EXPECT_EQ(kParseErrorUnspecificSyntaxError, reader.GetParseErrorCode());
}

Here is the call graph for this function:

TestEmptyExceptForCommaErrors()

template<unsigned extraFlags>

void TestEmptyExceptForCommaErrors

(

)

Definition at line 2073 of file readertest.cpp.

                                     {
    // not allowed even with trailing commas enabled; the
    // trailing comma must follow a value.
    {
        StringStream s("[,]");
        ParseArrayHandler<3> h;
        Reader reader;
        ParseResult r = reader.Parse<extraFlags|kParseTrailingCommasFlag>(s, h);
        EXPECT_TRUE(reader.HasParseError());
        EXPECT_EQ(kParseErrorValueInvalid, r.Code());
        EXPECT_EQ(1u, r.Offset());
    }
    {
        StringStream s("{,}");
        ParseObjectHandler h;
        Reader reader;
        ParseResult r = reader.Parse<extraFlags|kParseTrailingCommasFlag>(s, h);
        EXPECT_TRUE(reader.HasParseError());
        EXPECT_EQ(kParseErrorObjectMissName, r.Code());
        EXPECT_EQ(1u, r.Offset());
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

TestInsituMultipleRoot()

template<unsigned parseFlags>

void TestInsituMultipleRoot

(

)

Definition at line 1209 of file readertest.cpp.

                              {
    char* buffer = strdup("{}[] a");
    InsituStringStream s(buffer);
    ParseMultipleRootHandler h;
    Reader reader;
    EXPECT_TRUE(reader.Parse<kParseInsituFlag | parseFlags>(s, h));
    EXPECT_EQ(2u, h.step_);
    EXPECT_TRUE(reader.Parse<kParseInsituFlag | parseFlags>(s, h));
    EXPECT_EQ(4u, h.step_);
    EXPECT_EQ(' ', s.Take());
    EXPECT_EQ('a', s.Take());
    free(buffer);
}

Here is the call graph for this function:

Here is the caller graph for this function:

TestMultipleRoot()

template<unsigned parseFlags>

void TestMultipleRoot

(

)

Definition at line 1188 of file readertest.cpp.

                        {
    StringStream s("{}[] a");
    ParseMultipleRootHandler h;
    Reader reader;
    EXPECT_TRUE(reader.Parse<parseFlags>(s, h));
    EXPECT_EQ(2u, h.step_);
    EXPECT_TRUE(reader.Parse<parseFlags>(s, h));
    EXPECT_EQ(4u, h.step_);
    EXPECT_EQ(' ', s.Take());
    EXPECT_EQ('a', s.Take());
}

Here is the call graph for this function:

Here is the caller graph for this function:

TestMultipleTrailingCommaErrors()

template<unsigned extraFlags>

void TestMultipleTrailingCommaErrors

(

)

Definition at line 2040 of file readertest.cpp.

                                       {
    // only a single trailing comma is allowed.
    {
        StringStream s("[1,2,3,,]");
        ParseArrayHandler<3> h;
        Reader reader;
        ParseResult r = reader.Parse<extraFlags|kParseTrailingCommasFlag>(s, h);
        EXPECT_TRUE(reader.HasParseError());
        EXPECT_EQ(kParseErrorValueInvalid, r.Code());
        EXPECT_EQ(7u, r.Offset());
    }
    {
        const char* json = "{ \"hello\" : \"world\", \"t\" : true , \"f\" : false,"
                "\"n\": null, \"i\":123, \"pi\": 3.1416, \"a\":[1, 2, 3,],,}";
        StringStream s(json);
        ParseObjectHandler h;
        Reader reader;
        ParseResult r = reader.Parse<extraFlags|kParseTrailingCommasFlag>(s, h);
        EXPECT_TRUE(reader.HasParseError());
        EXPECT_EQ(kParseErrorObjectMissName, r.Code());
        EXPECT_EQ(95u, r.Offset());
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

TestString()

template<typename Encoding >

ParseErrorCode TestString

(

const typename Encoding::Ch *

str

)

Definition at line 899 of file readertest.cpp.

                                                          {
    GenericStringStream<Encoding> s(str);
    BaseReaderHandler<Encoding> h;
    GenericReader<Encoding, Encoding> reader;
    reader.template Parse<kParseValidateEncodingFlag>(s, h);
    return reader.GetParseErrorCode();
}

Here is the call graph for this function:

Here is the caller graph for this function:

TestTrailingCommaHandlerTermination()

template<unsigned extraFlags>

void TestTrailingCommaHandlerTermination

(

)

Definition at line 2105 of file readertest.cpp.

                                           {
    {
        HandlerTerminateAtEndArray h;
        Reader reader;
        StringStream s("[1,2,3,]");
        ParseResult r = reader.Parse<extraFlags|kParseTrailingCommasFlag>(s, h);
        EXPECT_TRUE(reader.HasParseError());
        EXPECT_EQ(kParseErrorTermination, r.Code());
        EXPECT_EQ(7u, r.Offset());
    }
    {
        HandlerTerminateAtEndObject h;
        Reader reader;
        StringStream s("{\"t\": true, \"f\": false,}");
        ParseResult r = reader.Parse<extraFlags|kParseTrailingCommasFlag>(s, h);
        EXPECT_TRUE(reader.HasParseError());
        EXPECT_EQ(kParseErrorTermination, r.Code());
        EXPECT_EQ(23u, r.Offset());
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

TestTrailingCommas()

template<unsigned extraFlags>

void TestTrailingCommas

(

)

Definition at line 1992 of file readertest.cpp.

                          {
    {
        StringStream s("[1,2,3,]");
        ParseArrayHandler<3> h;
        Reader reader;
        EXPECT_TRUE(reader.Parse<extraFlags|kParseTrailingCommasFlag>(s, h));
        EXPECT_EQ(5u, h.step_);
    }
    {
        const char* json = "{ \"hello\" : \"world\", \"t\" : true , \"f\" : false,"
                "\"n\": null, \"i\":123, \"pi\": 3.1416, \"a\":[1, 2, 3],}";
        StringStream s(json);
        ParseObjectHandler h;
        Reader reader;
        EXPECT_TRUE(reader.Parse<extraFlags|kParseTrailingCommasFlag>(s, h));
        EXPECT_EQ(20u, h.step_);
    }
    {
        // whitespace around trailing commas
        const char* json = "{ \"hello\" : \"world\", \"t\" : true , \"f\" : false,"
                "\"n\": null, \"i\":123, \"pi\": 3.1416, \"a\":[1, 2, 3\n,\n]\n,\n} ";
        StringStream s(json);
        ParseObjectHandler h;
        Reader reader;
        EXPECT_TRUE(reader.Parse<extraFlags|kParseTrailingCommasFlag>(s, h));
        EXPECT_EQ(20u, h.step_);
    }
    {
        // comments around trailing commas
        const char* json = "{ \"hello\" : \"world\", \"t\" : true , \"f\" : false, \"n\": null,"
                "\"i\":123, \"pi\": 3.1416, \"a\":[1, 2, 3/*test*/,/*test*/]/*test*/,/*test*/}";
        StringStream s(json);
        ParseObjectHandler h;
        Reader reader;
        EXPECT_TRUE(reader.Parse<extraFlags|kParseTrailingCommasFlag|kParseCommentsFlag>(s, h));
        EXPECT_EQ(20u, h.step_);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function: