Monero
Classes | Macros | Functions
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());\
}
s
const char * s
Definition: minissdp.c:596
UTF8
UTF-8 encoding.
Definition: encodings.h:96
buffer
const T buffer
Definition: byte_slice.cpp:83
str
const char *const str
Definition: portlistingparse.c:23
CrtAllocator
C-runtime library allocator.
Definition: allocators.h:75
h
static uint64_t h
Definition: blockchain_stats.cpp:55

◆ 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_); \
} \
}
kParseErrorNone
No error.
Definition: error.h:65
pymoduletest.u
u
Definition: pymoduletest.py:20
s
const char * s
Definition: minissdp.c:596
pymoduletest.e
e
Definition: pymoduletest.py:79
kParseFullPrecisionFlag
Parse number in full precision (but slower).
Definition: reader.h:151
a
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
str
const char *const str
Definition: portlistingparse.c:23
testing::internal::Double
FloatingPoint< double > Double
Definition: gtest-internal.h:421
h
static uint64_t h
Definition: blockchain_stats.cpp:55

◆ 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());\
}
s
const char * s
Definition: minissdp.c:596
buffer
const T buffer
Definition: byte_slice.cpp:83
str
const char *const str
Definition: portlistingparse.c:23
h
static uint64_t h
Definition: blockchain_stats.cpp:55

◆ 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_); \
}
pymoduletest.u
u
Definition: pymoduletest.py:20
s
const char * s
Definition: minissdp.c:596
str
const char *const str
Definition: portlistingparse.c:23
h
static uint64_t h
Definition: blockchain_stats.cpp:55

◆ 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); \
} \
}
kParseErrorNone
No error.
Definition: error.h:65
pymoduletest.u
u
Definition: pymoduletest.py:20
s
const char * s
Definition: minissdp.c:596
kParseNanAndInfFlag
Allow parsing NaN, Inf, Infinity, -Inf and -Infinity as doubles.
Definition: reader.h:155
kParseNumbersAsStringsFlag
Parse all numbers (ints/doubles) as strings.
Definition: reader.h:153
pymoduletest.e
e
Definition: pymoduletest.py:79
StrDup
Ch * StrDup(const Ch *str)
Definition: unittest.h:73
a
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
str
const char *const str
Definition: portlistingparse.c:23
testing::internal::Double
FloatingPoint< double > Double
Definition: gtest-internal.h:421
EXPECT_EQ
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922
h
static uint64_t h
Definition: blockchain_stats.cpp:55
kParseInsituFlag
In-situ(destructive) parsing.
Definition: reader.h:147
json
rapidjson::Document json
Definition: transport.cpp:49

◆ 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());\
}
s
const char * s
Definition: minissdp.c:596
kParseNanAndInfFlag
Allow parsing NaN, Inf, Infinity, -Inf and -Infinity as doubles.
Definition: reader.h:155
buffer
const T buffer
Definition: byte_slice.cpp:83
str
const char *const str
Definition: portlistingparse.c:23
h
static uint64_t h
Definition: blockchain_stats.cpp:55

◆ 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());\
}
pymoduletest.u
u
Definition: pymoduletest.py:20
s
const char * s
Definition: minissdp.c:596
kParseFullPrecisionFlag
Parse number in full precision (but slower).
Definition: reader.h:151
buffer
const T buffer
Definition: byte_slice.cpp:83
str
const char *const str
Definition: portlistingparse.c:23
h
static uint64_t h
Definition: blockchain_stats.cpp:55

◆ 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_); \
}
Ch
#define Ch(x, y, z)
Definition: sha512-blocks.c:34
s
const char * s
Definition: minissdp.c:596
pymoduletest.e
e
Definition: pymoduletest.py:79
buffer
const T buffer
Definition: byte_slice.cpp:83
StrDup
Ch * StrDup(const Ch *str)
Definition: unittest.h:73
StrLen
unsigned StrLen(const Ch *s)
Definition: unittest.h:60
kParseValidateEncodingFlag
Validate encoding of JSON strings.
Definition: reader.h:148
h
static uint64_t h
Definition: blockchain_stats.cpp:55
kParseInsituFlag
In-situ(destructive) parsing.
Definition: reader.h:147

◆ 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());\
}
s
const char * s
Definition: minissdp.c:596
UTF8
UTF-8 encoding.
Definition: encodings.h:96
str
const char *const str
Definition: portlistingparse.c:23
kParseValidateEncodingFlag
Validate encoding of JSON strings.
Definition: reader.h:148
h
static uint64_t h
Definition: blockchain_stats.cpp:55

◆ 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); \
}
Ch
#define Ch(x, y, z)
Definition: sha512-blocks.c:34
rapidjson::Encoding
Concept for encoding of Unicode characters.
pymoduletest.e
e
Definition: pymoduletest.py:79

◆ 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); \
}
Ch
#define Ch(x, y, z)
Definition: sha512-blocks.c:34
rapidjson::Encoding
Concept for encoding of Unicode characters.
pymoduletest.e
e
Definition: pymoduletest.py:79

◆ 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());\
}
Ch
#define Ch(x, y, z)
Definition: sha512-blocks.c:34
s
const char * s
Definition: minissdp.c:596
pymoduletest.e
e
Definition: pymoduletest.py:79
kParseErrorStringInvalidEncoding
Invalid encoding in string.
Definition: error.h:82
h
static uint64_t h
Definition: blockchain_stats.cpp:55

◆ 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());\
}
kParseErrorTermination
Parsing was terminated.
Definition: error.h:88
h
static uint64_t h
Definition: blockchain_stats.cpp:55
json
rapidjson::Document json
Definition: transport.cpp:49

◆ 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()); \
}
kParseIterativeFlag
Iterative(constant complexity in terms of function call stack size) parsing.
Definition: reader.h:149
text
const char * text
Definition: minihttptestserver.c:269
json
rapidjson::Document json
Definition: transport.cpp:49

Function Documentation

◆ TEST() [1/55]

TEST ( Reader  ,
ParseTrue   
)

◆ TEST() [2/55]

TEST ( Reader  ,
ParseFalse   
)

◆ TEST() [3/55]

TEST ( Reader  ,
ParseNumber_Integer   
)

◆ TEST() [4/55]

TEST ( Reader  ,
ParseNumber_NormalPrecisionDouble   
)

◆ TEST() [5/55]

TEST ( Reader  ,
ParseNumber_FullPrecisionDouble   
)

◆ TEST() [6/55]

TEST ( Reader  ,
ParseNumber_NormalPrecisionError   
)

◆ TEST() [7/55]

TEST ( Reader  ,
ParseNumberError_NormalPrecisionDouble   
)

◆ TEST() [8/55]

TEST ( Reader  ,
ParseNumberError_FullPrecisionDouble   
)

◆ TEST() [9/55]

TEST ( Reader  ,
ParseString   
)

◆ TEST() [10/55]

TEST ( Reader  ,
ParseString_Transcoding   
)

◆ TEST() [11/55]

TEST ( Reader  ,
ParseString_TranscodingWithValidation   
)

◆ TEST() [12/55]

TEST ( Reader  ,
ParseString_NonDestructive   
)

◆ TEST() [13/55]

TEST ( Reader  ,
ParseString_Error   
)

◆ TEST() [14/55]

TEST ( Reader  ,
ParseEmptyArray   
)

◆ TEST() [15/55]

TEST ( Reader  ,
ParseArray   
)

◆ TEST() [16/55]

TEST ( Reader  ,
ParseArray_Error   
)

◆ TEST() [17/55]

TEST ( Reader  ,
ParseObject   
)

◆ TEST() [18/55]

TEST ( Reader  ,
Parse_EmptyObject   
)

◆ TEST() [19/55]

TEST ( Reader  ,
Parse_MultipleRoot   
)

◆ TEST() [20/55]

TEST ( Reader  ,
ParseIterative_MultipleRoot   
)

◆ TEST() [21/55]

TEST ( Reader  ,
ParseInsitu_MultipleRoot   
)

◆ TEST() [22/55]

TEST ( Reader  ,
ParseInsituIterative_MultipleRoot   
)

◆ TEST() [23/55]

TEST ( Reader  ,
ParseDocument_Error   
)

◆ TEST() [24/55]

TEST ( Reader  ,
ParseValue_Error   
)

◆ TEST() [25/55]

TEST ( Reader  ,
ParseObject_Error   
)

◆ TEST() [26/55]

TEST ( Reader  ,
SkipWhitespace   
)

◆ TEST() [27/55]

TEST ( Reader  ,
CustomStringStream   
)

◆ TEST() [28/55]

TEST ( Reader  ,
Parse_IStreamWrapper_StringStream   
)

◆ TEST() [29/55]

TEST ( Reader  ,
IterativeParsing_ErrorHandling   
)

◆ TEST() [30/55]

TEST ( Reader  ,
IterativeParsing_General   
)

◆ TEST() [31/55]

TEST ( Reader  ,
IterativeParsing_Count   
)

◆ TEST() [32/55]

TEST ( Reader  ,
IterativePullParsing_General   
)

◆ TEST() [33/55]

TEST ( Reader  ,
IterativeParsing_ShortCircuit   
)

◆ TEST() [34/55]

TEST ( Reader  ,
BaseReaderHandler_Default   
)

◆ TEST() [35/55]

TEST ( Reader  ,
ParseTerminationByHandler   
)

◆ TEST() [36/55]

TEST ( Reader  ,
ParseComments   
)

◆ TEST() [37/55]

TEST ( Reader  ,
ParseEmptyInlineComment   
)

◆ TEST() [38/55]

TEST ( Reader  ,
ParseEmptyOnelineComment   
)

◆ TEST() [39/55]

TEST ( Reader  ,
ParseMultipleCommentsInARow   
)

◆ TEST() [40/55]

TEST ( Reader  ,
InlineCommentsAreDisabledByDefault   
)

◆ TEST() [41/55]

TEST ( Reader  ,
OnelineCommentsAreDisabledByDefault   
)

◆ TEST() [42/55]

TEST ( Reader  ,
EofAfterOneLineComment   
)

◆ TEST() [43/55]

TEST ( Reader  ,
IncompleteMultilineComment   
)

◆ TEST() [44/55]

TEST ( Reader  ,
IncompleteMultilineComment2   
)

◆ TEST() [45/55]

TEST ( Reader  ,
UnrecognizedComment   
)

◆ TEST() [46/55]

TEST ( Reader  ,
NumbersAsStrings   
)

◆ TEST() [47/55]

TEST ( Reader  ,
TrailingCommas   
)

◆ TEST() [48/55]

TEST ( Reader  ,
TrailingCommasIterative   
)

◆ TEST() [49/55]

TEST ( Reader  ,
MultipleTrailingCommaErrors   
)

◆ TEST() [50/55]

TEST ( Reader  ,
MultipleTrailingCommaErrorsIterative   
)

◆ TEST() [51/55]

TEST ( Reader  ,
EmptyExceptForCommaErrors   
)

◆ TEST() [52/55]

TEST ( Reader  ,
EmptyExceptForCommaErrorsIterative   
)

◆ TEST() [53/55]

TEST ( Reader  ,
TrailingCommaHandlerTermination   
)

◆ TEST() [54/55]

TEST ( Reader  ,
TrailingCommaHandlerTerminationIterative   
)

◆ TEST() [55/55]

TEST ( Reader  ,
ParseNanAndInfinity   
)

◆ 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 ( )
Generated on Sun Oct 12 2025 12:00:00 for Monero by   doxygen 1.8.14