Electroneum
valuetest.cpp File Reference
#include "unittest.h"
#include "rapidjson/document.h"
#include <algorithm>
Include dependency graph for valuetest.cpp:

Go to the source code of this file.

Classes

struct  TerminateHandler< e >
 
struct  ValueIntComparer
 

Macros

#define TEST_TERMINATION(e, json)
 

Functions

 TEST (Value, Size)
 
 TEST (Value, DefaultConstructor)
 
 TEST (Value, AssignmentOperator)
 
template<typename A , typename B >
void TestEqual (const A &a, const B &b)
 
template<typename A , typename B >
void TestUnequal (const A &a, const B &b)
 
 TEST (Value, EqualtoOperator)
 
template<typename Value >
void TestCopyFrom ()
 
 TEST (Value, CopyFrom)
 
 TEST (Value, Swap)
 
 TEST (Value, Null)
 
 TEST (Value, True)
 
 TEST (Value, False)
 
 TEST (Value, Int)
 
 TEST (Value, Uint)
 
 TEST (Value, Int64)
 
 TEST (Value, Uint64)
 
 TEST (Value, Double)
 
 TEST (Value, Float)
 
 TEST (Value, IsLosslessDouble)
 
 TEST (Value, IsLosslessFloat)
 
 TEST (Value, String)
 
 TEST (Value, SetStringNull)
 
 TEST (Value, Array)
 
 TEST (Value, ArrayHelper)
 
 TEST (Value, Object)
 
 TEST (Value, ObjectHelper)
 
 TEST (Value, EraseMember_String)
 
 TEST (Value, BigNestedArray)
 
 TEST (Value, BigNestedObject)
 
 TEST (Value, RemoveLastElement)
 
 TEST (Document, CrtAllocator)
 
 TEST (Value, AllocateShortString)
 
 TEST (Value, AcceptTerminationByHandler)
 
 TEST (Value, MergeDuplicateKey)
 

Macro Definition Documentation

◆ TEST_TERMINATION

#define TEST_TERMINATION (   e,
  json 
)
Value:
{\
Document d; \
EXPECT_FALSE(d.Parse(json).HasParseError()); \
Reader reader; \
TerminateHandler<e> h;\
EXPECT_FALSE(d.Accept(h));\
}
rapidjson::Document json
Definition: transport.cpp:49

Definition at line 1741 of file valuetest.cpp.

Function Documentation

◆ TEST() [1/31]

TEST ( Value  ,
Size   
)

Definition at line 26 of file valuetest.cpp.

26  {
27  if (sizeof(SizeType) == 4) {
28 #if RAPIDJSON_48BITPOINTER_OPTIMIZATION
29  EXPECT_EQ(16, sizeof(Value));
30 #elif RAPIDJSON_64BIT
31  EXPECT_EQ(24, sizeof(Value));
32 #else
33  EXPECT_EQ(16, sizeof(Value));
34 #endif
35  }
36 }
RAPIDJSON_NAMESPACE_BEGIN typedef unsigned SizeType
Size type (for string lengths, array sizes, etc.)
Definition: rapidjson.h:389
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922

◆ TEST() [2/31]

TEST ( Value  ,
DefaultConstructor   
)

Definition at line 38 of file valuetest.cpp.

38  {
39  Value x;
40  EXPECT_EQ(kNullType, x.GetType());
41  EXPECT_TRUE(x.IsNull());
42 
43  //std::cout << "sizeof(Value): " << sizeof(x) << std::endl;
44 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922
null
Definition: rapidjson.h:621

◆ TEST() [3/31]

TEST ( Value  ,
AssignmentOperator   
)

Definition at line 121 of file valuetest.cpp.

121  {
122  Value x(1234);
123  Value y;
124  y = x;
125  EXPECT_TRUE(x.IsNull()); // move semantic
126  EXPECT_EQ(1234, y.GetInt());
127 
128  y = 5678;
129  EXPECT_TRUE(y.IsInt());
130  EXPECT_EQ(5678, y.GetInt());
131 
132  x = "Hello";
133  EXPECT_TRUE(x.IsString());
134  EXPECT_STREQ(x.GetString(),"Hello");
135 
136  y = StringRef(x.GetString(),x.GetStringLength());
137  EXPECT_TRUE(y.IsString());
138  EXPECT_EQ(y.GetString(),x.GetString());
139  EXPECT_EQ(y.GetStringLength(),x.GetStringLength());
140 
141  static char mstr[] = "mutable";
142  // y = mstr; // should not compile
143  y = StringRef(mstr);
144  EXPECT_TRUE(y.IsString());
145  EXPECT_EQ(y.GetString(),mstr);
146 
147 #if RAPIDJSON_HAS_CXX11_RVALUE_REFS
148  // C++11 move assignment
149  x = Value("World");
150  EXPECT_TRUE(x.IsString());
151  EXPECT_STREQ("World", x.GetString());
152 
153  x = std::move(y);
154  EXPECT_TRUE(y.IsNull());
155  EXPECT_TRUE(x.IsString());
156  EXPECT_EQ(x.GetString(), mstr);
157 
158  y = std::move(Value().SetInt(1234));
159  EXPECT_TRUE(y.IsInt());
160  EXPECT_EQ(1234, y);
161 #endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS
162 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
#define EXPECT_STREQ(s1, s2)
Definition: gtest.h:1995
GenericStringRef< CharType > StringRef(const CharType *str)
Mark a character pointer as constant string.
Definition: document.h:361
GenericValue< UTF8<> > Value
GenericValue with UTF8 encoding.
Definition: document.h:2116
const T & move(const T &t)
Definition: gtest-port.h:1317
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922
Here is the call graph for this function:

◆ TEST() [4/31]

TEST ( Value  ,
EqualtoOperator   
)

Definition at line 180 of file valuetest.cpp.

180  {
181  Value::AllocatorType allocator;
182  Value x(kObjectType);
183  x.AddMember("hello", "world", allocator)
184  .AddMember("t", Value(true).Move(), allocator)
185  .AddMember("f", Value(false).Move(), allocator)
186  .AddMember("n", Value(kNullType).Move(), allocator)
187  .AddMember("i", 123, allocator)
188  .AddMember("pi", 3.14, allocator)
189  .AddMember("a", Value(kArrayType).Move().PushBack(1, allocator).PushBack(2, allocator).PushBack(3, allocator), allocator);
190 
191  // Test templated operator==() and operator!=()
192  TestEqual(x["hello"], "world");
193  const char* cc = "world";
194  TestEqual(x["hello"], cc);
195  char* c = strdup("world");
196  TestEqual(x["hello"], c);
197  free(c);
198 
199  TestEqual(x["t"], true);
200  TestEqual(x["f"], false);
201  TestEqual(x["i"], 123);
202  TestEqual(x["pi"], 3.14);
203 
204  // Test operator==() (including different allocators)
205  CrtAllocator crtAllocator;
207  GenericDocument<UTF8<>, CrtAllocator> z(&crtAllocator);
208  y.CopyFrom(x, crtAllocator);
209  z.CopyFrom(y, z.GetAllocator());
210  TestEqual(x, y);
211  TestEqual(y, z);
212  TestEqual(z, x);
213 
214  // Swapping member order should be fine.
215  EXPECT_TRUE(y.RemoveMember("t"));
216  TestUnequal(x, y);
217  TestUnequal(z, y);
218  EXPECT_TRUE(z.RemoveMember("t"));
219  TestUnequal(x, z);
220  TestEqual(y, z);
221  y.AddMember("t", false, crtAllocator);
222  z.AddMember("t", false, z.GetAllocator());
223  TestUnequal(x, y);
224  TestUnequal(z, x);
225  y["t"] = true;
226  z["t"] = true;
227  TestEqual(x, y);
228  TestEqual(y, z);
229  TestEqual(z, x);
230 
231  // Swapping element order is not OK
232  x["a"][0].Swap(x["a"][1]);
233  TestUnequal(x, y);
234  x["a"][0].Swap(x["a"][1]);
235  TestEqual(x, y);
236 
237  // Array of different size
238  x["a"].PushBack(4, allocator);
239  TestUnequal(x, y);
240  x["a"].PopBack();
241  TestEqual(x, y);
242 
243  // Issue #129: compare Uint64
244  x.SetUint64(RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0xFFFFFFF0));
245  y.SetUint64(RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0xFFFFFFFF));
246  TestUnequal(x, y);
247 }
void TestUnequal(const A &a, const B &b)
Definition: valuetest.cpp:173
void TestEqual(const A &a, const B &b)
Definition: valuetest.cpp:165
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
#define RAPIDJSON_UINT64_C2(high32, low32)
Construct a 64-bit literal by a pair of 32-bit integer.
Definition: rapidjson.h:294
object
Definition: rapidjson.h:624
C-runtime library allocator.
Definition: allocators.h:75
array
Definition: rapidjson.h:625
GenericValue< UTF8<> > Value
GenericValue with UTF8 encoding.
Definition: document.h:2116
A document for parsing JSON text as DOM.
Definition: document.h:60
null
Definition: rapidjson.h:621
Here is the call graph for this function:

◆ TEST() [5/31]

TEST ( Value  ,
CopyFrom   
)

Definition at line 283 of file valuetest.cpp.

283  {
284  TestCopyFrom<Value>();
285  TestCopyFrom<GenericValue<UTF8<>, CrtAllocator> >();
286 }
C-runtime library allocator.
Definition: allocators.h:75

◆ TEST() [6/31]

TEST ( Value  ,
Swap   
)

Definition at line 288 of file valuetest.cpp.

288  {
289  Value v1(1234);
290  Value v2(kObjectType);
291 
292  EXPECT_EQ(&v1, &v1.Swap(v2));
293  EXPECT_TRUE(v1.IsObject());
294  EXPECT_TRUE(v2.IsInt());
295  EXPECT_EQ(1234, v2.GetInt());
296 
297  // testing std::swap compatibility
298  using std::swap;
299  swap(v1, v2);
300  EXPECT_TRUE(v1.IsInt());
301  EXPECT_TRUE(v2.IsObject());
302 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
object
Definition: rapidjson.h:624
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922

◆ TEST() [7/31]

TEST ( Value  ,
Null   
)

Definition at line 304 of file valuetest.cpp.

304  {
305  // Default constructor
306  Value x;
307  EXPECT_EQ(kNullType, x.GetType());
308  EXPECT_TRUE(x.IsNull());
309 
310  EXPECT_FALSE(x.IsTrue());
311  EXPECT_FALSE(x.IsFalse());
312  EXPECT_FALSE(x.IsNumber());
313  EXPECT_FALSE(x.IsString());
314  EXPECT_FALSE(x.IsObject());
315  EXPECT_FALSE(x.IsArray());
316 
317  // Constructor with type
318  Value y(kNullType);
319  EXPECT_TRUE(y.IsNull());
320 
321  // SetNull();
322  Value z(true);
323  z.SetNull();
324  EXPECT_TRUE(z.IsNull());
325 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922
null
Definition: rapidjson.h:621

◆ TEST() [8/31]

TEST ( Value  ,
True   
)

Definition at line 327 of file valuetest.cpp.

327  {
328  // Constructor with bool
329  Value x(true);
330  EXPECT_EQ(kTrueType, x.GetType());
331  EXPECT_TRUE(x.GetBool());
332  EXPECT_TRUE(x.IsBool());
333  EXPECT_TRUE(x.IsTrue());
334 
335  EXPECT_FALSE(x.IsNull());
336  EXPECT_FALSE(x.IsFalse());
337  EXPECT_FALSE(x.IsNumber());
338  EXPECT_FALSE(x.IsString());
339  EXPECT_FALSE(x.IsObject());
340  EXPECT_FALSE(x.IsArray());
341 
342  // Constructor with type
343  Value y(kTrueType);
344  EXPECT_TRUE(y.IsTrue());
345 
346  // SetBool()
347  Value z;
348  z.SetBool(true);
349  EXPECT_TRUE(z.IsTrue());
350 
351  // Templated functions
352  EXPECT_TRUE(z.Is<bool>());
353  EXPECT_TRUE(z.Get<bool>());
354  EXPECT_FALSE(z.Set<bool>(false).Get<bool>());
355  EXPECT_TRUE(z.Set(true).Get<bool>());
356 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
true
Definition: rapidjson.h:623
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922

◆ TEST() [9/31]

TEST ( Value  ,
False   
)

Definition at line 358 of file valuetest.cpp.

358  {
359  // Constructor with bool
360  Value x(false);
361  EXPECT_EQ(kFalseType, x.GetType());
362  EXPECT_TRUE(x.IsBool());
363  EXPECT_TRUE(x.IsFalse());
364 
365  EXPECT_FALSE(x.IsNull());
366  EXPECT_FALSE(x.IsTrue());
367  EXPECT_FALSE(x.GetBool());
368  //EXPECT_FALSE((bool)x);
369  EXPECT_FALSE(x.IsNumber());
370  EXPECT_FALSE(x.IsString());
371  EXPECT_FALSE(x.IsObject());
372  EXPECT_FALSE(x.IsArray());
373 
374  // Constructor with type
375  Value y(kFalseType);
376  EXPECT_TRUE(y.IsFalse());
377 
378  // SetBool()
379  Value z;
380  z.SetBool(false);
381  EXPECT_TRUE(z.IsFalse());
382 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
false
Definition: rapidjson.h:622
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922

◆ TEST() [10/31]

TEST ( Value  ,
Int   
)

Definition at line 384 of file valuetest.cpp.

384  {
385  // Constructor with int
386  Value x(1234);
387  EXPECT_EQ(kNumberType, x.GetType());
388  EXPECT_EQ(1234, x.GetInt());
389  EXPECT_EQ(1234u, x.GetUint());
390  EXPECT_EQ(1234, x.GetInt64());
391  EXPECT_EQ(1234u, x.GetUint64());
392  EXPECT_NEAR(1234.0, x.GetDouble(), 0.0);
393  //EXPECT_EQ(1234, (int)x);
394  //EXPECT_EQ(1234, (unsigned)x);
395  //EXPECT_EQ(1234, (int64_t)x);
396  //EXPECT_EQ(1234, (uint64_t)x);
397  //EXPECT_EQ(1234, (double)x);
398  EXPECT_TRUE(x.IsNumber());
399  EXPECT_TRUE(x.IsInt());
400  EXPECT_TRUE(x.IsUint());
401  EXPECT_TRUE(x.IsInt64());
402  EXPECT_TRUE(x.IsUint64());
403 
404  EXPECT_FALSE(x.IsDouble());
405  EXPECT_FALSE(x.IsFloat());
406  EXPECT_FALSE(x.IsNull());
407  EXPECT_FALSE(x.IsBool());
408  EXPECT_FALSE(x.IsFalse());
409  EXPECT_FALSE(x.IsTrue());
410  EXPECT_FALSE(x.IsString());
411  EXPECT_FALSE(x.IsObject());
412  EXPECT_FALSE(x.IsArray());
413 
414  Value nx(-1234);
415  EXPECT_EQ(-1234, nx.GetInt());
416  EXPECT_EQ(-1234, nx.GetInt64());
417  EXPECT_TRUE(nx.IsInt());
418  EXPECT_TRUE(nx.IsInt64());
419  EXPECT_FALSE(nx.IsUint());
420  EXPECT_FALSE(nx.IsUint64());
421 
422  // Constructor with type
423  Value y(kNumberType);
424  EXPECT_TRUE(y.IsNumber());
425  EXPECT_TRUE(y.IsInt());
426  EXPECT_EQ(0, y.GetInt());
427 
428  // SetInt()
429  Value z;
430  z.SetInt(1234);
431  EXPECT_EQ(1234, z.GetInt());
432 
433  // operator=(int)
434  z = 5678;
435  EXPECT_EQ(5678, z.GetInt());
436 
437  // Templated functions
438  EXPECT_TRUE(z.Is<int>());
439  EXPECT_EQ(5678, z.Get<int>());
440  EXPECT_EQ(5679, z.Set(5679).Get<int>());
441  EXPECT_EQ(5680, z.Set<int>(5680).Get<int>());
442 
443 #ifdef _MSC_VER
444  // long as int on MSC platforms
445  RAPIDJSON_STATIC_ASSERT(sizeof(long) == sizeof(int));
446  z.SetInt(2222);
447  EXPECT_TRUE(z.Is<long>());
448  EXPECT_EQ(2222l, z.Get<long>());
449  EXPECT_EQ(3333l, z.Set(3333l).Get<long>());
450  EXPECT_EQ(4444l, z.Set<long>(4444l).Get<long>());
451  EXPECT_TRUE(z.IsInt());
452 #endif
453 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
#define RAPIDJSON_STATIC_ASSERT(x)
(Internal) macro to check for conditions at compile-time
Definition: rapidjson.h:450
#define EXPECT_NEAR(val1, val2, abs_error)
Definition: gtest.h:2043
number
Definition: rapidjson.h:627
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922

◆ TEST() [11/31]

TEST ( Value  ,
Uint   
)

Definition at line 455 of file valuetest.cpp.

455  {
456  // Constructor with int
457  Value x(1234u);
458  EXPECT_EQ(kNumberType, x.GetType());
459  EXPECT_EQ(1234, x.GetInt());
460  EXPECT_EQ(1234u, x.GetUint());
461  EXPECT_EQ(1234, x.GetInt64());
462  EXPECT_EQ(1234u, x.GetUint64());
463  EXPECT_TRUE(x.IsNumber());
464  EXPECT_TRUE(x.IsInt());
465  EXPECT_TRUE(x.IsUint());
466  EXPECT_TRUE(x.IsInt64());
467  EXPECT_TRUE(x.IsUint64());
468  EXPECT_NEAR(1234.0, x.GetDouble(), 0.0); // Number can always be cast as double but !IsDouble().
469 
470  EXPECT_FALSE(x.IsDouble());
471  EXPECT_FALSE(x.IsFloat());
472  EXPECT_FALSE(x.IsNull());
473  EXPECT_FALSE(x.IsBool());
474  EXPECT_FALSE(x.IsFalse());
475  EXPECT_FALSE(x.IsTrue());
476  EXPECT_FALSE(x.IsString());
477  EXPECT_FALSE(x.IsObject());
478  EXPECT_FALSE(x.IsArray());
479 
480  // SetUint()
481  Value z;
482  z.SetUint(1234);
483  EXPECT_EQ(1234u, z.GetUint());
484 
485  // operator=(unsigned)
486  z = 5678u;
487  EXPECT_EQ(5678u, z.GetUint());
488 
489  z = 2147483648u; // 2^31, cannot cast as int
490  EXPECT_EQ(2147483648u, z.GetUint());
491  EXPECT_FALSE(z.IsInt());
492  EXPECT_TRUE(z.IsInt64()); // Issue 41: Incorrect parsing of unsigned int number types
493 
494  // Templated functions
495  EXPECT_TRUE(z.Is<unsigned>());
496  EXPECT_EQ(2147483648u, z.Get<unsigned>());
497  EXPECT_EQ(2147483649u, z.Set(2147483649u).Get<unsigned>());
498  EXPECT_EQ(2147483650u, z.Set<unsigned>(2147483650u).Get<unsigned>());
499 
500 #ifdef _MSC_VER
501  // unsigned long as unsigned on MSC platforms
502  RAPIDJSON_STATIC_ASSERT(sizeof(unsigned long) == sizeof(unsigned));
503  z.SetUint(2222);
504  EXPECT_TRUE(z.Is<unsigned long>());
505  EXPECT_EQ(2222ul, z.Get<unsigned long>());
506  EXPECT_EQ(3333ul, z.Set(3333ul).Get<unsigned long>());
507  EXPECT_EQ(4444ul, z.Set<unsigned long>(4444ul).Get<unsigned long>());
508  EXPECT_TRUE(x.IsUint());
509 #endif
510 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
#define RAPIDJSON_STATIC_ASSERT(x)
(Internal) macro to check for conditions at compile-time
Definition: rapidjson.h:450
#define EXPECT_NEAR(val1, val2, abs_error)
Definition: gtest.h:2043
number
Definition: rapidjson.h:627
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922

◆ TEST() [12/31]

TEST ( Value  ,
Int64   
)

Definition at line 512 of file valuetest.cpp.

512  {
513  // Constructor with int
514  Value x(int64_t(1234));
515  EXPECT_EQ(kNumberType, x.GetType());
516  EXPECT_EQ(1234, x.GetInt());
517  EXPECT_EQ(1234u, x.GetUint());
518  EXPECT_EQ(1234, x.GetInt64());
519  EXPECT_EQ(1234u, x.GetUint64());
520  EXPECT_TRUE(x.IsNumber());
521  EXPECT_TRUE(x.IsInt());
522  EXPECT_TRUE(x.IsUint());
523  EXPECT_TRUE(x.IsInt64());
524  EXPECT_TRUE(x.IsUint64());
525 
526  EXPECT_FALSE(x.IsDouble());
527  EXPECT_FALSE(x.IsFloat());
528  EXPECT_FALSE(x.IsNull());
529  EXPECT_FALSE(x.IsBool());
530  EXPECT_FALSE(x.IsFalse());
531  EXPECT_FALSE(x.IsTrue());
532  EXPECT_FALSE(x.IsString());
533  EXPECT_FALSE(x.IsObject());
534  EXPECT_FALSE(x.IsArray());
535 
536  Value nx(int64_t(-1234));
537  EXPECT_EQ(-1234, nx.GetInt());
538  EXPECT_EQ(-1234, nx.GetInt64());
539  EXPECT_TRUE(nx.IsInt());
540  EXPECT_TRUE(nx.IsInt64());
541  EXPECT_FALSE(nx.IsUint());
542  EXPECT_FALSE(nx.IsUint64());
543 
544  // SetInt64()
545  Value z;
546  z.SetInt64(1234);
547  EXPECT_EQ(1234, z.GetInt64());
548 
549  z.SetInt64(2147483648u); // 2^31, cannot cast as int
550  EXPECT_FALSE(z.IsInt());
551  EXPECT_TRUE(z.IsUint());
552  EXPECT_NEAR(2147483648.0, z.GetDouble(), 0.0);
553 
554  z.SetInt64(int64_t(4294967295u) + 1); // 2^32, cannot cast as uint
555  EXPECT_FALSE(z.IsInt());
556  EXPECT_FALSE(z.IsUint());
557  EXPECT_NEAR(4294967296.0, z.GetDouble(), 0.0);
558 
559  z.SetInt64(-int64_t(2147483648u) - 1); // -2^31-1, cannot cast as int
560  EXPECT_FALSE(z.IsInt());
561  EXPECT_NEAR(-2147483649.0, z.GetDouble(), 0.0);
562 
563  int64_t i = static_cast<int64_t>(RAPIDJSON_UINT64_C2(0x80000000, 00000000));
564  z.SetInt64(i);
565  EXPECT_DOUBLE_EQ(-9223372036854775808.0, z.GetDouble());
566 
567  // Templated functions
568  EXPECT_TRUE(z.Is<int64_t>());
569  EXPECT_EQ(i, z.Get<int64_t>());
570 #if 0 // signed integer underflow is undefined behaviour
571  EXPECT_EQ(i - 1, z.Set(i - 1).Get<int64_t>());
572  EXPECT_EQ(i - 2, z.Set<int64_t>(i - 2).Get<int64_t>());
573 #endif
574 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
#define RAPIDJSON_UINT64_C2(high32, low32)
Construct a 64-bit literal by a pair of 32-bit integer.
Definition: rapidjson.h:294
#define EXPECT_NEAR(val1, val2, abs_error)
Definition: gtest.h:2043
number
Definition: rapidjson.h:627
signed __int64 int64_t
Definition: stdint.h:135
#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

◆ TEST() [13/31]

TEST ( Value  ,
Uint64   
)

Definition at line 576 of file valuetest.cpp.

576  {
577  // Constructor with int
578  Value x(uint64_t(1234));
579  EXPECT_EQ(kNumberType, x.GetType());
580  EXPECT_EQ(1234, x.GetInt());
581  EXPECT_EQ(1234u, x.GetUint());
582  EXPECT_EQ(1234, x.GetInt64());
583  EXPECT_EQ(1234u, x.GetUint64());
584  EXPECT_TRUE(x.IsNumber());
585  EXPECT_TRUE(x.IsInt());
586  EXPECT_TRUE(x.IsUint());
587  EXPECT_TRUE(x.IsInt64());
588  EXPECT_TRUE(x.IsUint64());
589 
590  EXPECT_FALSE(x.IsDouble());
591  EXPECT_FALSE(x.IsFloat());
592  EXPECT_FALSE(x.IsNull());
593  EXPECT_FALSE(x.IsBool());
594  EXPECT_FALSE(x.IsFalse());
595  EXPECT_FALSE(x.IsTrue());
596  EXPECT_FALSE(x.IsString());
597  EXPECT_FALSE(x.IsObject());
598  EXPECT_FALSE(x.IsArray());
599 
600  // SetUint64()
601  Value z;
602  z.SetUint64(1234);
603  EXPECT_EQ(1234u, z.GetUint64());
604 
605  z.SetUint64(uint64_t(2147483648u)); // 2^31, cannot cast as int
606  EXPECT_FALSE(z.IsInt());
607  EXPECT_TRUE(z.IsUint());
608  EXPECT_TRUE(z.IsInt64());
609 
610  z.SetUint64(uint64_t(4294967295u) + 1); // 2^32, cannot cast as uint
611  EXPECT_FALSE(z.IsInt());
612  EXPECT_FALSE(z.IsUint());
613  EXPECT_TRUE(z.IsInt64());
614 
615  uint64_t u = RAPIDJSON_UINT64_C2(0x80000000, 0x00000000);
616  z.SetUint64(u); // 2^63 cannot cast as int64
617  EXPECT_FALSE(z.IsInt64());
618  EXPECT_EQ(u, z.GetUint64()); // Issue 48
619  EXPECT_DOUBLE_EQ(9223372036854775808.0, z.GetDouble());
620 
621  // Templated functions
622  EXPECT_TRUE(z.Is<uint64_t>());
623  EXPECT_EQ(u, z.Get<uint64_t>());
624  EXPECT_EQ(u + 1, z.Set(u + 1).Get<uint64_t>());
625  EXPECT_EQ(u + 2, z.Set<uint64_t>(u + 2).Get<uint64_t>());
626 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
#define RAPIDJSON_UINT64_C2(high32, low32)
Construct a 64-bit literal by a pair of 32-bit integer.
Definition: rapidjson.h:294
unsigned __int64 uint64_t
Definition: stdint.h:136
number
Definition: rapidjson.h:627
#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

◆ TEST() [14/31]

TEST ( Value  ,
Double   
)

Definition at line 628 of file valuetest.cpp.

628  {
629  // Constructor with double
630  Value x(12.34);
631  EXPECT_EQ(kNumberType, x.GetType());
632  EXPECT_NEAR(12.34, x.GetDouble(), 0.0);
633  EXPECT_TRUE(x.IsNumber());
634  EXPECT_TRUE(x.IsDouble());
635 
636  EXPECT_FALSE(x.IsInt());
637  EXPECT_FALSE(x.IsNull());
638  EXPECT_FALSE(x.IsBool());
639  EXPECT_FALSE(x.IsFalse());
640  EXPECT_FALSE(x.IsTrue());
641  EXPECT_FALSE(x.IsString());
642  EXPECT_FALSE(x.IsObject());
643  EXPECT_FALSE(x.IsArray());
644 
645  // SetDouble()
646  Value z;
647  z.SetDouble(12.34);
648  EXPECT_NEAR(12.34, z.GetDouble(), 0.0);
649 
650  z = 56.78;
651  EXPECT_NEAR(56.78, z.GetDouble(), 0.0);
652 
653  // Templated functions
654  EXPECT_TRUE(z.Is<double>());
655  EXPECT_EQ(56.78, z.Get<double>());
656  EXPECT_EQ(57.78, z.Set(57.78).Get<double>());
657  EXPECT_EQ(58.78, z.Set<double>(58.78).Get<double>());
658 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
#define EXPECT_NEAR(val1, val2, abs_error)
Definition: gtest.h:2043
number
Definition: rapidjson.h:627
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922

◆ TEST() [15/31]

TEST ( Value  ,
Float   
)

Definition at line 660 of file valuetest.cpp.

660  {
661  // Constructor with double
662  Value x(12.34f);
663  EXPECT_EQ(kNumberType, x.GetType());
664  EXPECT_NEAR(12.34f, x.GetFloat(), 0.0);
665  EXPECT_TRUE(x.IsNumber());
666  EXPECT_TRUE(x.IsDouble());
667  EXPECT_TRUE(x.IsFloat());
668 
669  EXPECT_FALSE(x.IsInt());
670  EXPECT_FALSE(x.IsNull());
671  EXPECT_FALSE(x.IsBool());
672  EXPECT_FALSE(x.IsFalse());
673  EXPECT_FALSE(x.IsTrue());
674  EXPECT_FALSE(x.IsString());
675  EXPECT_FALSE(x.IsObject());
676  EXPECT_FALSE(x.IsArray());
677 
678  // SetFloat()
679  Value z;
680  z.SetFloat(12.34f);
681  EXPECT_NEAR(12.34f, z.GetFloat(), 0.0f);
682 
683  // Issue 573
684  z.SetInt(0);
685  EXPECT_EQ(0.0f, z.GetFloat());
686 
687  z = 56.78f;
688  EXPECT_NEAR(56.78f, z.GetFloat(), 0.0f);
689 
690  // Templated functions
691  EXPECT_TRUE(z.Is<float>());
692  EXPECT_EQ(56.78f, z.Get<float>());
693  EXPECT_EQ(57.78f, z.Set(57.78f).Get<float>());
694  EXPECT_EQ(58.78f, z.Set<float>(58.78f).Get<float>());
695 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
#define EXPECT_NEAR(val1, val2, abs_error)
Definition: gtest.h:2043
number
Definition: rapidjson.h:627
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922

◆ TEST() [16/31]

TEST ( Value  ,
IsLosslessDouble   
)

Definition at line 697 of file valuetest.cpp.

697  {
698  EXPECT_TRUE(Value(0.0).IsLosslessDouble());
699  EXPECT_TRUE(Value(12.34).IsLosslessDouble());
700  EXPECT_TRUE(Value(-123).IsLosslessDouble());
701  EXPECT_TRUE(Value(2147483648u).IsLosslessDouble());
702  EXPECT_TRUE(Value(-static_cast<int64_t>(RAPIDJSON_UINT64_C2(0x40000000, 0x00000000))).IsLosslessDouble());
703 #if !(defined(_MSC_VER) && _MSC_VER < 1800) // VC2010 has problem
704  EXPECT_TRUE(Value(RAPIDJSON_UINT64_C2(0xA0000000, 0x00000000)).IsLosslessDouble());
705 #endif
706 
707  EXPECT_FALSE(Value(static_cast<int64_t>(RAPIDJSON_UINT64_C2(0x7FFFFFFF, 0xFFFFFFFF))).IsLosslessDouble()); // INT64_MAX
708  EXPECT_FALSE(Value(-static_cast<int64_t>(RAPIDJSON_UINT64_C2(0x7FFFFFFF, 0xFFFFFFFF))).IsLosslessDouble()); // -INT64_MAX
709  EXPECT_TRUE(Value(-static_cast<int64_t>(RAPIDJSON_UINT64_C2(0x7FFFFFFF, 0xFFFFFFFF)) - 1).IsLosslessDouble()); // INT64_MIN
710  EXPECT_FALSE(Value(RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0xFFFFFFFF)).IsLosslessDouble()); // UINT64_MAX
711 
712  EXPECT_TRUE(Value(3.4028234e38f).IsLosslessDouble()); // FLT_MAX
713  EXPECT_TRUE(Value(-3.4028234e38f).IsLosslessDouble()); // -FLT_MAX
714  EXPECT_TRUE(Value(1.17549435e-38f).IsLosslessDouble()); // FLT_MIN
715  EXPECT_TRUE(Value(-1.17549435e-38f).IsLosslessDouble()); // -FLT_MIN
716  EXPECT_TRUE(Value(1.7976931348623157e+308).IsLosslessDouble()); // DBL_MAX
717  EXPECT_TRUE(Value(-1.7976931348623157e+308).IsLosslessDouble()); // -DBL_MAX
718  EXPECT_TRUE(Value(2.2250738585072014e-308).IsLosslessDouble()); // DBL_MIN
719  EXPECT_TRUE(Value(-2.2250738585072014e-308).IsLosslessDouble()); // -DBL_MIN
720 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
#define RAPIDJSON_UINT64_C2(high32, low32)
Construct a 64-bit literal by a pair of 32-bit integer.
Definition: rapidjson.h:294
GenericValue< UTF8<> > Value
GenericValue with UTF8 encoding.
Definition: document.h:2116
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [17/31]

TEST ( Value  ,
IsLosslessFloat   
)

Definition at line 722 of file valuetest.cpp.

722  {
723  EXPECT_TRUE(Value(12.25).IsLosslessFloat());
724  EXPECT_TRUE(Value(-123).IsLosslessFloat());
725  EXPECT_TRUE(Value(2147483648u).IsLosslessFloat());
726  EXPECT_TRUE(Value(3.4028234e38f).IsLosslessFloat());
727  EXPECT_TRUE(Value(-3.4028234e38f).IsLosslessFloat());
728  EXPECT_FALSE(Value(3.4028235e38).IsLosslessFloat());
729  EXPECT_FALSE(Value(0.3).IsLosslessFloat());
730 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericValue< UTF8<> > Value
GenericValue with UTF8 encoding.
Definition: document.h:2116
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [18/31]

TEST ( Value  ,
String   
)

Definition at line 732 of file valuetest.cpp.

732  {
733  // Construction with const string
734  Value x("Hello", 5); // literal
735  EXPECT_EQ(kStringType, x.GetType());
736  EXPECT_TRUE(x.IsString());
737  EXPECT_STREQ("Hello", x.GetString());
738  EXPECT_EQ(5u, x.GetStringLength());
739 
740  EXPECT_FALSE(x.IsNumber());
741  EXPECT_FALSE(x.IsNull());
742  EXPECT_FALSE(x.IsBool());
743  EXPECT_FALSE(x.IsFalse());
744  EXPECT_FALSE(x.IsTrue());
745  EXPECT_FALSE(x.IsObject());
746  EXPECT_FALSE(x.IsArray());
747 
748  static const char cstr[] = "World"; // const array
749  Value(cstr).Swap(x);
750  EXPECT_TRUE(x.IsString());
751  EXPECT_EQ(x.GetString(), cstr);
752  EXPECT_EQ(x.GetStringLength(), sizeof(cstr)-1);
753 
754  static char mstr[] = "Howdy"; // non-const array
755  // Value(mstr).Swap(x); // should not compile
756  Value(StringRef(mstr)).Swap(x);
757  EXPECT_TRUE(x.IsString());
758  EXPECT_EQ(x.GetString(), mstr);
759  EXPECT_EQ(x.GetStringLength(), sizeof(mstr)-1);
760  strncpy(mstr,"Hello", sizeof(mstr));
761  EXPECT_STREQ(x.GetString(), "Hello");
762 
763  const char* pstr = cstr;
764  //Value(pstr).Swap(x); // should not compile
765  Value(StringRef(pstr)).Swap(x);
766  EXPECT_TRUE(x.IsString());
767  EXPECT_EQ(x.GetString(), cstr);
768  EXPECT_EQ(x.GetStringLength(), sizeof(cstr)-1);
769 
770  char* mpstr = mstr;
771  Value(StringRef(mpstr,sizeof(mstr)-1)).Swap(x);
772  EXPECT_TRUE(x.IsString());
773  EXPECT_EQ(x.GetString(), mstr);
774  EXPECT_EQ(x.GetStringLength(), 5u);
775  EXPECT_STREQ(x.GetString(), "Hello");
776 
777  // Constructor with copy string
778  MemoryPoolAllocator<> allocator;
779  Value c(x.GetString(), x.GetStringLength(), allocator);
780  EXPECT_NE(x.GetString(), c.GetString());
781  EXPECT_EQ(x.GetStringLength(), c.GetStringLength());
782  EXPECT_STREQ(x.GetString(), c.GetString());
783  //x.SetString("World");
784  x.SetString("World", 5);
785  EXPECT_STREQ("Hello", c.GetString());
786  EXPECT_EQ(5u, c.GetStringLength());
787 
788  // Constructor with type
789  Value y(kStringType);
790  EXPECT_TRUE(y.IsString());
791  EXPECT_STREQ("", y.GetString()); // Empty string should be "" instead of 0 (issue 226)
792  EXPECT_EQ(0u, y.GetStringLength());
793 
794  // SetConsttring()
795  Value z;
796  z.SetString("Hello");
797  EXPECT_TRUE(x.IsString());
798  z.SetString("Hello", 5);
799  EXPECT_STREQ("Hello", z.GetString());
800  EXPECT_STREQ("Hello", z.GetString());
801  EXPECT_EQ(5u, z.GetStringLength());
802 
803  z.SetString("Hello");
804  EXPECT_TRUE(z.IsString());
805  EXPECT_STREQ("Hello", z.GetString());
806 
807  //z.SetString(mstr); // should not compile
808  //z.SetString(pstr); // should not compile
809  z.SetString(StringRef(mstr));
810  EXPECT_TRUE(z.IsString());
811  EXPECT_STREQ(z.GetString(), mstr);
812 
813  z.SetString(cstr);
814  EXPECT_TRUE(z.IsString());
815  EXPECT_EQ(cstr, z.GetString());
816 
817  z = cstr;
818  EXPECT_TRUE(z.IsString());
819  EXPECT_EQ(cstr, z.GetString());
820 
821  // SetString()
822  char s[] = "World";
823  Value w;
824  w.SetString(s, static_cast<SizeType>(strlen(s)), allocator);
825  s[0] = '\0';
826  EXPECT_STREQ("World", w.GetString());
827  EXPECT_EQ(5u, w.GetStringLength());
828 
829  // templated functions
830  EXPECT_TRUE(z.Is<const char*>());
831  EXPECT_STREQ(cstr, z.Get<const char*>());
832  EXPECT_STREQ("Apple", z.Set<const char*>("Apple").Get<const char*>());
833 
834 #if RAPIDJSON_HAS_STDSTRING
835  {
836  std::string str = "Hello World";
837  str[5] = '\0';
838  EXPECT_STREQ(str.data(),"Hello"); // embedded '\0'
839  EXPECT_EQ(str.size(), 11u);
840 
841  // no copy
842  Value vs0(StringRef(str));
843  EXPECT_TRUE(vs0.IsString());
844  EXPECT_EQ(vs0.GetString(), str.data());
845  EXPECT_EQ(vs0.GetStringLength(), str.size());
846  TestEqual(vs0, str);
847 
848  // do copy
849  Value vs1(str, allocator);
850  EXPECT_TRUE(vs1.IsString());
851  EXPECT_NE(vs1.GetString(), str.data());
852  EXPECT_NE(vs1.GetString(), str); // not equal due to embedded '\0'
853  EXPECT_EQ(vs1.GetStringLength(), str.size());
854  TestEqual(vs1, str);
855 
856  // SetString
857  str = "World";
858  vs0.SetNull().SetString(str, allocator);
859  EXPECT_TRUE(vs0.IsString());
860  EXPECT_STREQ(vs0.GetString(), str.c_str());
861  EXPECT_EQ(vs0.GetStringLength(), str.size());
862  TestEqual(str, vs0);
863  TestUnequal(str, vs1);
864 
865  // vs1 = str; // should not compile
866  vs1 = StringRef(str);
867  TestEqual(str, vs1);
868  TestEqual(vs0, vs1);
869 
870  // Templated function.
871  EXPECT_TRUE(vs0.Is<std::string>());
872  EXPECT_EQ(str, vs0.Get<std::string>());
873  vs0.Set<std::string>(std::string("Apple"), allocator);
874  EXPECT_EQ(std::string("Apple"), vs0.Get<std::string>());
875  vs0.Set(std::string("Orange"), allocator);
876  EXPECT_EQ(std::string("Orange"), vs0.Get<std::string>());
877  }
878 #endif // RAPIDJSON_HAS_STDSTRING
879 }
void TestUnequal(const A &a, const B &b)
Definition: valuetest.cpp:173
void TestEqual(const A &a, const B &b)
Definition: valuetest.cpp:165
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
#define EXPECT_STREQ(s1, s2)
Definition: gtest.h:1995
::std::string string
Definition: gtest-port.h:1097
GenericStringRef< CharType > StringRef(const CharType *str)
Mark a character pointer as constant string.
Definition: document.h:361
string
Definition: rapidjson.h:626
GenericValue< UTF8<> > Value
GenericValue with UTF8 encoding.
Definition: document.h:2116
#define EXPECT_NE(val1, val2)
Definition: gtest.h:1926
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922
Here is the call graph for this function:

◆ TEST() [19/31]

TEST ( Value  ,
SetStringNull   
)

Definition at line 882 of file valuetest.cpp.

882  {
883 
884  MemoryPoolAllocator<> allocator;
885  const char* nullPtr = 0;
886  {
887  // Construction with string type creates empty string
888  Value v(kStringType);
889  EXPECT_NE(v.GetString(), nullPtr); // non-null string returned
890  EXPECT_EQ(v.GetStringLength(), 0u);
891 
892  // Construction from/setting to null without length not allowed
894  EXPECT_THROW(Value(StringRef(nullPtr), allocator), AssertException);
895  EXPECT_THROW(v.SetString(nullPtr, allocator), AssertException);
896 
897  // Non-empty length with null string is not allowed
898  EXPECT_THROW(v.SetString(nullPtr, 17u), AssertException);
899  EXPECT_THROW(v.SetString(nullPtr, 42u, allocator), AssertException);
900 
901  // Setting to null string with empty length is allowed
902  v.SetString(nullPtr, 0u);
903  EXPECT_NE(v.GetString(), nullPtr); // non-null string returned
904  EXPECT_EQ(v.GetStringLength(), 0u);
905 
906  v.SetNull();
907  v.SetString(nullPtr, 0u, allocator);
908  EXPECT_NE(v.GetString(), nullPtr); // non-null string returned
909  EXPECT_EQ(v.GetStringLength(), 0u);
910  }
911  // Construction with null string and empty length is allowed
912  {
913  Value v(nullPtr,0u);
914  EXPECT_NE(v.GetString(), nullPtr); // non-null string returned
915  EXPECT_EQ(v.GetStringLength(), 0u);
916  }
917  {
918  Value v(nullPtr, 0u, allocator);
919  EXPECT_NE(v.GetString(), nullPtr); // non-null string returned
920  EXPECT_EQ(v.GetStringLength(), 0u);
921  }
922 }
#define EXPECT_THROW(statement, expected_exception)
Definition: gtest.h:1843
GenericStringRef< CharType > StringRef(const CharType *str)
Mark a character pointer as constant string.
Definition: document.h:361
string
Definition: rapidjson.h:626
GenericValue< UTF8<> > Value
GenericValue with UTF8 encoding.
Definition: document.h:2116
#define EXPECT_NE(val1, val2)
Definition: gtest.h:1926
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922
Here is the call graph for this function:

◆ TEST() [20/31]

TEST ( Value  ,
Array   
)

Definition at line 1080 of file valuetest.cpp.

1080  {
1081  Value x(kArrayType);
1082  const Value& y = x;
1083  Value::AllocatorType allocator;
1084 
1085  EXPECT_EQ(kArrayType, x.GetType());
1086  EXPECT_TRUE(x.IsArray());
1087  EXPECT_TRUE(x.Empty());
1088  EXPECT_EQ(0u, x.Size());
1089  EXPECT_TRUE(y.IsArray());
1090  EXPECT_TRUE(y.Empty());
1091  EXPECT_EQ(0u, y.Size());
1092 
1093  EXPECT_FALSE(x.IsNull());
1094  EXPECT_FALSE(x.IsBool());
1095  EXPECT_FALSE(x.IsFalse());
1096  EXPECT_FALSE(x.IsTrue());
1097  EXPECT_FALSE(x.IsString());
1098  EXPECT_FALSE(x.IsObject());
1099 
1100  TestArray(x, allocator);
1101 
1102  // Working in gcc without C++11, but VS2013 cannot compile. To be diagnosed.
1103  // http://en.wikipedia.org/wiki/Erase-remove_idiom
1104  x.Clear();
1105  for (int i = 0; i < 10; i++)
1106  if (i % 2 == 0)
1107  x.PushBack(i, allocator);
1108  else
1109  x.PushBack(Value(kNullType).Move(), allocator);
1110 
1111  const Value null(kNullType);
1112  x.Erase(std::remove(x.Begin(), x.End(), null), x.End());
1113  EXPECT_EQ(5u, x.Size());
1114  for (int i = 0; i < 5; i++)
1115  EXPECT_EQ(i * 2, x[static_cast<SizeType>(i)]);
1116 
1117  // SetArray()
1118  Value z;
1119  z.SetArray();
1120  EXPECT_TRUE(z.IsArray());
1121  EXPECT_TRUE(z.Empty());
1122 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
array
Definition: rapidjson.h:625
GenericValue< UTF8<> > Value
GenericValue with UTF8 encoding.
Definition: document.h:2116
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922
null
Definition: rapidjson.h:621

◆ TEST() [21/31]

TEST ( Value  ,
ArrayHelper   
)

Definition at line 1124 of file valuetest.cpp.

1124  {
1125  Value::AllocatorType allocator;
1126  {
1127  Value x(kArrayType);
1128  Value::Array a = x.GetArray();
1129  TestArray(a, allocator);
1130  }
1131 
1132  {
1133  Value x(kArrayType);
1134  Value::Array a = x.GetArray();
1135  a.PushBack(1, allocator);
1136 
1137  Value::Array a2(a); // copy constructor
1138  EXPECT_EQ(1, a2.Size());
1139 
1140  Value::Array a3 = a;
1141  EXPECT_EQ(1, a3.Size());
1142 
1143  Value::ConstArray y = static_cast<const Value&>(x).GetArray();
1144  (void)y;
1145  // y.PushBack(1, allocator); // should not compile
1146 
1147  // Templated functions
1148  x.Clear();
1149  EXPECT_TRUE(x.Is<Value::Array>());
1150  EXPECT_TRUE(x.Is<Value::ConstArray>());
1151  a.PushBack(1, allocator);
1152  EXPECT_EQ(1, x.Get<Value::Array>()[0].GetInt());
1153  EXPECT_EQ(1, x.Get<Value::ConstArray>()[0].GetInt());
1154 
1155  Value x2;
1156  x2.Set<Value::Array>(a);
1157  EXPECT_TRUE(x.IsArray()); // IsArray() is invariant after moving.
1158  EXPECT_EQ(1, x2.Get<Value::Array>()[0].GetInt());
1159  }
1160 
1161  {
1162  Value y(kArrayType);
1163  y.PushBack(123, allocator);
1164 
1165  Value x(y.GetArray()); // Construct value form array.
1166  EXPECT_TRUE(x.IsArray());
1167  EXPECT_EQ(123, x[0].GetInt());
1168  EXPECT_TRUE(y.IsArray()); // Invariant
1169  EXPECT_TRUE(y.Empty());
1170  }
1171 
1172  {
1173  Value x(kArrayType);
1174  Value y(kArrayType);
1175  y.PushBack(123, allocator);
1176  x.PushBack(y.GetArray(), allocator); // Implicit constructor to convert Array to GenericValue
1177 
1178  EXPECT_EQ(1, x.Size());
1179  EXPECT_EQ(123, x[0][0].GetInt());
1180  EXPECT_TRUE(y.IsArray());
1181  EXPECT_TRUE(y.Empty());
1182  }
1183 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
array
Definition: rapidjson.h:625
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
Helper class for accessing Value of array type.
Definition: document.h:558
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922

◆ TEST() [22/31]

TEST ( Value  ,
Object   
)

Definition at line 1483 of file valuetest.cpp.

1483  {
1484  Value x(kObjectType);
1485  const Value& y = x; // const version
1486  Value::AllocatorType allocator;
1487 
1488  EXPECT_EQ(kObjectType, x.GetType());
1489  EXPECT_TRUE(x.IsObject());
1490  EXPECT_TRUE(x.ObjectEmpty());
1491  EXPECT_EQ(0u, x.MemberCount());
1492  EXPECT_EQ(kObjectType, y.GetType());
1493  EXPECT_TRUE(y.IsObject());
1494  EXPECT_TRUE(y.ObjectEmpty());
1495  EXPECT_EQ(0u, y.MemberCount());
1496 
1497  TestObject(x, allocator);
1498 
1499  // SetObject()
1500  Value z;
1501  z.SetObject();
1502  EXPECT_TRUE(z.IsObject());
1503 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
object
Definition: rapidjson.h:624
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922

◆ TEST() [23/31]

TEST ( Value  ,
ObjectHelper   
)

Definition at line 1505 of file valuetest.cpp.

1505  {
1506  Value::AllocatorType allocator;
1507  {
1508  Value x(kObjectType);
1509  Value::Object o = x.GetObject();
1510  TestObject(o, allocator);
1511  }
1512 
1513  {
1514  Value x(kObjectType);
1515  Value::Object o = x.GetObject();
1516  o.AddMember("1", 1, allocator);
1517 
1518  Value::Object o2(o); // copy constructor
1519  EXPECT_EQ(1, o2.MemberCount());
1520 
1521  Value::Object o3 = o;
1522  EXPECT_EQ(1, o3.MemberCount());
1523 
1524  Value::ConstObject y = static_cast<const Value&>(x).GetObject();
1525  (void)y;
1526  // y.AddMember("1", 1, allocator); // should not compile
1527 
1528  // Templated functions
1529  x.RemoveAllMembers();
1530  EXPECT_TRUE(x.Is<Value::Object>());
1532  o.AddMember("1", 1, allocator);
1533  EXPECT_EQ(1, x.Get<Value::Object>()["1"].GetInt());
1534  EXPECT_EQ(1, x.Get<Value::ConstObject>()["1"].GetInt());
1535 
1536  Value x2;
1537  x2.Set<Value::Object>(o);
1538  EXPECT_TRUE(x.IsObject()); // IsObject() is invariant after moving
1539  EXPECT_EQ(1, x2.Get<Value::Object>()["1"].GetInt());
1540  }
1541 
1542  {
1543  Value x(kObjectType);
1544  x.AddMember("a", "apple", allocator);
1545  Value y(x.GetObject());
1546  EXPECT_STREQ("apple", y["a"].GetString());
1547  EXPECT_TRUE(x.IsObject()); // Invariant
1548  }
1549 
1550  {
1551  Value x(kObjectType);
1552  x.AddMember("a", "apple", allocator);
1553  Value y(kObjectType);
1554  y.AddMember("fruits", x.GetObject(), allocator);
1555  EXPECT_STREQ("apple", y["fruits"]["a"].GetString());
1556  EXPECT_TRUE(x.IsObject()); // Invariant
1557  }
1558 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
#define EXPECT_STREQ(s1, s2)
Definition: gtest.h:1995
object
Definition: rapidjson.h:624
GenericObject AddMember(ValueType &name, ValueType &value, AllocatorType &allocator) const
Definition: document.h:2614
Helper class for accessing Value of object type.
Definition: document.h:559
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922

◆ TEST() [24/31]

TEST ( Value  ,
EraseMember_String   
)

Definition at line 1599 of file valuetest.cpp.

1599  {
1600  Value::AllocatorType allocator;
1601  Value x(kObjectType);
1602  x.AddMember("A", "Apple", allocator);
1603  x.AddMember("B", "Banana", allocator);
1604 
1605  EXPECT_TRUE(x.EraseMember("B"));
1606  EXPECT_FALSE(x.HasMember("B"));
1607 
1608  EXPECT_FALSE(x.EraseMember("nonexist"));
1609 
1610  GenericValue<UTF8<>, CrtAllocator> othername("A");
1611  EXPECT_TRUE(x.EraseMember(othername));
1612  EXPECT_FALSE(x.HasMember("A"));
1613 
1614  EXPECT_TRUE(x.MemberBegin() == x.MemberEnd());
1615 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
object
Definition: rapidjson.h:624
C-runtime library allocator.
Definition: allocators.h:75
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [25/31]

TEST ( Value  ,
BigNestedArray   
)

Definition at line 1617 of file valuetest.cpp.

1617  {
1618  MemoryPoolAllocator<> allocator;
1619  Value x(kArrayType);
1620  static const SizeType n = 200;
1621 
1622  for (SizeType i = 0; i < n; i++) {
1623  Value y(kArrayType);
1624  for (SizeType j = 0; j < n; j++) {
1625  Value number(static_cast<int>(i * n + j));
1626  y.PushBack(number, allocator);
1627  }
1628  x.PushBack(y, allocator);
1629  }
1630 
1631  for (SizeType i = 0; i < n; i++)
1632  for (SizeType j = 0; j < n; j++) {
1633  EXPECT_TRUE(x[i][j].IsInt());
1634  EXPECT_EQ(static_cast<int>(i * n + j), x[i][j].GetInt());
1635  }
1636 }
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
array
Definition: rapidjson.h:625
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922

◆ TEST() [26/31]

TEST ( Value  ,
BigNestedObject   
)

Definition at line 1638 of file valuetest.cpp.

1638  {
1639  MemoryPoolAllocator<> allocator;
1640  Value x(kObjectType);
1641  static const SizeType n = 200;
1642 
1643  for (SizeType i = 0; i < n; i++) {
1644  char name1[10];
1645  sprintf(name1, "%d", i);
1646 
1647  // Value name(name1); // should not compile
1648  Value name(name1, static_cast<SizeType>(strlen(name1)), allocator);
1649  Value object(kObjectType);
1650 
1651  for (SizeType j = 0; j < n; j++) {
1652  char name2[10];
1653  sprintf(name2, "%d", j);
1654 
1655  Value name3(name2, static_cast<SizeType>(strlen(name2)), allocator);
1656  Value number(static_cast<int>(i * n + j));
1657  object.AddMember(name3, number, allocator);
1658  }
1659 
1660  // x.AddMember(name1, object, allocator); // should not compile
1661  x.AddMember(name, object, allocator);
1662  }
1663 
1664  for (SizeType i = 0; i < n; i++) {
1665  char name1[10];
1666  sprintf(name1, "%d", i);
1667 
1668  for (SizeType j = 0; j < n; j++) {
1669  char name2[10];
1670  sprintf(name2, "%d", j);
1671  x[name1];
1672  EXPECT_EQ(static_cast<int>(i * n + j), x[name1][name2].GetInt());
1673  }
1674  }
1675 }
RAPIDJSON_NAMESPACE_BEGIN typedef unsigned SizeType
Size type (for string lengths, array sizes, etc.)
Definition: rapidjson.h:389
object
Definition: rapidjson.h:624
const char * name
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922

◆ TEST() [27/31]

TEST ( Value  ,
RemoveLastElement   
)

Definition at line 1679 of file valuetest.cpp.

1679  {
1680  rapidjson::Document doc;
1681  rapidjson::Document::AllocatorType& allocator = doc.GetAllocator();
1683  objVal.AddMember("var1", 123, allocator);
1684  objVal.AddMember("var2", "444", allocator);
1685  objVal.AddMember("var3", 555, allocator);
1686  EXPECT_TRUE(objVal.HasMember("var3"));
1687  objVal.RemoveMember("var3"); // Assertion here in r61
1688  EXPECT_FALSE(objVal.HasMember("var3"));
1689 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
object
Definition: rapidjson.h:624
GenericValue< UTF8<> > Value
GenericValue with UTF8 encoding.
Definition: document.h:2116
GenericDocument< UTF8<> > Document
GenericDocument with UTF8 encoding.
Definition: document.h:2512
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [28/31]

TEST ( Document  ,
CrtAllocator   
)

Definition at line 1692 of file valuetest.cpp.

1692  {
1693  typedef GenericValue<UTF8<>, CrtAllocator> V;
1694 
1695  V::AllocatorType allocator;
1696  V o(kObjectType);
1697  o.AddMember("x", 1, allocator); // Should not call destructor on uninitialized name/value of newly allocated members.
1698 
1699  V a(kArrayType);
1700  a.PushBack(1, allocator); // Should not call destructor on uninitialized Value of newly allocated elements.
1701 }
object
Definition: rapidjson.h:624
C-runtime library allocator.
Definition: allocators.h:75
array
Definition: rapidjson.h:625
Represents a JSON value. Use Value for UTF8 encoding and default allocator.
Definition: document.h:57
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124

◆ TEST() [29/31]

TEST ( Value  ,
AllocateShortString   
)

Definition at line 1714 of file valuetest.cpp.

1714  {
1715  TestShortStringOptimization(""); // edge case: empty string
1716  TestShortStringOptimization("12345678"); // regular case for short strings: 8 chars
1717  TestShortStringOptimization("12345678901"); // edge case: 11 chars in 32-bit mode (=> short string)
1718  TestShortStringOptimization("123456789012"); // edge case: 12 chars in 32-bit mode (=> regular string)
1719  TestShortStringOptimization("123456789012345"); // edge case: 15 chars in 64-bit mode (=> short string)
1720  TestShortStringOptimization("1234567890123456"); // edge case: 16 chars in 64-bit mode (=> regular string)
1721 }

◆ TEST() [30/31]

TEST ( Value  ,
AcceptTerminationByHandler   
)

Definition at line 1750 of file valuetest.cpp.

1750  {
1751  TEST_TERMINATION(0, "[null]");
1752  TEST_TERMINATION(1, "[true]");
1753  TEST_TERMINATION(1, "[false]");
1754  TEST_TERMINATION(2, "[-1]");
1755  TEST_TERMINATION(3, "[2147483648]");
1756  TEST_TERMINATION(4, "[-1234567890123456789]");
1757  TEST_TERMINATION(5, "[9223372036854775808]");
1758  TEST_TERMINATION(6, "[0.5]");
1759  // RawNumber() is never called
1760  TEST_TERMINATION(8, "[\"a\"]");
1761  TEST_TERMINATION(9, "[{}]");
1762  TEST_TERMINATION(10, "[{\"a\":1}]");
1763  TEST_TERMINATION(11, "[{}]");
1764  TEST_TERMINATION(12, "{\"a\":[]}");
1765  TEST_TERMINATION(13, "{\"a\":[]}");
1766 }
#define TEST_TERMINATION(e, json)
Definition: valuetest.cpp:1741

◆ TEST() [31/31]

TEST ( Value  ,
MergeDuplicateKey   
)

Definition at line 1819 of file valuetest.cpp.

1819  {
1820  Document d;
1821  d.Parse(
1822  "{"
1823  " \"key1\": {"
1824  " \"a\": \"asdf\","
1825  " \"b\": \"foo\","
1826  " \"b\": \"bar\","
1827  " \"c\": \"fdas\""
1828  " }"
1829  "}");
1830 
1831  Document d2;
1832  d2.Parse(
1833  "{"
1834  " \"key1\": {"
1835  " \"a\": \"asdf\","
1836  " \"b\": ["
1837  " \"foo\","
1838  " \"bar\""
1839  " ],"
1840  " \"c\": \"fdas\""
1841  " }"
1842  "}");
1843 
1844  EXPECT_NE(d2, d);
1845  MergeDuplicateKey(d, d.GetAllocator());
1846  EXPECT_EQ(d2, d);
1847 }
Allocator & GetAllocator()
Get the allocator of this document.
Definition: document.h:2418
#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
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922

◆ TestCopyFrom()

template<typename Value >
void TestCopyFrom ( )

Definition at line 250 of file valuetest.cpp.

250  {
251  typename Value::AllocatorType a;
252  Value v1(1234);
253  Value v2(v1, a); // deep copy constructor
254  EXPECT_TRUE(v1.GetType() == v2.GetType());
255  EXPECT_EQ(v1.GetInt(), v2.GetInt());
256 
257  v1.SetString("foo");
258  v2.CopyFrom(v1, a);
259  EXPECT_TRUE(v1.GetType() == v2.GetType());
260  EXPECT_STREQ(v1.GetString(), v2.GetString());
261  EXPECT_EQ(v1.GetString(), v2.GetString()); // string NOT copied
262 
263  v1.SetString("bar", a); // copy string
264  v2.CopyFrom(v1, a);
265  EXPECT_TRUE(v1.GetType() == v2.GetType());
266  EXPECT_STREQ(v1.GetString(), v2.GetString());
267  EXPECT_NE(v1.GetString(), v2.GetString()); // string copied
268 
269 
270  v1.SetArray().PushBack(1234, a);
271  v2.CopyFrom(v1, a);
272  EXPECT_TRUE(v2.IsArray());
273  EXPECT_EQ(v1.Size(), v2.Size());
274 
275  v1.PushBack(Value().SetString("foo", a), a); // push string copy
276  EXPECT_TRUE(v1.Size() != v2.Size());
277  v2.CopyFrom(v1, a);
278  EXPECT_TRUE(v1.Size() == v2.Size());
279  EXPECT_STREQ(v1[1].GetString(), v2[1].GetString());
280  EXPECT_NE(v1[1].GetString(), v2[1].GetString()); // string got copied
281 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
#define EXPECT_STREQ(s1, s2)
Definition: gtest.h:1995
GenericValue< UTF8<> > Value
GenericValue with UTF8 encoding.
Definition: document.h:2116
#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

◆ TestEqual()

template<typename A , typename B >
void TestEqual ( const A &  a,
const B &  b 
)

Definition at line 165 of file valuetest.cpp.

165  {
166  EXPECT_TRUE (a == b);
167  EXPECT_FALSE(a != b);
168  EXPECT_TRUE (b == a);
169  EXPECT_FALSE(b != a);
170 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862
Here is the caller graph for this function:

◆ TestUnequal()

template<typename A , typename B >
void TestUnequal ( const A &  a,
const B &  b 
)

Definition at line 173 of file valuetest.cpp.

173  {
174  EXPECT_FALSE(a == b);
175  EXPECT_TRUE (a != b);
176  EXPECT_FALSE(b == a);
177  EXPECT_TRUE (b != a);
178 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862
Here is the caller graph for this function: