Electroneum
documenttest.cpp File Reference
#include "unittest.h"
#include "rapidjson/document.h"
#include "rapidjson/writer.h"
#include "rapidjson/filereadstream.h"
#include "rapidjson/encodedstream.h"
#include "rapidjson/stringbuffer.h"
#include <sstream>
#include <algorithm>
Include dependency graph for documenttest.cpp:

Go to the source code of this file.

Classes

struct  OutputStringStream
 

Functions

template<typename DocumentType >
void ParseCheck (DocumentType &doc)
 
template<typename Allocator , typename StackAllocator >
void ParseTest ()
 
 TEST (Document, Parse)
 
 TEST (Document, UnchangedOnParseError)
 
 TEST (Document, Parse_Encoding)
 
 TEST (Document, ParseStream_EncodedInputStream)
 
 TEST (Document, ParseStream_AutoUTFInputStream)
 
 TEST (Document, Swap)
 
 TEST (Document, AcceptWriter)
 
 TEST (Document, UserBuffer)
 
 TEST (Document, AssertAcceptInvalidNameType)
 
 TEST (Document, UTF16_Document)
 

Function Documentation

◆ ParseCheck()

template<typename DocumentType >
void ParseCheck ( DocumentType &  doc)

Definition at line 33 of file documenttest.cpp.

33  {
34  typedef typename DocumentType::ValueType ValueType;
35 
36  EXPECT_FALSE(doc.HasParseError());
37  if (doc.HasParseError())
38  printf("Error: %d at %zu\n", static_cast<int>(doc.GetParseError()), doc.GetErrorOffset());
39  EXPECT_TRUE(static_cast<ParseResult>(doc));
40 
41  EXPECT_TRUE(doc.IsObject());
42 
43  EXPECT_TRUE(doc.HasMember("hello"));
44  const ValueType& hello = doc["hello"];
45  EXPECT_TRUE(hello.IsString());
46  EXPECT_STREQ("world", hello.GetString());
47 
48  EXPECT_TRUE(doc.HasMember("t"));
49  const ValueType& t = doc["t"];
50  EXPECT_TRUE(t.IsTrue());
51 
52  EXPECT_TRUE(doc.HasMember("f"));
53  const ValueType& f = doc["f"];
54  EXPECT_TRUE(f.IsFalse());
55 
56  EXPECT_TRUE(doc.HasMember("n"));
57  const ValueType& n = doc["n"];
58  EXPECT_TRUE(n.IsNull());
59 
60  EXPECT_TRUE(doc.HasMember("i"));
61  const ValueType& i = doc["i"];
62  EXPECT_TRUE(i.IsNumber());
63  EXPECT_EQ(123, i.GetInt());
64 
65  EXPECT_TRUE(doc.HasMember("pi"));
66  const ValueType& pi = doc["pi"];
67  EXPECT_TRUE(pi.IsNumber());
68  EXPECT_DOUBLE_EQ(3.1416, pi.GetDouble());
69 
70  EXPECT_TRUE(doc.HasMember("a"));
71  const ValueType& a = doc["a"];
72  EXPECT_TRUE(a.IsArray());
73  EXPECT_EQ(4u, a.Size());
74  for (SizeType j = 0; j < 4; j++)
75  EXPECT_EQ(j + 1, a[j].GetUint());
76 }
RAPIDJSON_NAMESPACE_BEGIN typedef unsigned SizeType
Size type (for string lengths, array sizes, etc.)
Definition: rapidjson.h:389
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
#define EXPECT_STREQ(s1, s2)
Definition: gtest.h:1995
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
#define EXPECT_DOUBLE_EQ(val1, val2)
Definition: gtest.h:2031
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922
Here is the caller graph for this function:

◆ ParseTest()

template<typename Allocator , typename StackAllocator >
void ParseTest ( )

Definition at line 79 of file documenttest.cpp.

79  {
80  typedef GenericDocument<UTF8<>, Allocator, StackAllocator> DocumentType;
81  DocumentType doc;
82 
83  const char* json = " { \"hello\" : \"world\", \"t\" : true , \"f\" : false, \"n\": null, \"i\":123, \"pi\": 3.1416, \"a\":[1, 2, 3, 4] } ";
84 
85  doc.Parse(json);
86  ParseCheck(doc);
87 
88  doc.SetNull();
89  StringStream s(json);
90  doc.template ParseStream<0>(s);
91  ParseCheck(doc);
92 
93  doc.SetNull();
94  char *buffer = strdup(json);
95  doc.ParseInsitu(buffer);
96  ParseCheck(doc);
97  free(buffer);
98 
99  // Parse(const Ch*, size_t)
100  size_t length = strlen(json);
101  buffer = reinterpret_cast<char*>(malloc(length * 2));
102  memcpy(buffer, json, length);
103  memset(buffer + length, 'X', length);
104 #if RAPIDJSON_HAS_STDSTRING
105  std::string s2(buffer, length); // backup buffer
106 #endif
107  doc.SetNull();
108  doc.Parse(buffer, length);
109  free(buffer);
110  ParseCheck(doc);
111 
112 #if RAPIDJSON_HAS_STDSTRING
113  // Parse(std::string)
114  doc.SetNull();
115  doc.Parse(s2);
116  ParseCheck(doc);
117 #endif
118 }
::std::string string
Definition: gtest-port.h:1097
Read-only string stream.
Definition: fwd.h:47
void ParseCheck(DocumentType &doc)
void * memcpy(void *a, const void *b, size_t c)
Concept for allocating, resizing and freeing memory block.
A document for parsing JSON text as DOM.
Definition: document.h:60
rapidjson::Document json
Definition: transport.cpp:49
Here is the call graph for this function:

◆ TEST() [1/10]

TEST ( Document  ,
Parse   
)

Definition at line 120 of file documenttest.cpp.

120  {
121  ParseTest<MemoryPoolAllocator<>, CrtAllocator>();
122  ParseTest<MemoryPoolAllocator<>, MemoryPoolAllocator<> >();
123  ParseTest<CrtAllocator, MemoryPoolAllocator<> >();
124  ParseTest<CrtAllocator, CrtAllocator>();
125 }
C-runtime library allocator.
Definition: allocators.h:75

◆ TEST() [2/10]

TEST ( Document  ,
UnchangedOnParseError   
)

Definition at line 127 of file documenttest.cpp.

127  {
128  Document doc;
129  doc.SetArray().PushBack(0, doc.GetAllocator());
130 
131  ParseResult noError;
132  EXPECT_TRUE(noError);
133 
134  ParseResult err = doc.Parse("{]");
135  EXPECT_TRUE(doc.HasParseError());
136  EXPECT_NE(err, noError);
137  EXPECT_NE(err.Code(), noError);
138  EXPECT_NE(noError, doc.GetParseError());
139  EXPECT_EQ(err.Code(), doc.GetParseError());
140  EXPECT_EQ(err.Offset(), doc.GetErrorOffset());
141  EXPECT_TRUE(doc.IsArray());
142  EXPECT_EQ(doc.Size(), 1u);
143 
144  err = doc.Parse("{}");
146  EXPECT_FALSE(err.IsError());
147  EXPECT_TRUE(err);
148  EXPECT_EQ(err, noError);
149  EXPECT_EQ(err.Code(), noError);
150  EXPECT_EQ(err.Code(), doc.GetParseError());
151  EXPECT_EQ(err.Offset(), doc.GetErrorOffset());
152  EXPECT_TRUE(doc.IsObject());
153  EXPECT_EQ(doc.MemberCount(), 0u);
154 }
ParseErrorCode GetParseError() const
Get the ParseErrorCode of last parsing.
Definition: document.h:2397
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
ParseErrorCode Code() const
Get the error code.
Definition: error.h:116
size_t GetErrorOffset() const
Get the position of last parsing error in input, 0 otherwise.
Definition: document.h:2400
Allocator & GetAllocator()
Get the allocator of this document.
Definition: document.h:2418
bool HasParseError() const
Whether a parse error has occurred in the last parsing.
Definition: document.h:2394
#define EXPECT_NE(val1, val2)
Definition: gtest.h:1926
GenericDocument & Parse(const typename SourceEncoding::Ch *str)
Parse JSON text from a read-only string (with Encoding conversion)
Definition: document.h:2331
Result of parsing (wraps ParseErrorCode)
Definition: error.h:106
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922
size_t Offset() const
Get the error offset, if IsError(), 0 otherwise.
Definition: error.h:118
Here is the call graph for this function:

◆ TEST() [3/10]

TEST ( Document  ,
Parse_Encoding   
)

Definition at line 174 of file documenttest.cpp.

174  {
175  const char* json = " { \"hello\" : \"world\", \"t\" : true , \"f\" : false, \"n\": null, \"i\":123, \"pi\": 3.1416, \"a\":[1, 2, 3, 4] } ";
176 
177  typedef GenericDocument<UTF16<> > DocumentType;
178  DocumentType doc;
179 
180  // Parse<unsigned, SourceEncoding>(const SourceEncoding::Ch*)
181  // doc.Parse<kParseDefaultFlags, UTF8<> >(json);
182  // EXPECT_FALSE(doc.HasParseError());
183  // EXPECT_EQ(0, StrCmp(doc[L"hello"].GetString(), L"world"));
184 
185  // Parse<unsigned, SourceEncoding>(const SourceEncoding::Ch*, size_t)
186  size_t length = strlen(json);
187  char* buffer = reinterpret_cast<char*>(malloc(length * 2));
188  memcpy(buffer, json, length);
189  memset(buffer + length, 'X', length);
190 #if RAPIDJSON_HAS_STDSTRING
191  std::string s2(buffer, length); // backup buffer
192 #endif
193  doc.SetNull();
194  doc.Parse<kParseDefaultFlags, UTF8<> >(buffer, length);
195  free(buffer);
196  EXPECT_FALSE(doc.HasParseError());
197  if (doc.HasParseError())
198  printf("Error: %d at %zu\n", static_cast<int>(doc.GetParseError()), doc.GetErrorOffset());
199  EXPECT_EQ(0, StrCmp(doc[L"hello"].GetString(), L"world"));
200 
201 #if RAPIDJSON_HAS_STDSTRING
202  // Parse<unsigned, SourceEncoding>(std::string)
203  doc.SetNull();
204 
205 #if defined(_MSC_VER) && _MSC_VER < 1800
206  doc.Parse<kParseDefaultFlags, UTF8<> >(s2.c_str()); // VS2010 or below cannot handle templated function overloading. Use const char* instead.
207 #else
208  doc.Parse<kParseDefaultFlags, UTF8<> >(s2);
209 #endif
210  EXPECT_FALSE(doc.HasParseError());
211  EXPECT_EQ(0, StrCmp(doc[L"hello"].GetString(), L"world"));
212 #endif
213 }
::std::string string
Definition: gtest-port.h:1097
Default parse flags. Can be customized by defining RAPIDJSON_PARSE_DEFAULT_FLAGS. ...
Definition: reader.h:156
int StrCmp(const Ch *s1, const Ch *s2)
Definition: unittest.h:67
void * memcpy(void *a, const void *b, size_t c)
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922
A document for parsing JSON text as DOM.
Definition: document.h:60
rapidjson::Document json
Definition: transport.cpp:49
UTF-8 encoding.
Definition: encodings.h:96
Here is the call graph for this function:

◆ TEST() [4/10]

TEST ( Document  ,
ParseStream_EncodedInputStream   
)

Definition at line 215 of file documenttest.cpp.

215  {
216  // UTF8 -> UTF16
217  FILE* fp = OpenEncodedFile("utf8.json");
218  char buffer[256];
219  FileReadStream bis(fp, buffer, sizeof(buffer));
221 
223  d.ParseStream<0, UTF8<> >(eis);
225 
226  fclose(fp);
227 
228  wchar_t expected[] = L"I can eat glass and it doesn't hurt me.";
229  GenericValue<UTF16<> >& v = d[L"en"];
230  EXPECT_TRUE(v.IsString());
231  EXPECT_EQ(sizeof(expected) / sizeof(wchar_t) - 1, v.GetStringLength());
232  EXPECT_EQ(0, StrCmp(expected, v.GetString()));
233 
234  // UTF16 -> UTF8 in memory
235  StringBuffer bos;
236  typedef EncodedOutputStream<UTF8<>, StringBuffer> OutputStream;
237  OutputStream eos(bos, false); // Not writing BOM
238  {
239  Writer<OutputStream, UTF16<>, UTF8<> > writer(eos);
240  d.Accept(writer);
241  }
242 
243  // Condense the original file and compare.
244  fp = OpenEncodedFile("utf8.json");
245  FileReadStream is(fp, buffer, sizeof(buffer));
246  Reader reader;
247  StringBuffer bos2;
248  Writer<StringBuffer> writer2(bos2);
249  reader.Parse(is, writer2);
250  fclose(fp);
251 
252  EXPECT_EQ(bos.GetSize(), bos2.GetSize());
253  EXPECT_EQ(0, memcmp(bos.GetString(), bos2.GetString(), bos2.GetSize()));
254 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
Output byte stream wrapper with statically bound encoding.
size_t GetSize() const
Get the size of string in bytes in the string buffer.
Definition: stringbuffer.h:82
Represents a JSON value. Use Value for UTF8 encoding and default allocator.
Definition: document.h:57
JSON writer.
Definition: fwd.h:95
ParseResult Parse(InputStream &is, Handler &handler)
Parse JSON text.
Definition: reader.h:557
File byte stream for input using fread().
bool HasParseError() const
Whether a parse error has occurred in the last parsing.
Definition: document.h:2394
int StrCmp(const Ch *s1, const Ch *s2)
Definition: unittest.h:67
const Ch * GetString() const
Definition: stringbuffer.h:73
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862
Input byte stream wrapper with a statically bound encoding.
Definition: encodedstream.h:39
GenericDocument & ParseStream(InputStream &is)
Parse JSON text from an input stream (with Encoding conversion)
Definition: document.h:2265
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922
A document for parsing JSON text as DOM.
Definition: document.h:60
UTF-8 encoding.
Definition: encodings.h:96

◆ TEST() [5/10]

TEST ( Document  ,
ParseStream_AutoUTFInputStream   
)

Definition at line 256 of file documenttest.cpp.

256  {
257  // Any -> UTF8
258  FILE* fp = OpenEncodedFile("utf32be.json");
259  char buffer[256];
260  FileReadStream bis(fp, buffer, sizeof(buffer));
262 
263  Document d;
264  d.ParseStream<0, AutoUTF<unsigned> >(eis);
266 
267  fclose(fp);
268 
269  char expected[] = "I can eat glass and it doesn't hurt me.";
270  Value& v = d["en"];
271  EXPECT_TRUE(v.IsString());
272  EXPECT_EQ(sizeof(expected) - 1, v.GetStringLength());
273  EXPECT_EQ(0, StrCmp(expected, v.GetString()));
274 
275  // UTF8 -> UTF8 in memory
276  StringBuffer bos;
277  Writer<StringBuffer> writer(bos);
278  d.Accept(writer);
279 
280  // Condense the original file and compare.
281  fp = OpenEncodedFile("utf8.json");
282  FileReadStream is(fp, buffer, sizeof(buffer));
283  Reader reader;
284  StringBuffer bos2;
285  Writer<StringBuffer> writer2(bos2);
286  reader.Parse(is, writer2);
287  fclose(fp);
288 
289  EXPECT_EQ(bos.GetSize(), bos2.GetSize());
290  EXPECT_EQ(0, memcmp(bos.GetString(), bos2.GetString(), bos2.GetSize()));
291 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
Input stream wrapper with dynamically bound encoding and automatic encoding detection.
size_t GetSize() const
Get the size of string in bytes in the string buffer.
Definition: stringbuffer.h:82
JSON writer.
Definition: fwd.h:95
ParseResult Parse(InputStream &is, Handler &handler)
Parse JSON text.
Definition: reader.h:557
File byte stream for input using fread().
bool HasParseError() const
Whether a parse error has occurred in the last parsing.
Definition: document.h:2394
int StrCmp(const Ch *s1, const Ch *s2)
Definition: unittest.h:67
const Ch * GetString() const
Definition: stringbuffer.h:73
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862
GenericDocument & ParseStream(InputStream &is)
Parse JSON text from an input stream (with Encoding conversion)
Definition: document.h:2265
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922

◆ TEST() [6/10]

TEST ( Document  ,
Swap   
)

Definition at line 293 of file documenttest.cpp.

293  {
294  Document d1;
296 
297  d1.SetArray().PushBack(1, a).PushBack(2, a);
298 
299  Value o;
300  o.SetObject().AddMember("a", 1, a);
301 
302  // Swap between Document and Value
303  d1.Swap(o);
304  EXPECT_TRUE(d1.IsObject());
305  EXPECT_TRUE(o.IsArray());
306 
307  d1.Swap(o);
308  EXPECT_TRUE(d1.IsArray());
309  EXPECT_TRUE(o.IsObject());
310 
311  o.Swap(d1);
312  EXPECT_TRUE(d1.IsObject());
313  EXPECT_TRUE(o.IsArray());
314 
315  // Swap between Document and Document
316  Document d2;
317  d2.SetArray().PushBack(3, a);
318  d1.Swap(d2);
319  EXPECT_TRUE(d1.IsArray());
320  EXPECT_TRUE(d2.IsObject());
321  EXPECT_EQ(&d2.GetAllocator(), &a);
322 
323  // reset value
324  Value().Swap(d1);
325  EXPECT_TRUE(d1.IsNull());
326 
327  // reset document, including allocator
328  Document().Swap(d2);
329  EXPECT_TRUE(d2.IsNull());
330  EXPECT_NE(&d2.GetAllocator(), &a);
331 
332  // testing std::swap compatibility
333  d1.SetBool(true);
334  using std::swap;
335  swap(d1, d2);
336  EXPECT_TRUE(d1.IsNull());
337  EXPECT_TRUE(d2.IsTrue());
338 
339  swap(o, d2);
340  EXPECT_TRUE(o.IsTrue());
341  EXPECT_TRUE(d2.IsArray());
342 }
GenericDocument & Swap(GenericDocument &rhs) RAPIDJSON_NOEXCEPT
Exchange the contents of this document with those of another.
Definition: document.h:2212
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
Allocator & GetAllocator()
Get the allocator of this document.
Definition: document.h:2418
GenericValue< UTF8<> > Value
GenericValue with UTF8 encoding.
Definition: document.h:2116
GenericDocument< UTF8<> > Document
GenericDocument with UTF8 encoding.
Definition: document.h:2512
#define EXPECT_NE(val1, val2)
Definition: gtest.h:1926
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922
Here is the call graph for this function:

◆ TEST() [7/10]

TEST ( Document  ,
AcceptWriter   
)

Definition at line 359 of file documenttest.cpp.

359  {
360  Document doc;
361  doc.Parse(" { \"hello\" : \"world\", \"t\" : true , \"f\" : false, \"n\": null, \"i\":123, \"pi\": 3.1416, \"a\":[1, 2, 3, 4] } ");
362 
364  Writer<OutputStringStream> writer(os);
365  doc.Accept(writer);
366 
367  EXPECT_EQ("{\"hello\":\"world\",\"t\":true,\"f\":false,\"n\":null,\"i\":123,\"pi\":3.1416,\"a\":[1,2,3,4]}", os.str());
368 }
JSON writer.
Definition: fwd.h:95
GenericDocument & Parse(const typename SourceEncoding::Ch *str)
Parse JSON text from a read-only string (with Encoding conversion)
Definition: document.h:2331
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922
Here is the call graph for this function:

◆ TEST() [8/10]

TEST ( Document  ,
UserBuffer   
)

Definition at line 370 of file documenttest.cpp.

370  {
372  char valueBuffer[4096];
373  char parseBuffer[1024];
374  MemoryPoolAllocator<> valueAllocator(valueBuffer, sizeof(valueBuffer));
375  MemoryPoolAllocator<> parseAllocator(parseBuffer, sizeof(parseBuffer));
376  DocumentType doc(&valueAllocator, sizeof(parseBuffer) / 2, &parseAllocator);
377  doc.Parse(" { \"hello\" : \"world\", \"t\" : true , \"f\" : false, \"n\": null, \"i\":123, \"pi\": 3.1416, \"a\":[1, 2, 3, 4] } ");
378  EXPECT_FALSE(doc.HasParseError());
379  EXPECT_LE(valueAllocator.Size(), sizeof(valueBuffer));
380  EXPECT_LE(parseAllocator.Size(), sizeof(parseBuffer));
381 
382  // Cover MemoryPoolAllocator::Capacity()
383  EXPECT_LE(valueAllocator.Size(), valueAllocator.Capacity());
384  EXPECT_LE(parseAllocator.Size(), parseAllocator.Capacity());
385 }
#define EXPECT_LE(val1, val2)
Definition: gtest.h:1928
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862
A document for parsing JSON text as DOM.
Definition: document.h:60
Here is the call graph for this function:

◆ TEST() [9/10]

TEST ( Document  ,
AssertAcceptInvalidNameType   
)

Definition at line 388 of file documenttest.cpp.

388  {
389  Document doc;
390  doc.SetObject();
391  doc.AddMember("a", 0, doc.GetAllocator());
392  doc.FindMember("a")->name.SetNull(); // Change name to non-string type.
393 
395  Writer<OutputStringStream> writer(os);
396  ASSERT_THROW(doc.Accept(writer), AssertException);
397 }
JSON writer.
Definition: fwd.h:95
Allocator & GetAllocator()
Get the allocator of this document.
Definition: document.h:2418
#define ASSERT_THROW(statement, expected_exception)
Definition: gtest.h:1849
Here is the call graph for this function:

◆ TEST() [10/10]

TEST ( Document  ,
UTF16_Document   
)

Definition at line 400 of file documenttest.cpp.

400  {
402  json.Parse<kParseValidateEncodingFlag>(L"[{\"created_at\":\"Wed Oct 30 17:13:20 +0000 2012\"}]");
403 
404  ASSERT_TRUE(json.IsArray());
405  GenericValue< UTF16<> >& v = json[0];
406  ASSERT_TRUE(v.IsObject());
407 
408  GenericValue< UTF16<> >& s = v[L"created_at"];
409  ASSERT_TRUE(s.IsString());
410 
411  EXPECT_EQ(0, memcmp(L"Wed Oct 30 17:13:20 +0000 2012", s.GetString(), (s.GetStringLength() + 1) * sizeof(wchar_t)));
412 }
Represents a JSON value. Use Value for UTF8 encoding and default allocator.
Definition: document.h:57
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
Validate encoding of JSON strings.
Definition: reader.h:148
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922
A document for parsing JSON text as DOM.
Definition: document.h:60
rapidjson::Document json
Definition: transport.cpp:49