| // Tencent is pleased to support the open source community by making RapidJSON available. |
| // |
| // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. |
| // |
| // Licensed under the MIT License (the "License"); you may not use this file except |
| // in compliance with the License. You may obtain a copy of the License at |
| // |
| // http://opensource.org/licenses/MIT |
| // |
| // Unless required by applicable law or agreed to in writing, software distributed |
| // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR |
| // CONDITIONS OF ANY KIND, either express or implied. See the License for the |
| // specific language governing permissions and limitations under the License. |
| |
| #include "unittest.h" |
| #include "rapidjson/document.h" |
| #include <algorithm> |
| |
| #ifdef __clang__ |
| RAPIDJSON_DIAG_PUSH |
| RAPIDJSON_DIAG_OFF(c++98-compat) |
| #endif |
| |
| using namespace rapidjson; |
| |
| TEST(Value, Size) { |
| if (sizeof(SizeType) == 4) { |
| #if RAPIDJSON_48BITPOINTER_OPTIMIZATION |
| EXPECT_EQ(16u, sizeof(Value)); |
| #elif RAPIDJSON_64BIT |
| EXPECT_EQ(24u, sizeof(Value)); |
| #else |
| EXPECT_EQ(16u, sizeof(Value)); |
| #endif |
| } |
| } |
| |
| TEST(Value, DefaultConstructor) { |
| Value x; |
| EXPECT_EQ(kNullType, x.GetType()); |
| EXPECT_TRUE(x.IsNull()); |
| |
| //std::cout << "sizeof(Value): " << sizeof(x) << std::endl; |
| } |
| |
| // Should not pass compilation |
| //TEST(Value, copy_constructor) { |
| // Value x(1234); |
| // Value y = x; |
| //} |
| |
| #if RAPIDJSON_HAS_CXX11_RVALUE_REFS |
| |
| #if 0 // Many old compiler does not support these. Turn it off temporaily. |
| |
| #include <type_traits> |
| |
| TEST(Value, Traits) { |
| typedef GenericValue<UTF8<>, CrtAllocator> Value; |
| static_assert(std::is_constructible<Value>::value, ""); |
| static_assert(std::is_default_constructible<Value>::value, ""); |
| #ifndef _MSC_VER |
| static_assert(!std::is_copy_constructible<Value>::value, ""); |
| #endif |
| static_assert(std::is_move_constructible<Value>::value, ""); |
| |
| #ifndef _MSC_VER |
| static_assert(std::is_nothrow_constructible<Value>::value, ""); |
| static_assert(std::is_nothrow_default_constructible<Value>::value, ""); |
| static_assert(!std::is_nothrow_copy_constructible<Value>::value, ""); |
| static_assert(std::is_nothrow_move_constructible<Value>::value, ""); |
| #endif |
| |
| static_assert(std::is_assignable<Value,Value>::value, ""); |
| #ifndef _MSC_VER |
| static_assert(!std::is_copy_assignable<Value>::value, ""); |
| #endif |
| static_assert(std::is_move_assignable<Value>::value, ""); |
| |
| #ifndef _MSC_VER |
| static_assert(std::is_nothrow_assignable<Value, Value>::value, ""); |
| #endif |
| static_assert(!std::is_nothrow_copy_assignable<Value>::value, ""); |
| #ifndef _MSC_VER |
| static_assert(std::is_nothrow_move_assignable<Value>::value, ""); |
| #endif |
| |
| static_assert(std::is_destructible<Value>::value, ""); |
| #ifndef _MSC_VER |
| static_assert(std::is_nothrow_destructible<Value>::value, ""); |
| #endif |
| } |
| |
| #endif |
| |
| TEST(Value, MoveConstructor) { |
| typedef GenericValue<UTF8<>, CrtAllocator> V; |
| V::AllocatorType allocator; |
| |
| V x((V(kArrayType))); |
| x.Reserve(4u, allocator); |
| x.PushBack(1, allocator).PushBack(2, allocator).PushBack(3, allocator).PushBack(4, allocator); |
| EXPECT_TRUE(x.IsArray()); |
| EXPECT_EQ(4u, x.Size()); |
| |
| // Value y(x); // does not compile (!is_copy_constructible) |
| V y(std::move(x)); |
| EXPECT_TRUE(x.IsNull()); |
| EXPECT_TRUE(y.IsArray()); |
| EXPECT_EQ(4u, y.Size()); |
| |
| // Value z = y; // does not compile (!is_copy_assignable) |
| V z = std::move(y); |
| EXPECT_TRUE(y.IsNull()); |
| EXPECT_TRUE(z.IsArray()); |
| EXPECT_EQ(4u, z.Size()); |
| } |
| |
| #endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS |
| |
| TEST(Value, AssignmentOperator) { |
| Value x(1234); |
| Value y; |
| y = x; |
| EXPECT_TRUE(x.IsNull()); // move semantic |
| EXPECT_EQ(1234, y.GetInt()); |
| |
| y = 5678; |
| EXPECT_TRUE(y.IsInt()); |
| EXPECT_EQ(5678, y.GetInt()); |
| |
| x = "Hello"; |
| EXPECT_TRUE(x.IsString()); |
| EXPECT_STREQ(x.GetString(),"Hello"); |
| |
| y = StringRef(x.GetString(),x.GetStringLength()); |
| EXPECT_TRUE(y.IsString()); |
| EXPECT_EQ(y.GetString(),x.GetString()); |
| EXPECT_EQ(y.GetStringLength(),x.GetStringLength()); |
| |
| static char mstr[] = "mutable"; |
| // y = mstr; // should not compile |
| y = StringRef(mstr); |
| EXPECT_TRUE(y.IsString()); |
| EXPECT_EQ(y.GetString(),mstr); |
| |
| #if RAPIDJSON_HAS_CXX11_RVALUE_REFS |
| // C++11 move assignment |
| x = Value("World"); |
| EXPECT_TRUE(x.IsString()); |
| EXPECT_STREQ("World", x.GetString()); |
| |
| x = std::move(y); |
| EXPECT_TRUE(y.IsNull()); |
| EXPECT_TRUE(x.IsString()); |
| EXPECT_EQ(x.GetString(), mstr); |
| |
| y = std::move(Value().SetInt(1234)); |
| EXPECT_TRUE(y.IsInt()); |
| EXPECT_EQ(1234, y); |
| #endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS |
| } |
| |
| template <typename A, typename B> |
| void TestEqual(const A& a, const B& b) { |
| EXPECT_TRUE (a == b); |
| EXPECT_FALSE(a != b); |
| EXPECT_TRUE (b == a); |
| EXPECT_FALSE(b != a); |
| } |
| |
| template <typename A, typename B> |
| void TestUnequal(const A& a, const B& b) { |
| EXPECT_FALSE(a == b); |
| EXPECT_TRUE (a != b); |
| EXPECT_FALSE(b == a); |
| EXPECT_TRUE (b != a); |
| } |
| |
| TEST(Value, EqualtoOperator) { |
| Value::AllocatorType allocator; |
| Value x(kObjectType); |
| x.AddMember("hello", "world", allocator) |
| .AddMember("t", Value(true).Move(), allocator) |
| .AddMember("f", Value(false).Move(), allocator) |
| .AddMember("n", Value(kNullType).Move(), allocator) |
| .AddMember("i", 123, allocator) |
| .AddMember("pi", 3.14, allocator) |
| .AddMember("a", Value(kArrayType).Move().PushBack(1, allocator).PushBack(2, allocator).PushBack(3, allocator), allocator); |
| |
| // Test templated operator==() and operator!=() |
| TestEqual(x["hello"], "world"); |
| const char* cc = "world"; |
| TestEqual(x["hello"], cc); |
| char* c = strdup("world"); |
| TestEqual(x["hello"], c); |
| free(c); |
| |
| TestEqual(x["t"], true); |
| TestEqual(x["f"], false); |
| TestEqual(x["i"], 123); |
| TestEqual(x["pi"], 3.14); |
| |
| // Test operator==() (including different allocators) |
| CrtAllocator crtAllocator; |
| GenericValue<UTF8<>, CrtAllocator> y; |
| GenericDocument<UTF8<>, CrtAllocator> z(&crtAllocator); |
| y.CopyFrom(x, crtAllocator); |
| z.CopyFrom(y, z.GetAllocator()); |
| TestEqual(x, y); |
| TestEqual(y, z); |
| TestEqual(z, x); |
| |
| // Swapping member order should be fine. |
| EXPECT_TRUE(y.RemoveMember("t")); |
| TestUnequal(x, y); |
| TestUnequal(z, y); |
| EXPECT_TRUE(z.RemoveMember("t")); |
| TestUnequal(x, z); |
| TestEqual(y, z); |
| y.AddMember("t", false, crtAllocator); |
| z.AddMember("t", false, z.GetAllocator()); |
| TestUnequal(x, y); |
| TestUnequal(z, x); |
| y["t"] = true; |
| z["t"] = true; |
| TestEqual(x, y); |
| TestEqual(y, z); |
| TestEqual(z, x); |
| |
| // Swapping element order is not OK |
| x["a"][0].Swap(x["a"][1]); |
| TestUnequal(x, y); |
| x["a"][0].Swap(x["a"][1]); |
| TestEqual(x, y); |
| |
| // Array of different size |
| x["a"].PushBack(4, allocator); |
| TestUnequal(x, y); |
| x["a"].PopBack(); |
| TestEqual(x, y); |
| |
| // Issue #129: compare Uint64 |
| x.SetUint64(RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0xFFFFFFF0)); |
| y.SetUint64(RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0xFFFFFFFF)); |
| TestUnequal(x, y); |
| } |
| |
| template <typename Value> |
| void TestCopyFrom() { |
| typename Value::AllocatorType a; |
| Value v1(1234); |
| Value v2(v1, a); // deep copy constructor |
| EXPECT_TRUE(v1.GetType() == v2.GetType()); |
| EXPECT_EQ(v1.GetInt(), v2.GetInt()); |
| |
| v1.SetString("foo"); |
| v2.CopyFrom(v1, a); |
| EXPECT_TRUE(v1.GetType() == v2.GetType()); |
| EXPECT_STREQ(v1.GetString(), v2.GetString()); |
| EXPECT_EQ(v1.GetString(), v2.GetString()); // string NOT copied |
| |
| v1.SetString("bar", a); // copy string |
| v2.CopyFrom(v1, a); |
| EXPECT_TRUE(v1.GetType() == v2.GetType()); |
| EXPECT_STREQ(v1.GetString(), v2.GetString()); |
| EXPECT_NE(v1.GetString(), v2.GetString()); // string copied |
| |
| |
| v1.SetArray().PushBack(1234, a); |
| v2.CopyFrom(v1, a); |
| EXPECT_TRUE(v2.IsArray()); |
| EXPECT_EQ(v1.Size(), v2.Size()); |
| |
| v1.PushBack(Value().SetString("foo", a), a); // push string copy |
| EXPECT_TRUE(v1.Size() != v2.Size()); |
| v2.CopyFrom(v1, a); |
| EXPECT_TRUE(v1.Size() == v2.Size()); |
| EXPECT_STREQ(v1[1].GetString(), v2[1].GetString()); |
| EXPECT_NE(v1[1].GetString(), v2[1].GetString()); // string got copied |
| } |
| |
| TEST(Value, CopyFrom) { |
| TestCopyFrom<Value>(); |
| TestCopyFrom<GenericValue<UTF8<>, CrtAllocator> >(); |
| } |
| |
| TEST(Value, Swap) { |
| Value v1(1234); |
| Value v2(kObjectType); |
| |
| EXPECT_EQ(&v1, &v1.Swap(v2)); |
| EXPECT_TRUE(v1.IsObject()); |
| EXPECT_TRUE(v2.IsInt()); |
| EXPECT_EQ(1234, v2.GetInt()); |
| |
| // testing std::swap compatibility |
| using std::swap; |
| swap(v1, v2); |
| EXPECT_TRUE(v1.IsInt()); |
| EXPECT_TRUE(v2.IsObject()); |
| } |
| |
| TEST(Value, Null) { |
| // Default constructor |
| Value x; |
| EXPECT_EQ(kNullType, x.GetType()); |
| EXPECT_TRUE(x.IsNull()); |
| |
| EXPECT_FALSE(x.IsTrue()); |
| EXPECT_FALSE(x.IsFalse()); |
| EXPECT_FALSE(x.IsNumber()); |
| EXPECT_FALSE(x.IsString()); |
| EXPECT_FALSE(x.IsObject()); |
| EXPECT_FALSE(x.IsArray()); |
| |
| // Constructor with type |
| Value y(kNullType); |
| EXPECT_TRUE(y.IsNull()); |
| |
| // SetNull(); |
| Value z(true); |
| z.SetNull(); |
| EXPECT_TRUE(z.IsNull()); |
| } |
| |
| TEST(Value, True) { |
| // Constructor with bool |
| Value x(true); |
| EXPECT_EQ(kTrueType, x.GetType()); |
| EXPECT_TRUE(x.GetBool()); |
| EXPECT_TRUE(x.IsBool()); |
| EXPECT_TRUE(x.IsTrue()); |
| |
| EXPECT_FALSE(x.IsNull()); |
| EXPECT_FALSE(x.IsFalse()); |
| EXPECT_FALSE(x.IsNumber()); |
| EXPECT_FALSE(x.IsString()); |
| EXPECT_FALSE(x.IsObject()); |
| EXPECT_FALSE(x.IsArray()); |
| |
| // Constructor with type |
| Value y(kTrueType); |
| EXPECT_TRUE(y.IsTrue()); |
| |
| // SetBool() |
| Value z; |
| z.SetBool(true); |
| EXPECT_TRUE(z.IsTrue()); |
| |
| // Templated functions |
| EXPECT_TRUE(z.Is<bool>()); |
| EXPECT_TRUE(z.Get<bool>()); |
| EXPECT_FALSE(z.Set<bool>(false).Get<bool>()); |
| EXPECT_TRUE(z.Set(true).Get<bool>()); |
| } |
| |
| TEST(Value, False) { |
| // Constructor with bool |
| Value x(false); |
| EXPECT_EQ(kFalseType, x.GetType()); |
| EXPECT_TRUE(x.IsBool()); |
| EXPECT_TRUE(x.IsFalse()); |
| |
| EXPECT_FALSE(x.IsNull()); |
| EXPECT_FALSE(x.IsTrue()); |
| EXPECT_FALSE(x.GetBool()); |
| //EXPECT_FALSE((bool)x); |
| EXPECT_FALSE(x.IsNumber()); |
| EXPECT_FALSE(x.IsString()); |
| EXPECT_FALSE(x.IsObject()); |
| EXPECT_FALSE(x.IsArray()); |
| |
| // Constructor with type |
| Value y(kFalseType); |
| EXPECT_TRUE(y.IsFalse()); |
| |
| // SetBool() |
| Value z; |
| z.SetBool(false); |
| EXPECT_TRUE(z.IsFalse()); |
| } |
| |
| TEST(Value, Int) { |
| // Constructor with int |
| Value x(1234); |
| EXPECT_EQ(kNumberType, x.GetType()); |
| EXPECT_EQ(1234, x.GetInt()); |
| EXPECT_EQ(1234u, x.GetUint()); |
| EXPECT_EQ(1234, x.GetInt64()); |
| EXPECT_EQ(1234u, x.GetUint64()); |
| EXPECT_NEAR(1234.0, x.GetDouble(), 0.0); |
| //EXPECT_EQ(1234, (int)x); |
| //EXPECT_EQ(1234, (unsigned)x); |
| //EXPECT_EQ(1234, (int64_t)x); |
| //EXPECT_EQ(1234, (uint64_t)x); |
| //EXPECT_EQ(1234, (double)x); |
| EXPECT_TRUE(x.IsNumber()); |
| EXPECT_TRUE(x.IsInt()); |
| EXPECT_TRUE(x.IsUint()); |
| EXPECT_TRUE(x.IsInt64()); |
| EXPECT_TRUE(x.IsUint64()); |
| |
| EXPECT_FALSE(x.IsDouble()); |
| EXPECT_FALSE(x.IsFloat()); |
| EXPECT_FALSE(x.IsNull()); |
| EXPECT_FALSE(x.IsBool()); |
| EXPECT_FALSE(x.IsFalse()); |
| EXPECT_FALSE(x.IsTrue()); |
| EXPECT_FALSE(x.IsString()); |
| EXPECT_FALSE(x.IsObject()); |
| EXPECT_FALSE(x.IsArray()); |
| |
| Value nx(-1234); |
| EXPECT_EQ(-1234, nx.GetInt()); |
| EXPECT_EQ(-1234, nx.GetInt64()); |
| EXPECT_TRUE(nx.IsInt()); |
| EXPECT_TRUE(nx.IsInt64()); |
| EXPECT_FALSE(nx.IsUint()); |
| EXPECT_FALSE(nx.IsUint64()); |
| |
| // Constructor with type |
| Value y(kNumberType); |
| EXPECT_TRUE(y.IsNumber()); |
| EXPECT_TRUE(y.IsInt()); |
| EXPECT_EQ(0, y.GetInt()); |
| |
| // SetInt() |
| Value z; |
| z.SetInt(1234); |
| EXPECT_EQ(1234, z.GetInt()); |
| |
| // operator=(int) |
| z = 5678; |
| EXPECT_EQ(5678, z.GetInt()); |
| |
| // Templated functions |
| EXPECT_TRUE(z.Is<int>()); |
| EXPECT_EQ(5678, z.Get<int>()); |
| EXPECT_EQ(5679, z.Set(5679).Get<int>()); |
| EXPECT_EQ(5680, z.Set<int>(5680).Get<int>()); |
| |
| #ifdef _MSC_VER |
| // long as int on MSC platforms |
| RAPIDJSON_STATIC_ASSERT(sizeof(long) == sizeof(int)); |
| z.SetInt(2222); |
| EXPECT_TRUE(z.Is<long>()); |
| EXPECT_EQ(2222l, z.Get<long>()); |
| EXPECT_EQ(3333l, z.Set(3333l).Get<long>()); |
| EXPECT_EQ(4444l, z.Set<long>(4444l).Get<long>()); |
| EXPECT_TRUE(z.IsInt()); |
| #endif |
| } |
| |
| TEST(Value, Uint) { |
| // Constructor with int |
| Value x(1234u); |
| EXPECT_EQ(kNumberType, x.GetType()); |
| EXPECT_EQ(1234, x.GetInt()); |
| EXPECT_EQ(1234u, x.GetUint()); |
| EXPECT_EQ(1234, x.GetInt64()); |
| EXPECT_EQ(1234u, x.GetUint64()); |
| EXPECT_TRUE(x.IsNumber()); |
| EXPECT_TRUE(x.IsInt()); |
| EXPECT_TRUE(x.IsUint()); |
| EXPECT_TRUE(x.IsInt64()); |
| EXPECT_TRUE(x.IsUint64()); |
| EXPECT_NEAR(1234.0, x.GetDouble(), 0.0); // Number can always be cast as double but !IsDouble(). |
| |
| EXPECT_FALSE(x.IsDouble()); |
| EXPECT_FALSE(x.IsFloat()); |
| EXPECT_FALSE(x.IsNull()); |
| EXPECT_FALSE(x.IsBool()); |
| EXPECT_FALSE(x.IsFalse()); |
| EXPECT_FALSE(x.IsTrue()); |
| EXPECT_FALSE(x.IsString()); |
| EXPECT_FALSE(x.IsObject()); |
| EXPECT_FALSE(x.IsArray()); |
| |
| // SetUint() |
| Value z; |
| z.SetUint(1234); |
| EXPECT_EQ(1234u, z.GetUint()); |
| |
| // operator=(unsigned) |
| z = 5678u; |
| EXPECT_EQ(5678u, z.GetUint()); |
| |
| z = 2147483648u; // 2^31, cannot cast as int |
| EXPECT_EQ(2147483648u, z.GetUint()); |
| EXPECT_FALSE(z.IsInt()); |
| EXPECT_TRUE(z.IsInt64()); // Issue 41: Incorrect parsing of unsigned int number types |
| |
| // Templated functions |
| EXPECT_TRUE(z.Is<unsigned>()); |
| EXPECT_EQ(2147483648u, z.Get<unsigned>()); |
| EXPECT_EQ(2147483649u, z.Set(2147483649u).Get<unsigned>()); |
| EXPECT_EQ(2147483650u, z.Set<unsigned>(2147483650u).Get<unsigned>()); |
| |
| #ifdef _MSC_VER |
| // unsigned long as unsigned on MSC platforms |
| RAPIDJSON_STATIC_ASSERT(sizeof(unsigned long) == sizeof(unsigned)); |
| z.SetUint(2222); |
| EXPECT_TRUE(z.Is<unsigned long>()); |
| EXPECT_EQ(2222ul, z.Get<unsigned long>()); |
| EXPECT_EQ(3333ul, z.Set(3333ul).Get<unsigned long>()); |
| EXPECT_EQ(4444ul, z.Set<unsigned long>(4444ul).Get<unsigned long>()); |
| EXPECT_TRUE(x.IsUint()); |
| #endif |
| } |
| |
| TEST(Value, Int64) { |
| // Constructor with int |
| Value x(int64_t(1234)); |
| EXPECT_EQ(kNumberType, x.GetType()); |
| EXPECT_EQ(1234, x.GetInt()); |
| EXPECT_EQ(1234u, x.GetUint()); |
| EXPECT_EQ(1234, x.GetInt64()); |
| EXPECT_EQ(1234u, x.GetUint64()); |
| EXPECT_TRUE(x.IsNumber()); |
| EXPECT_TRUE(x.IsInt()); |
| EXPECT_TRUE(x.IsUint()); |
| EXPECT_TRUE(x.IsInt64()); |
| EXPECT_TRUE(x.IsUint64()); |
| |
| EXPECT_FALSE(x.IsDouble()); |
| EXPECT_FALSE(x.IsFloat()); |
| EXPECT_FALSE(x.IsNull()); |
| EXPECT_FALSE(x.IsBool()); |
| EXPECT_FALSE(x.IsFalse()); |
| EXPECT_FALSE(x.IsTrue()); |
| EXPECT_FALSE(x.IsString()); |
| EXPECT_FALSE(x.IsObject()); |
| EXPECT_FALSE(x.IsArray()); |
| |
| Value nx(int64_t(-1234)); |
| EXPECT_EQ(-1234, nx.GetInt()); |
| EXPECT_EQ(-1234, nx.GetInt64()); |
| EXPECT_TRUE(nx.IsInt()); |
| EXPECT_TRUE(nx.IsInt64()); |
| EXPECT_FALSE(nx.IsUint()); |
| EXPECT_FALSE(nx.IsUint64()); |
| |
| // SetInt64() |
| Value z; |
| z.SetInt64(1234); |
| EXPECT_EQ(1234, z.GetInt64()); |
| |
| z.SetInt64(2147483648u); // 2^31, cannot cast as int |
| EXPECT_FALSE(z.IsInt()); |
| EXPECT_TRUE(z.IsUint()); |
| EXPECT_NEAR(2147483648.0, z.GetDouble(), 0.0); |
| |
| z.SetInt64(int64_t(4294967295u) + 1); // 2^32, cannot cast as uint |
| EXPECT_FALSE(z.IsInt()); |
| EXPECT_FALSE(z.IsUint()); |
| EXPECT_NEAR(4294967296.0, z.GetDouble(), 0.0); |
| |
| z.SetInt64(-int64_t(2147483648u) - 1); // -2^31-1, cannot cast as int |
| EXPECT_FALSE(z.IsInt()); |
| EXPECT_NEAR(-2147483649.0, z.GetDouble(), 0.0); |
| |
| int64_t i = static_cast<int64_t>(RAPIDJSON_UINT64_C2(0x80000000, 00000000)); |
| z.SetInt64(i); |
| EXPECT_DOUBLE_EQ(-9223372036854775808.0, z.GetDouble()); |
| |
| // Templated functions |
| EXPECT_TRUE(z.Is<int64_t>()); |
| EXPECT_EQ(i, z.Get<int64_t>()); |
| #if 0 // signed integer underflow is undefined behaviour |
| EXPECT_EQ(i - 1, z.Set(i - 1).Get<int64_t>()); |
| EXPECT_EQ(i - 2, z.Set<int64_t>(i - 2).Get<int64_t>()); |
| #endif |
| } |
| |
| TEST(Value, Uint64) { |
| // Constructor with int |
| Value x(uint64_t(1234)); |
| EXPECT_EQ(kNumberType, x.GetType()); |
| EXPECT_EQ(1234, x.GetInt()); |
| EXPECT_EQ(1234u, x.GetUint()); |
| EXPECT_EQ(1234, x.GetInt64()); |
| EXPECT_EQ(1234u, x.GetUint64()); |
| EXPECT_TRUE(x.IsNumber()); |
| EXPECT_TRUE(x.IsInt()); |
| EXPECT_TRUE(x.IsUint()); |
| EXPECT_TRUE(x.IsInt64()); |
| EXPECT_TRUE(x.IsUint64()); |
| |
| EXPECT_FALSE(x.IsDouble()); |
| EXPECT_FALSE(x.IsFloat()); |
| EXPECT_FALSE(x.IsNull()); |
| EXPECT_FALSE(x.IsBool()); |
| EXPECT_FALSE(x.IsFalse()); |
| EXPECT_FALSE(x.IsTrue()); |
| EXPECT_FALSE(x.IsString()); |
| EXPECT_FALSE(x.IsObject()); |
| EXPECT_FALSE(x.IsArray()); |
| |
| // SetUint64() |
| Value z; |
| z.SetUint64(1234); |
| EXPECT_EQ(1234u, z.GetUint64()); |
| |
| z.SetUint64(uint64_t(2147483648u)); // 2^31, cannot cast as int |
| EXPECT_FALSE(z.IsInt()); |
| EXPECT_TRUE(z.IsUint()); |
| EXPECT_TRUE(z.IsInt64()); |
| |
| z.SetUint64(uint64_t(4294967295u) + 1); // 2^32, cannot cast as uint |
| EXPECT_FALSE(z.IsInt()); |
| EXPECT_FALSE(z.IsUint()); |
| EXPECT_TRUE(z.IsInt64()); |
| |
| uint64_t u = RAPIDJSON_UINT64_C2(0x80000000, 0x00000000); |
| z.SetUint64(u); // 2^63 cannot cast as int64 |
| EXPECT_FALSE(z.IsInt64()); |
| EXPECT_EQ(u, z.GetUint64()); // Issue 48 |
| EXPECT_DOUBLE_EQ(9223372036854775808.0, z.GetDouble()); |
| |
| // Templated functions |
| EXPECT_TRUE(z.Is<uint64_t>()); |
| EXPECT_EQ(u, z.Get<uint64_t>()); |
| EXPECT_EQ(u + 1, z.Set(u + 1).Get<uint64_t>()); |
| EXPECT_EQ(u + 2, z.Set<uint64_t>(u + 2).Get<uint64_t>()); |
| } |
| |
| TEST(Value, Double) { |
| // Constructor with double |
| Value x(12.34); |
| EXPECT_EQ(kNumberType, x.GetType()); |
| EXPECT_NEAR(12.34, x.GetDouble(), 0.0); |
| EXPECT_TRUE(x.IsNumber()); |
| EXPECT_TRUE(x.IsDouble()); |
| |
| EXPECT_FALSE(x.IsInt()); |
| EXPECT_FALSE(x.IsNull()); |
| EXPECT_FALSE(x.IsBool()); |
| EXPECT_FALSE(x.IsFalse()); |
| EXPECT_FALSE(x.IsTrue()); |
| EXPECT_FALSE(x.IsString()); |
| EXPECT_FALSE(x.IsObject()); |
| EXPECT_FALSE(x.IsArray()); |
| |
| // SetDouble() |
| Value z; |
| z.SetDouble(12.34); |
| EXPECT_NEAR(12.34, z.GetDouble(), 0.0); |
| |
| z = 56.78; |
| EXPECT_NEAR(56.78, z.GetDouble(), 0.0); |
| |
| // Templated functions |
| EXPECT_TRUE(z.Is<double>()); |
| EXPECT_EQ(56.78, z.Get<double>()); |
| EXPECT_EQ(57.78, z.Set(57.78).Get<double>()); |
| EXPECT_EQ(58.78, z.Set<double>(58.78).Get<double>()); |
| } |
| |
| TEST(Value, Float) { |
| // Constructor with double |
| Value x(12.34f); |
| EXPECT_EQ(kNumberType, x.GetType()); |
| EXPECT_NEAR(12.34f, x.GetFloat(), 0.0); |
| EXPECT_TRUE(x.IsNumber()); |
| EXPECT_TRUE(x.IsDouble()); |
| EXPECT_TRUE(x.IsFloat()); |
| |
| EXPECT_FALSE(x.IsInt()); |
| EXPECT_FALSE(x.IsNull()); |
| EXPECT_FALSE(x.IsBool()); |
| EXPECT_FALSE(x.IsFalse()); |
| EXPECT_FALSE(x.IsTrue()); |
| EXPECT_FALSE(x.IsString()); |
| EXPECT_FALSE(x.IsObject()); |
| EXPECT_FALSE(x.IsArray()); |
| |
| // SetFloat() |
| Value z; |
| z.SetFloat(12.34f); |
| EXPECT_NEAR(12.34f, z.GetFloat(), 0.0f); |
| |
| // Issue 573 |
| z.SetInt(0); |
| EXPECT_EQ(0.0f, z.GetFloat()); |
| |
| z = 56.78f; |
| EXPECT_NEAR(56.78f, z.GetFloat(), 0.0f); |
| |
| // Templated functions |
| EXPECT_TRUE(z.Is<float>()); |
| EXPECT_EQ(56.78f, z.Get<float>()); |
| EXPECT_EQ(57.78f, z.Set(57.78f).Get<float>()); |
| EXPECT_EQ(58.78f, z.Set<float>(58.78f).Get<float>()); |
| } |
| |
| TEST(Value, IsLosslessDouble) { |
| EXPECT_TRUE(Value(0.0).IsLosslessDouble()); |
| EXPECT_TRUE(Value(12.34).IsLosslessDouble()); |
| EXPECT_TRUE(Value(-123).IsLosslessDouble()); |
| EXPECT_TRUE(Value(2147483648u).IsLosslessDouble()); |
| EXPECT_TRUE(Value(-static_cast<int64_t>(RAPIDJSON_UINT64_C2(0x40000000, 0x00000000))).IsLosslessDouble()); |
| #if !(defined(_MSC_VER) && _MSC_VER < 1800) // VC2010 has problem |
| EXPECT_TRUE(Value(RAPIDJSON_UINT64_C2(0xA0000000, 0x00000000)).IsLosslessDouble()); |
| #endif |
| |
| EXPECT_FALSE(Value(static_cast<int64_t>(RAPIDJSON_UINT64_C2(0x7FFFFFFF, 0xFFFFFFFF))).IsLosslessDouble()); // INT64_MAX |
| EXPECT_FALSE(Value(-static_cast<int64_t>(RAPIDJSON_UINT64_C2(0x7FFFFFFF, 0xFFFFFFFF))).IsLosslessDouble()); // -INT64_MAX |
| EXPECT_TRUE(Value(-static_cast<int64_t>(RAPIDJSON_UINT64_C2(0x7FFFFFFF, 0xFFFFFFFF)) - 1).IsLosslessDouble()); // INT64_MIN |
| EXPECT_FALSE(Value(RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0xFFFFFFFF)).IsLosslessDouble()); // UINT64_MAX |
| |
| EXPECT_TRUE(Value(3.4028234e38f).IsLosslessDouble()); // FLT_MAX |
| EXPECT_TRUE(Value(-3.4028234e38f).IsLosslessDouble()); // -FLT_MAX |
| EXPECT_TRUE(Value(1.17549435e-38f).IsLosslessDouble()); // FLT_MIN |
| EXPECT_TRUE(Value(-1.17549435e-38f).IsLosslessDouble()); // -FLT_MIN |
| EXPECT_TRUE(Value(1.7976931348623157e+308).IsLosslessDouble()); // DBL_MAX |
| EXPECT_TRUE(Value(-1.7976931348623157e+308).IsLosslessDouble()); // -DBL_MAX |
| EXPECT_TRUE(Value(2.2250738585072014e-308).IsLosslessDouble()); // DBL_MIN |
| EXPECT_TRUE(Value(-2.2250738585072014e-308).IsLosslessDouble()); // -DBL_MIN |
| } |
| |
| TEST(Value, IsLosslessFloat) { |
| EXPECT_TRUE(Value(12.25).IsLosslessFloat()); |
| EXPECT_TRUE(Value(-123).IsLosslessFloat()); |
| EXPECT_TRUE(Value(2147483648u).IsLosslessFloat()); |
| EXPECT_TRUE(Value(3.4028234e38f).IsLosslessFloat()); |
| EXPECT_TRUE(Value(-3.4028234e38f).IsLosslessFloat()); |
| EXPECT_FALSE(Value(3.4028235e38).IsLosslessFloat()); |
| EXPECT_FALSE(Value(0.3).IsLosslessFloat()); |
| } |
| |
| TEST(Value, String) { |
| // Construction with const string |
| Value x("Hello", 5); // literal |
| EXPECT_EQ(kStringType, x.GetType()); |
| EXPECT_TRUE(x.IsString()); |
| EXPECT_STREQ("Hello", x.GetString()); |
| EXPECT_EQ(5u, x.GetStringLength()); |
| |
| EXPECT_FALSE(x.IsNumber()); |
| EXPECT_FALSE(x.IsNull()); |
| EXPECT_FALSE(x.IsBool()); |
| EXPECT_FALSE(x.IsFalse()); |
| EXPECT_FALSE(x.IsTrue()); |
| EXPECT_FALSE(x.IsObject()); |
| EXPECT_FALSE(x.IsArray()); |
| |
| static const char cstr[] = "World"; // const array |
| Value(cstr).Swap(x); |
| EXPECT_TRUE(x.IsString()); |
| EXPECT_EQ(x.GetString(), cstr); |
| EXPECT_EQ(x.GetStringLength(), sizeof(cstr)-1); |
| |
| static char mstr[] = "Howdy"; // non-const array |
| // Value(mstr).Swap(x); // should not compile |
| Value(StringRef(mstr)).Swap(x); |
| EXPECT_TRUE(x.IsString()); |
| EXPECT_EQ(x.GetString(), mstr); |
| EXPECT_EQ(x.GetStringLength(), sizeof(mstr)-1); |
| strncpy(mstr,"Hello", sizeof(mstr)); |
| EXPECT_STREQ(x.GetString(), "Hello"); |
| |
| const char* pstr = cstr; |
| //Value(pstr).Swap(x); // should not compile |
| Value(StringRef(pstr)).Swap(x); |
| EXPECT_TRUE(x.IsString()); |
| EXPECT_EQ(x.GetString(), cstr); |
| EXPECT_EQ(x.GetStringLength(), sizeof(cstr)-1); |
| |
| char* mpstr = mstr; |
| Value(StringRef(mpstr,sizeof(mstr)-1)).Swap(x); |
| EXPECT_TRUE(x.IsString()); |
| EXPECT_EQ(x.GetString(), mstr); |
| EXPECT_EQ(x.GetStringLength(), 5u); |
| EXPECT_STREQ(x.GetString(), "Hello"); |
| |
| // Constructor with copy string |
| MemoryPoolAllocator<> allocator; |
| Value c(x.GetString(), x.GetStringLength(), allocator); |
| EXPECT_NE(x.GetString(), c.GetString()); |
| EXPECT_EQ(x.GetStringLength(), c.GetStringLength()); |
| EXPECT_STREQ(x.GetString(), c.GetString()); |
| //x.SetString("World"); |
| x.SetString("World", 5); |
| EXPECT_STREQ("Hello", c.GetString()); |
| EXPECT_EQ(5u, c.GetStringLength()); |
| |
| // Constructor with type |
| Value y(kStringType); |
| EXPECT_TRUE(y.IsString()); |
| EXPECT_STREQ("", y.GetString()); // Empty string should be "" instead of 0 (issue 226) |
| EXPECT_EQ(0u, y.GetStringLength()); |
| |
| // SetConsttring() |
| Value z; |
| z.SetString("Hello"); |
| EXPECT_TRUE(x.IsString()); |
| z.SetString("Hello", 5); |
| EXPECT_STREQ("Hello", z.GetString()); |
| EXPECT_STREQ("Hello", z.GetString()); |
| EXPECT_EQ(5u, z.GetStringLength()); |
| |
| z.SetString("Hello"); |
| EXPECT_TRUE(z.IsString()); |
| EXPECT_STREQ("Hello", z.GetString()); |
| |
| //z.SetString(mstr); // should not compile |
| //z.SetString(pstr); // should not compile |
| z.SetString(StringRef(mstr)); |
| EXPECT_TRUE(z.IsString()); |
| EXPECT_STREQ(z.GetString(), mstr); |
| |
| z.SetString(cstr); |
| EXPECT_TRUE(z.IsString()); |
| EXPECT_EQ(cstr, z.GetString()); |
| |
| z = cstr; |
| EXPECT_TRUE(z.IsString()); |
| EXPECT_EQ(cstr, z.GetString()); |
| |
| // SetString() |
| char s[] = "World"; |
| Value w; |
| w.SetString(s, static_cast<SizeType>(strlen(s)), allocator); |
| s[0] = '\0'; |
| EXPECT_STREQ("World", w.GetString()); |
| EXPECT_EQ(5u, w.GetStringLength()); |
| |
| // templated functions |
| EXPECT_TRUE(z.Is<const char*>()); |
| EXPECT_STREQ(cstr, z.Get<const char*>()); |
| EXPECT_STREQ("Apple", z.Set<const char*>("Apple").Get<const char*>()); |
| |
| #if RAPIDJSON_HAS_STDSTRING |
| { |
| std::string str = "Hello World"; |
| str[5] = '\0'; |
| EXPECT_STREQ(str.data(),"Hello"); // embedded '\0' |
| EXPECT_EQ(str.size(), 11u); |
| |
| // no copy |
| Value vs0(StringRef(str)); |
| EXPECT_TRUE(vs0.IsString()); |
| EXPECT_EQ(vs0.GetString(), str.data()); |
| EXPECT_EQ(vs0.GetStringLength(), str.size()); |
| TestEqual(vs0, str); |
| |
| // do copy |
| Value vs1(str, allocator); |
| EXPECT_TRUE(vs1.IsString()); |
| EXPECT_NE(vs1.GetString(), str.data()); |
| EXPECT_NE(vs1.GetString(), str); // not equal due to embedded '\0' |
| EXPECT_EQ(vs1.GetStringLength(), str.size()); |
| TestEqual(vs1, str); |
| |
| // SetString |
| str = "World"; |
| vs0.SetNull().SetString(str, allocator); |
| EXPECT_TRUE(vs0.IsString()); |
| EXPECT_STREQ(vs0.GetString(), str.c_str()); |
| EXPECT_EQ(vs0.GetStringLength(), str.size()); |
| TestEqual(str, vs0); |
| TestUnequal(str, vs1); |
| |
| // vs1 = str; // should not compile |
| vs1 = StringRef(str); |
| TestEqual(str, vs1); |
| TestEqual(vs0, vs1); |
| |
| // Templated function. |
| EXPECT_TRUE(vs0.Is<std::string>()); |
| EXPECT_EQ(str, vs0.Get<std::string>()); |
| vs0.Set<std::string>(std::string("Apple"), allocator); |
| EXPECT_EQ(std::string("Apple"), vs0.Get<std::string>()); |
| vs0.Set(std::string("Orange"), allocator); |
| EXPECT_EQ(std::string("Orange"), vs0.Get<std::string>()); |
| } |
| #endif // RAPIDJSON_HAS_STDSTRING |
| } |
| |
| // Issue 226: Value of string type should not point to NULL |
| TEST(Value, SetStringNull) { |
| |
| MemoryPoolAllocator<> allocator; |
| const char* nullPtr = 0; |
| { |
| // Construction with string type creates empty string |
| Value v(kStringType); |
| EXPECT_NE(v.GetString(), nullPtr); // non-null string returned |
| EXPECT_EQ(v.GetStringLength(), 0u); |
| |
| // Construction from/setting to null without length not allowed |
| EXPECT_THROW(Value(StringRef(nullPtr)), AssertException); |
| EXPECT_THROW(Value(StringRef(nullPtr), allocator), AssertException); |
| EXPECT_THROW(v.SetString(nullPtr, allocator), AssertException); |
| |
| // Non-empty length with null string is not allowed |
| EXPECT_THROW(v.SetString(nullPtr, 17u), AssertException); |
| EXPECT_THROW(v.SetString(nullPtr, 42u, allocator), AssertException); |
| |
| // Setting to null string with empty length is allowed |
| v.SetString(nullPtr, 0u); |
| EXPECT_NE(v.GetString(), nullPtr); // non-null string returned |
| EXPECT_EQ(v.GetStringLength(), 0u); |
| |
| v.SetNull(); |
| v.SetString(nullPtr, 0u, allocator); |
| EXPECT_NE(v.GetString(), nullPtr); // non-null string returned |
| EXPECT_EQ(v.GetStringLength(), 0u); |
| } |
| // Construction with null string and empty length is allowed |
| { |
| Value v(nullPtr,0u); |
| EXPECT_NE(v.GetString(), nullPtr); // non-null string returned |
| EXPECT_EQ(v.GetStringLength(), 0u); |
| } |
| { |
| Value v(nullPtr, 0u, allocator); |
| EXPECT_NE(v.GetString(), nullPtr); // non-null string returned |
| EXPECT_EQ(v.GetStringLength(), 0u); |
| } |
| } |
| |
| template <typename T, typename Allocator> |
| static void TestArray(T& x, Allocator& allocator) { |
| const T& y = x; |
| |
| // PushBack() |
| Value v; |
| x.PushBack(v, allocator); |
| v.SetBool(true); |
| x.PushBack(v, allocator); |
| v.SetBool(false); |
| x.PushBack(v, allocator); |
| v.SetInt(123); |
| x.PushBack(v, allocator); |
| //x.PushBack((const char*)"foo", allocator); // should not compile |
| x.PushBack("foo", allocator); |
| |
| EXPECT_FALSE(x.Empty()); |
| EXPECT_EQ(5u, x.Size()); |
| EXPECT_FALSE(y.Empty()); |
| EXPECT_EQ(5u, y.Size()); |
| EXPECT_TRUE(x[SizeType(0)].IsNull()); |
| EXPECT_TRUE(x[1].IsTrue()); |
| EXPECT_TRUE(x[2].IsFalse()); |
| EXPECT_TRUE(x[3].IsInt()); |
| EXPECT_EQ(123, x[3].GetInt()); |
| EXPECT_TRUE(y[SizeType(0)].IsNull()); |
| EXPECT_TRUE(y[1].IsTrue()); |
| EXPECT_TRUE(y[2].IsFalse()); |
| EXPECT_TRUE(y[3].IsInt()); |
| EXPECT_EQ(123, y[3].GetInt()); |
| EXPECT_TRUE(y[4].IsString()); |
| EXPECT_STREQ("foo", y[4].GetString()); |
| |
| #if RAPIDJSON_HAS_CXX11_RVALUE_REFS |
| // PushBack(GenericValue&&, Allocator&); |
| { |
| Value y2(kArrayType); |
| y2.PushBack(Value(true), allocator); |
| y2.PushBack(std::move(Value(kArrayType).PushBack(Value(1), allocator).PushBack("foo", allocator)), allocator); |
| EXPECT_EQ(2u, y2.Size()); |
| EXPECT_TRUE(y2[0].IsTrue()); |
| EXPECT_TRUE(y2[1].IsArray()); |
| EXPECT_EQ(2u, y2[1].Size()); |
| EXPECT_TRUE(y2[1][0].IsInt()); |
| EXPECT_TRUE(y2[1][1].IsString()); |
| } |
| #endif |
| |
| // iterator |
| typename T::ValueIterator itr = x.Begin(); |
| EXPECT_TRUE(itr != x.End()); |
| EXPECT_TRUE(itr->IsNull()); |
| ++itr; |
| EXPECT_TRUE(itr != x.End()); |
| EXPECT_TRUE(itr->IsTrue()); |
| ++itr; |
| EXPECT_TRUE(itr != x.End()); |
| EXPECT_TRUE(itr->IsFalse()); |
| ++itr; |
| EXPECT_TRUE(itr != x.End()); |
| EXPECT_TRUE(itr->IsInt()); |
| EXPECT_EQ(123, itr->GetInt()); |
| ++itr; |
| EXPECT_TRUE(itr != x.End()); |
| EXPECT_TRUE(itr->IsString()); |
| EXPECT_STREQ("foo", itr->GetString()); |
| |
| // const iterator |
| typename T::ConstValueIterator citr = y.Begin(); |
| EXPECT_TRUE(citr != y.End()); |
| EXPECT_TRUE(citr->IsNull()); |
| ++citr; |
| EXPECT_TRUE(citr != y.End()); |
| EXPECT_TRUE(citr->IsTrue()); |
| ++citr; |
| EXPECT_TRUE(citr != y.End()); |
| EXPECT_TRUE(citr->IsFalse()); |
| ++citr; |
| EXPECT_TRUE(citr != y.End()); |
| EXPECT_TRUE(citr->IsInt()); |
| EXPECT_EQ(123, citr->GetInt()); |
| ++citr; |
| EXPECT_TRUE(citr != y.End()); |
| EXPECT_TRUE(citr->IsString()); |
| EXPECT_STREQ("foo", citr->GetString()); |
| |
| // PopBack() |
| x.PopBack(); |
| EXPECT_EQ(4u, x.Size()); |
| EXPECT_TRUE(y[SizeType(0)].IsNull()); |
| EXPECT_TRUE(y[1].IsTrue()); |
| EXPECT_TRUE(y[2].IsFalse()); |
| EXPECT_TRUE(y[3].IsInt()); |
| |
| // Clear() |
| x.Clear(); |
| EXPECT_TRUE(x.Empty()); |
| EXPECT_EQ(0u, x.Size()); |
| EXPECT_TRUE(y.Empty()); |
| EXPECT_EQ(0u, y.Size()); |
| |
| // Erase(ValueIterator) |
| |
| // Use array of array to ensure removed elements' destructor is called. |
| // [[0],[1],[2],...] |
| for (int i = 0; i < 10; i++) |
| x.PushBack(Value(kArrayType).PushBack(i, allocator).Move(), allocator); |
| |
| // Erase the first |
| itr = x.Erase(x.Begin()); |
| EXPECT_EQ(x.Begin(), itr); |
| EXPECT_EQ(9u, x.Size()); |
| for (int i = 0; i < 9; i++) |
| EXPECT_EQ(i + 1, x[static_cast<SizeType>(i)][0].GetInt()); |
| |
| // Ease the last |
| itr = x.Erase(x.End() - 1); |
| EXPECT_EQ(x.End(), itr); |
| EXPECT_EQ(8u, x.Size()); |
| for (int i = 0; i < 8; i++) |
| EXPECT_EQ(i + 1, x[static_cast<SizeType>(i)][0].GetInt()); |
| |
| // Erase the middle |
| itr = x.Erase(x.Begin() + 4); |
| EXPECT_EQ(x.Begin() + 4, itr); |
| EXPECT_EQ(7u, x.Size()); |
| for (int i = 0; i < 4; i++) |
| EXPECT_EQ(i + 1, x[static_cast<SizeType>(i)][0].GetInt()); |
| for (int i = 4; i < 7; i++) |
| EXPECT_EQ(i + 2, x[static_cast<SizeType>(i)][0].GetInt()); |
| |
| // Erase(ValueIterator, ValueIterator) |
| // Exhaustive test with all 0 <= first < n, first <= last <= n cases |
| const unsigned n = 10; |
| for (unsigned first = 0; first < n; first++) { |
| for (unsigned last = first; last <= n; last++) { |
| x.Clear(); |
| for (unsigned i = 0; i < n; i++) |
| x.PushBack(Value(kArrayType).PushBack(i, allocator).Move(), allocator); |
| |
| itr = x.Erase(x.Begin() + first, x.Begin() + last); |
| if (last == n) |
| EXPECT_EQ(x.End(), itr); |
| else |
| EXPECT_EQ(x.Begin() + first, itr); |
| |
| size_t removeCount = last - first; |
| EXPECT_EQ(n - removeCount, x.Size()); |
| for (unsigned i = 0; i < first; i++) |
| EXPECT_EQ(i, x[i][0].GetUint()); |
| for (unsigned i = first; i < n - removeCount; i++) |
| EXPECT_EQ(i + removeCount, x[static_cast<SizeType>(i)][0].GetUint()); |
| } |
| } |
| } |
| |
| TEST(Value, Array) { |
| Value::AllocatorType allocator; |
| Value x(kArrayType); |
| const Value& y = x; |
| |
| EXPECT_EQ(kArrayType, x.GetType()); |
| EXPECT_TRUE(x.IsArray()); |
| EXPECT_TRUE(x.Empty()); |
| EXPECT_EQ(0u, x.Size()); |
| EXPECT_TRUE(y.IsArray()); |
| EXPECT_TRUE(y.Empty()); |
| EXPECT_EQ(0u, y.Size()); |
| |
| EXPECT_FALSE(x.IsNull()); |
| EXPECT_FALSE(x.IsBool()); |
| EXPECT_FALSE(x.IsFalse()); |
| EXPECT_FALSE(x.IsTrue()); |
| EXPECT_FALSE(x.IsString()); |
| EXPECT_FALSE(x.IsObject()); |
| |
| TestArray(x, allocator); |
| |
| // Working in gcc without C++11, but VS2013 cannot compile. To be diagnosed. |
| // http://en.wikipedia.org/wiki/Erase-remove_idiom |
| x.Clear(); |
| for (int i = 0; i < 10; i++) |
| if (i % 2 == 0) |
| x.PushBack(i, allocator); |
| else |
| x.PushBack(Value(kNullType).Move(), allocator); |
| |
| const Value null(kNullType); |
| x.Erase(std::remove(x.Begin(), x.End(), null), x.End()); |
| EXPECT_EQ(5u, x.Size()); |
| for (int i = 0; i < 5; i++) |
| EXPECT_EQ(i * 2, x[static_cast<SizeType>(i)]); |
| |
| // SetArray() |
| Value z; |
| z.SetArray(); |
| EXPECT_TRUE(z.IsArray()); |
| EXPECT_TRUE(z.Empty()); |
| |
| // PR #1503: assign from inner Value |
| { |
| CrtAllocator a; // Free() is not a noop |
| GenericValue<UTF8<>, CrtAllocator> nullValue; |
| GenericValue<UTF8<>, CrtAllocator> arrayValue(kArrayType); |
| arrayValue.PushBack(nullValue, a); |
| arrayValue = arrayValue[0]; // shouldn't crash (use after free) |
| EXPECT_TRUE(arrayValue.IsNull()); |
| } |
| } |
| |
| TEST(Value, ArrayHelper) { |
| Value::AllocatorType allocator; |
| { |
| Value x(kArrayType); |
| Value::Array a = x.GetArray(); |
| TestArray(a, allocator); |
| } |
| |
| { |
| Value x(kArrayType); |
| Value::Array a = x.GetArray(); |
| a.PushBack(1, allocator); |
| |
| Value::Array a2(a); // copy constructor |
| EXPECT_EQ(1u, a2.Size()); |
| |
| Value::Array a3 = a; |
| EXPECT_EQ(1u, a3.Size()); |
| |
| Value::ConstArray y = static_cast<const Value&>(x).GetArray(); |
| (void)y; |
| // y.PushBack(1, allocator); // should not compile |
| |
| // Templated functions |
| x.Clear(); |
| EXPECT_TRUE(x.Is<Value::Array>()); |
| EXPECT_TRUE(x.Is<Value::ConstArray>()); |
| a.PushBack(1, allocator); |
| EXPECT_EQ(1, x.Get<Value::Array>()[0].GetInt()); |
| EXPECT_EQ(1, x.Get<Value::ConstArray>()[0].GetInt()); |
| |
| Value x2; |
| x2.Set<Value::Array>(a); |
| EXPECT_TRUE(x.IsArray()); // IsArray() is invariant after moving. |
| EXPECT_EQ(1, x2.Get<Value::Array>()[0].GetInt()); |
| } |
| |
| { |
| Value y(kArrayType); |
| y.PushBack(123, allocator); |
| |
| Value x(y.GetArray()); // Construct value form array. |
| EXPECT_TRUE(x.IsArray()); |
| EXPECT_EQ(123, x[0].GetInt()); |
| EXPECT_TRUE(y.IsArray()); // Invariant |
| EXPECT_TRUE(y.Empty()); |
| } |
| |
| { |
| Value x(kArrayType); |
| Value y(kArrayType); |
| y.PushBack(123, allocator); |
| x.PushBack(y.GetArray(), allocator); // Implicit constructor to convert Array to GenericValue |
| |
| EXPECT_EQ(1u, x.Size()); |
| EXPECT_EQ(123, x[0][0].GetInt()); |
| EXPECT_TRUE(y.IsArray()); |
| EXPECT_TRUE(y.Empty()); |
| } |
| } |
| |
| #if RAPIDJSON_HAS_CXX11_RANGE_FOR |
| TEST(Value, ArrayHelperRangeFor) { |
| Value::AllocatorType allocator; |
| Value x(kArrayType); |
| |
| for (int i = 0; i < 10; i++) |
| x.PushBack(i, allocator); |
| |
| { |
| int i = 0; |
| for (auto& v : x.GetArray()) { |
| EXPECT_EQ(i, v.GetInt()); |
| i++; |
| } |
| EXPECT_EQ(i, 10); |
| } |
| { |
| int i = 0; |
| for (const auto& v : const_cast<const Value&>(x).GetArray()) { |
| EXPECT_EQ(i, v.GetInt()); |
| i++; |
| } |
| EXPECT_EQ(i, 10); |
| } |
| |
| // Array a = x.GetArray(); |
| // Array ca = const_cast<const Value&>(x).GetArray(); |
| } |
| #endif |
| |
| template <typename T, typename Allocator> |
| static void TestObject(T& x, Allocator& allocator) { |
| const T& y = x; // const version |
| |
| // AddMember() |
| x.AddMember("A", "Apple", allocator); |
| EXPECT_FALSE(x.ObjectEmpty()); |
| EXPECT_EQ(1u, x.MemberCount()); |
| |
| Value value("Banana", 6); |
| x.AddMember("B", "Banana", allocator); |
| EXPECT_EQ(2u, x.MemberCount()); |
| |
| // AddMember<T>(StringRefType, T, Allocator) |
| { |
| Value o(kObjectType); |
| o.AddMember("true", true, allocator); |
| o.AddMember("false", false, allocator); |
| o.AddMember("int", -1, allocator); |
| o.AddMember("uint", 1u, allocator); |
| o.AddMember("int64", int64_t(-4294967296), allocator); |
| o.AddMember("uint64", uint64_t(4294967296), allocator); |
| o.AddMember("double", 3.14, allocator); |
| o.AddMember("string", "Jelly", allocator); |
| |
| EXPECT_TRUE(o["true"].GetBool()); |
| EXPECT_FALSE(o["false"].GetBool()); |
| EXPECT_EQ(-1, o["int"].GetInt()); |
| EXPECT_EQ(1u, o["uint"].GetUint()); |
| EXPECT_EQ(int64_t(-4294967296), o["int64"].GetInt64()); |
| EXPECT_EQ(uint64_t(4294967296), o["uint64"].GetUint64()); |
| EXPECT_STREQ("Jelly",o["string"].GetString()); |
| EXPECT_EQ(8u, o.MemberCount()); |
| } |
| |
| // AddMember<T>(Value&, T, Allocator) |
| { |
| Value o(kObjectType); |
| |
| Value n("s"); |
| o.AddMember(n, "string", allocator); |
| EXPECT_EQ(1u, o.MemberCount()); |
| |
| Value count("#"); |
| o.AddMember(count, o.MemberCount(), allocator); |
| EXPECT_EQ(2u, o.MemberCount()); |
| } |
| |
| #if RAPIDJSON_HAS_STDSTRING |
| { |
| // AddMember(StringRefType, const std::string&, Allocator) |
| Value o(kObjectType); |
| o.AddMember("b", std::string("Banana"), allocator); |
| EXPECT_STREQ("Banana", o["b"].GetString()); |
| |
| // RemoveMember(const std::string&) |
| o.RemoveMember(std::string("b")); |
| EXPECT_TRUE(o.ObjectEmpty()); |
| } |
| #endif |
| |
| #if RAPIDJSON_HAS_CXX11_RVALUE_REFS |
| // AddMember(GenericValue&&, ...) variants |
| { |
| Value o(kObjectType); |
| o.AddMember(Value("true"), Value(true), allocator); |
| o.AddMember(Value("false"), Value(false).Move(), allocator); // value is lvalue ref |
| o.AddMember(Value("int").Move(), Value(-1), allocator); // name is lvalue ref |
| o.AddMember("uint", std::move(Value().SetUint(1u)), allocator); // name is literal, value is rvalue |
| EXPECT_TRUE(o["true"].GetBool()); |
| EXPECT_FALSE(o["false"].GetBool()); |
| EXPECT_EQ(-1, o["int"].GetInt()); |
| EXPECT_EQ(1u, o["uint"].GetUint()); |
| EXPECT_EQ(4u, o.MemberCount()); |
| } |
| #endif |
| |
| // Tests a member with null character |
| Value name; |
| const Value C0D("C\0D", 3); |
| name.SetString(C0D.GetString(), 3); |
| value.SetString("CherryD", 7); |
| x.AddMember(name, value, allocator); |
| |
| // HasMember() |
| EXPECT_TRUE(x.HasMember("A")); |
| EXPECT_TRUE(x.HasMember("B")); |
| EXPECT_TRUE(y.HasMember("A")); |
| EXPECT_TRUE(y.HasMember("B")); |
| |
| #if RAPIDJSON_HAS_STDSTRING |
| EXPECT_TRUE(x.HasMember(std::string("A"))); |
| #endif |
| |
| name.SetString("C\0D"); |
| EXPECT_TRUE(x.HasMember(name)); |
| EXPECT_TRUE(y.HasMember(name)); |
| |
| GenericValue<UTF8<>, CrtAllocator> othername("A"); |
| EXPECT_TRUE(x.HasMember(othername)); |
| EXPECT_TRUE(y.HasMember(othername)); |
| othername.SetString("C\0D"); |
| EXPECT_TRUE(x.HasMember(othername)); |
| EXPECT_TRUE(y.HasMember(othername)); |
| |
| // operator[] |
| EXPECT_STREQ("Apple", x["A"].GetString()); |
| EXPECT_STREQ("Banana", x["B"].GetString()); |
| EXPECT_STREQ("CherryD", x[C0D].GetString()); |
| EXPECT_STREQ("CherryD", x[othername].GetString()); |
| EXPECT_THROW(x["nonexist"], AssertException); |
| |
| // const operator[] |
| EXPECT_STREQ("Apple", y["A"].GetString()); |
| EXPECT_STREQ("Banana", y["B"].GetString()); |
| EXPECT_STREQ("CherryD", y[C0D].GetString()); |
| |
| #if RAPIDJSON_HAS_STDSTRING |
| EXPECT_STREQ("Apple", x["A"].GetString()); |
| EXPECT_STREQ("Apple", y[std::string("A")].GetString()); |
| #endif |
| |
| // member iterator |
| Value::MemberIterator itr = x.MemberBegin(); |
| EXPECT_TRUE(itr != x.MemberEnd()); |
| EXPECT_STREQ("A", itr->name.GetString()); |
| EXPECT_STREQ("Apple", itr->value.GetString()); |
| ++itr; |
| EXPECT_TRUE(itr != x.MemberEnd()); |
| EXPECT_STREQ("B", itr->name.GetString()); |
| EXPECT_STREQ("Banana", itr->value.GetString()); |
| ++itr; |
| EXPECT_TRUE(itr != x.MemberEnd()); |
| EXPECT_TRUE(memcmp(itr->name.GetString(), "C\0D", 4) == 0); |
| EXPECT_STREQ("CherryD", itr->value.GetString()); |
| ++itr; |
| EXPECT_FALSE(itr != x.MemberEnd()); |
| |
| // const member iterator |
| Value::ConstMemberIterator citr = y.MemberBegin(); |
| EXPECT_TRUE(citr != y.MemberEnd()); |
| EXPECT_STREQ("A", citr->name.GetString()); |
| EXPECT_STREQ("Apple", citr->value.GetString()); |
| ++citr; |
| EXPECT_TRUE(citr != y.MemberEnd()); |
| EXPECT_STREQ("B", citr->name.GetString()); |
| EXPECT_STREQ("Banana", citr->value.GetString()); |
| ++citr; |
| EXPECT_TRUE(citr != y.MemberEnd()); |
| EXPECT_TRUE(memcmp(citr->name.GetString(), "C\0D", 4) == 0); |
| EXPECT_STREQ("CherryD", citr->value.GetString()); |
| ++citr; |
| EXPECT_FALSE(citr != y.MemberEnd()); |
| |
| // member iterator conversions/relations |
| itr = x.MemberBegin(); |
| citr = x.MemberBegin(); // const conversion |
| TestEqual(itr, citr); |
| EXPECT_TRUE(itr < x.MemberEnd()); |
| EXPECT_FALSE(itr > y.MemberEnd()); |
| EXPECT_TRUE(citr < x.MemberEnd()); |
| EXPECT_FALSE(citr > y.MemberEnd()); |
| ++citr; |
| TestUnequal(itr, citr); |
| EXPECT_FALSE(itr < itr); |
| EXPECT_TRUE(itr < citr); |
| EXPECT_FALSE(itr > itr); |
| EXPECT_TRUE(citr > itr); |
| EXPECT_EQ(1, citr - x.MemberBegin()); |
| EXPECT_EQ(0, itr - y.MemberBegin()); |
| itr += citr - x.MemberBegin(); |
| EXPECT_EQ(1, itr - y.MemberBegin()); |
| TestEqual(citr, itr); |
| EXPECT_TRUE(itr <= citr); |
| EXPECT_TRUE(citr <= itr); |
| itr++; |
| EXPECT_TRUE(itr >= citr); |
| EXPECT_FALSE(citr >= itr); |
| |
| // RemoveMember() |
| EXPECT_TRUE(x.RemoveMember("A")); |
| EXPECT_FALSE(x.HasMember("A")); |
| |
| EXPECT_TRUE(x.RemoveMember("B")); |
| EXPECT_FALSE(x.HasMember("B")); |
| |
| EXPECT_FALSE(x.RemoveMember("nonexist")); |
| |
| EXPECT_TRUE(x.RemoveMember(othername)); |
| EXPECT_FALSE(x.HasMember(name)); |
| |
| EXPECT_TRUE(x.MemberBegin() == x.MemberEnd()); |
| |
| // EraseMember(ConstMemberIterator) |
| |
| // Use array members to ensure removed elements' destructor is called. |
| // { "a": [0], "b": [1],[2],...] |
| const char keys[][2] = { "a", "b", "c", "d", "e", "f", "g", "h", "i", "j" }; |
| for (int i = 0; i < 10; i++) |
| x.AddMember(keys[i], Value(kArrayType).PushBack(i, allocator), allocator); |
| |
| // MemberCount, iterator difference |
| EXPECT_EQ(x.MemberCount(), SizeType(x.MemberEnd() - x.MemberBegin())); |
| |
| // Erase the first |
| itr = x.EraseMember(x.MemberBegin()); |
| EXPECT_FALSE(x.HasMember(keys[0])); |
| EXPECT_EQ(x.MemberBegin(), itr); |
| EXPECT_EQ(9u, x.MemberCount()); |
| for (; itr != x.MemberEnd(); ++itr) { |
| size_t i = static_cast<size_t>((itr - x.MemberBegin())) + 1; |
| EXPECT_STREQ(itr->name.GetString(), keys[i]); |
| EXPECT_EQ(static_cast<int>(i), itr->value[0].GetInt()); |
| } |
| |
| // Erase the last |
| itr = x.EraseMember(x.MemberEnd() - 1); |
| EXPECT_FALSE(x.HasMember(keys[9])); |
| EXPECT_EQ(x.MemberEnd(), itr); |
| EXPECT_EQ(8u, x.MemberCount()); |
| for (; itr != x.MemberEnd(); ++itr) { |
| size_t i = static_cast<size_t>(itr - x.MemberBegin()) + 1; |
| EXPECT_STREQ(itr->name.GetString(), keys[i]); |
| EXPECT_EQ(static_cast<int>(i), itr->value[0].GetInt()); |
| } |
| |
| // Erase the middle |
| itr = x.EraseMember(x.MemberBegin() + 4); |
| EXPECT_FALSE(x.HasMember(keys[5])); |
| EXPECT_EQ(x.MemberBegin() + 4, itr); |
| EXPECT_EQ(7u, x.MemberCount()); |
| for (; itr != x.MemberEnd(); ++itr) { |
| size_t i = static_cast<size_t>(itr - x.MemberBegin()); |
| i += (i < 4) ? 1 : 2; |
| EXPECT_STREQ(itr->name.GetString(), keys[i]); |
| EXPECT_EQ(static_cast<int>(i), itr->value[0].GetInt()); |
| } |
| |
| // EraseMember(ConstMemberIterator, ConstMemberIterator) |
| // Exhaustive test with all 0 <= first < n, first <= last <= n cases |
| const unsigned n = 10; |
| for (unsigned first = 0; first < n; first++) { |
| for (unsigned last = first; last <= n; last++) { |
| x.RemoveAllMembers(); |
| for (unsigned i = 0; i < n; i++) |
| x.AddMember(keys[i], Value(kArrayType).PushBack(i, allocator), allocator); |
| |
| itr = x.EraseMember(x.MemberBegin() + static_cast<int>(first), x.MemberBegin() + static_cast<int>(last)); |
| if (last == n) |
| EXPECT_EQ(x.MemberEnd(), itr); |
| else |
| EXPECT_EQ(x.MemberBegin() + static_cast<int>(first), itr); |
| |
| size_t removeCount = last - first; |
| EXPECT_EQ(n - removeCount, x.MemberCount()); |
| for (unsigned i = 0; i < first; i++) |
| EXPECT_EQ(i, x[keys[i]][0].GetUint()); |
| for (unsigned i = first; i < n - removeCount; i++) |
| EXPECT_EQ(i + removeCount, x[keys[i+removeCount]][0].GetUint()); |
| } |
| } |
| |
| // RemoveAllMembers() |
| x.RemoveAllMembers(); |
| EXPECT_TRUE(x.ObjectEmpty()); |
| EXPECT_EQ(0u, x.MemberCount()); |
| } |
| |
| TEST(Value, Object) { |
| Value::AllocatorType allocator; |
| Value x(kObjectType); |
| const Value& y = x; // const version |
| |
| EXPECT_EQ(kObjectType, x.GetType()); |
| EXPECT_TRUE(x.IsObject()); |
| EXPECT_TRUE(x.ObjectEmpty()); |
| EXPECT_EQ(0u, x.MemberCount()); |
| EXPECT_EQ(kObjectType, y.GetType()); |
| EXPECT_TRUE(y.IsObject()); |
| EXPECT_TRUE(y.ObjectEmpty()); |
| EXPECT_EQ(0u, y.MemberCount()); |
| |
| TestObject(x, allocator); |
| |
| // SetObject() |
| Value z; |
| z.SetObject(); |
| EXPECT_TRUE(z.IsObject()); |
| } |
| |
| TEST(Value, ObjectHelper) { |
| Value::AllocatorType allocator; |
| { |
| Value x(kObjectType); |
| Value::Object o = x.GetObject(); |
| TestObject(o, allocator); |
| } |
| |
| { |
| Value x(kObjectType); |
| Value::Object o = x.GetObject(); |
| o.AddMember("1", 1, allocator); |
| |
| Value::Object o2(o); // copy constructor |
| EXPECT_EQ(1u, o2.MemberCount()); |
| |
| Value::Object o3 = o; |
| EXPECT_EQ(1u, o3.MemberCount()); |
| |
| Value::ConstObject y = static_cast<const Value&>(x).GetObject(); |
| (void)y; |
| // y.AddMember("1", 1, allocator); // should not compile |
| |
| // Templated functions |
| x.RemoveAllMembers(); |
| EXPECT_TRUE(x.Is<Value::Object>()); |
| EXPECT_TRUE(x.Is<Value::ConstObject>()); |
| o.AddMember("1", 1, allocator); |
| EXPECT_EQ(1, x.Get<Value::Object>()["1"].GetInt()); |
| EXPECT_EQ(1, x.Get<Value::ConstObject>()["1"].GetInt()); |
| |
| Value x2; |
| x2.Set<Value::Object>(o); |
| EXPECT_TRUE(x.IsObject()); // IsObject() is invariant after moving |
| EXPECT_EQ(1, x2.Get<Value::Object>()["1"].GetInt()); |
| } |
| |
| { |
| Value x(kObjectType); |
| x.AddMember("a", "apple", allocator); |
| Value y(x.GetObject()); |
| EXPECT_STREQ("apple", y["a"].GetString()); |
| EXPECT_TRUE(x.IsObject()); // Invariant |
| } |
| |
| { |
| Value x(kObjectType); |
| x.AddMember("a", "apple", allocator); |
| Value y(kObjectType); |
| y.AddMember("fruits", x.GetObject(), allocator); |
| EXPECT_STREQ("apple", y["fruits"]["a"].GetString()); |
| EXPECT_TRUE(x.IsObject()); // Invariant |
| } |
| } |
| |
| #if RAPIDJSON_HAS_CXX11_RANGE_FOR |
| TEST(Value, ObjectHelperRangeFor) { |
| Value::AllocatorType allocator; |
| Value x(kObjectType); |
| |
| for (int i = 0; i < 10; i++) { |
| char name[10]; |
| Value n(name, static_cast<SizeType>(sprintf(name, "%d", i)), allocator); |
| x.AddMember(n, i, allocator); |
| } |
| |
| { |
| int i = 0; |
| for (auto& m : x.GetObject()) { |
| char name[11]; |
| sprintf(name, "%d", i); |
| EXPECT_STREQ(name, m.name.GetString()); |
| EXPECT_EQ(i, m.value.GetInt()); |
| i++; |
| } |
| EXPECT_EQ(i, 10); |
| } |
| { |
| int i = 0; |
| for (const auto& m : const_cast<const Value&>(x).GetObject()) { |
| char name[11]; |
| sprintf(name, "%d", i); |
| EXPECT_STREQ(name, m.name.GetString()); |
| EXPECT_EQ(i, m.value.GetInt()); |
| i++; |
| } |
| EXPECT_EQ(i, 10); |
| } |
| |
| // Object a = x.GetObject(); |
| // Object ca = const_cast<const Value&>(x).GetObject(); |
| } |
| #endif |
| |
| TEST(Value, EraseMember_String) { |
| Value::AllocatorType allocator; |
| Value x(kObjectType); |
| x.AddMember("A", "Apple", allocator); |
| x.AddMember("B", "Banana", allocator); |
| |
| EXPECT_TRUE(x.EraseMember("B")); |
| EXPECT_FALSE(x.HasMember("B")); |
| |
| EXPECT_FALSE(x.EraseMember("nonexist")); |
| |
| GenericValue<UTF8<>, CrtAllocator> othername("A"); |
| EXPECT_TRUE(x.EraseMember(othername)); |
| EXPECT_FALSE(x.HasMember("A")); |
| |
| EXPECT_TRUE(x.MemberBegin() == x.MemberEnd()); |
| } |
| |
| TEST(Value, BigNestedArray) { |
| MemoryPoolAllocator<> allocator; |
| Value x(kArrayType); |
| static const SizeType n = 200; |
| |
| for (SizeType i = 0; i < n; i++) { |
| Value y(kArrayType); |
| for (SizeType j = 0; j < n; j++) { |
| Value number(static_cast<int>(i * n + j)); |
| y.PushBack(number, allocator); |
| } |
| x.PushBack(y, allocator); |
| } |
| |
| for (SizeType i = 0; i < n; i++) |
| for (SizeType j = 0; j < n; j++) { |
| EXPECT_TRUE(x[i][j].IsInt()); |
| EXPECT_EQ(static_cast<int>(i * n + j), x[i][j].GetInt()); |
| } |
| } |
| |
| TEST(Value, BigNestedObject) { |
| MemoryPoolAllocator<> allocator; |
| Value x(kObjectType); |
| static const SizeType n = 200; |
| const char* format = std::numeric_limits<SizeType>::is_signed ? "%d" : "%u"; |
| |
| for (SizeType i = 0; i < n; i++) { |
| char name1[10]; |
| sprintf(name1, format, i); |
| |
| // Value name(name1); // should not compile |
| Value name(name1, static_cast<SizeType>(strlen(name1)), allocator); |
| Value object(kObjectType); |
| |
| for (SizeType j = 0; j < n; j++) { |
| char name2[10]; |
| sprintf(name2, format, j); |
| |
| Value name3(name2, static_cast<SizeType>(strlen(name2)), allocator); |
| Value number(static_cast<int>(i * n + j)); |
| object.AddMember(name3, number, allocator); |
| } |
| |
| // x.AddMember(name1, object, allocator); // should not compile |
| x.AddMember(name, object, allocator); |
| } |
| |
| for (SizeType i = 0; i < n; i++) { |
| char name1[10]; |
| sprintf(name1, format, i); |
| |
| for (SizeType j = 0; j < n; j++) { |
| char name2[10]; |
| sprintf(name2, format, j); |
| x[name1]; |
| EXPECT_EQ(static_cast<int>(i * n + j), x[name1][name2].GetInt()); |
| } |
| } |
| } |
| |
| // Issue 18: Error removing last element of object |
| // http://code.google.com/p/rapidjson/issues/detail?id=18 |
| TEST(Value, RemoveLastElement) { |
| rapidjson::Document doc; |
| rapidjson::Document::AllocatorType& allocator = doc.GetAllocator(); |
| rapidjson::Value objVal(rapidjson::kObjectType); |
| objVal.AddMember("var1", 123, allocator); |
| objVal.AddMember("var2", "444", allocator); |
| objVal.AddMember("var3", 555, allocator); |
| EXPECT_TRUE(objVal.HasMember("var3")); |
| objVal.RemoveMember("var3"); // Assertion here in r61 |
| EXPECT_FALSE(objVal.HasMember("var3")); |
| } |
| |
| // Issue 38: Segmentation fault with CrtAllocator |
| TEST(Document, CrtAllocator) { |
| typedef GenericValue<UTF8<>, CrtAllocator> V; |
| |
| V::AllocatorType allocator; |
| V o(kObjectType); |
| o.AddMember("x", 1, allocator); // Should not call destructor on uninitialized name/value of newly allocated members. |
| |
| V a(kArrayType); |
| a.PushBack(1, allocator); // Should not call destructor on uninitialized Value of newly allocated elements. |
| } |
| |
| static void TestShortStringOptimization(const char* str) { |
| const rapidjson::SizeType len = static_cast<rapidjson::SizeType>(strlen(str)); |
| |
| rapidjson::Document doc; |
| rapidjson::Value val; |
| val.SetString(str, len, doc.GetAllocator()); |
| |
| EXPECT_EQ(val.GetStringLength(), len); |
| EXPECT_STREQ(val.GetString(), str); |
| } |
| |
| TEST(Value, AllocateShortString) { |
| TestShortStringOptimization(""); // edge case: empty string |
| TestShortStringOptimization("12345678"); // regular case for short strings: 8 chars |
| TestShortStringOptimization("12345678901"); // edge case: 11 chars in 32-bit mode (=> short string) |
| TestShortStringOptimization("123456789012"); // edge case: 12 chars in 32-bit mode (=> regular string) |
| TestShortStringOptimization("123456789012345"); // edge case: 15 chars in 64-bit mode (=> short string) |
| TestShortStringOptimization("1234567890123456"); // edge case: 16 chars in 64-bit mode (=> regular string) |
| } |
| |
| template <int e> |
| struct TerminateHandler { |
| bool Null() { return e != 0; } |
| bool Bool(bool) { return e != 1; } |
| bool Int(int) { return e != 2; } |
| bool Uint(unsigned) { return e != 3; } |
| bool Int64(int64_t) { return e != 4; } |
| bool Uint64(uint64_t) { return e != 5; } |
| bool Double(double) { return e != 6; } |
| bool RawNumber(const char*, SizeType, bool) { return e != 7; } |
| bool String(const char*, SizeType, bool) { return e != 8; } |
| bool StartObject() { return e != 9; } |
| bool Key(const char*, SizeType, bool) { return e != 10; } |
| bool EndObject(SizeType) { return e != 11; } |
| bool StartArray() { return e != 12; } |
| bool EndArray(SizeType) { return e != 13; } |
| }; |
| |
| #define TEST_TERMINATION(e, json)\ |
| {\ |
| Document d; \ |
| EXPECT_FALSE(d.Parse(json).HasParseError()); \ |
| Reader reader; \ |
| TerminateHandler<e> h;\ |
| EXPECT_FALSE(d.Accept(h));\ |
| } |
| |
| TEST(Value, AcceptTerminationByHandler) { |
| TEST_TERMINATION(0, "[null]"); |
| TEST_TERMINATION(1, "[true]"); |
| TEST_TERMINATION(1, "[false]"); |
| TEST_TERMINATION(2, "[-1]"); |
| TEST_TERMINATION(3, "[2147483648]"); |
| TEST_TERMINATION(4, "[-1234567890123456789]"); |
| TEST_TERMINATION(5, "[9223372036854775808]"); |
| TEST_TERMINATION(6, "[0.5]"); |
| // RawNumber() is never called |
| TEST_TERMINATION(8, "[\"a\"]"); |
| TEST_TERMINATION(9, "[{}]"); |
| TEST_TERMINATION(10, "[{\"a\":1}]"); |
| TEST_TERMINATION(11, "[{}]"); |
| TEST_TERMINATION(12, "{\"a\":[]}"); |
| TEST_TERMINATION(13, "{\"a\":[]}"); |
| } |
| |
| struct ValueIntComparer { |
| bool operator()(const Value& lhs, const Value& rhs) const { |
| return lhs.GetInt() < rhs.GetInt(); |
| } |
| }; |
| |
| #if RAPIDJSON_HAS_CXX11_RVALUE_REFS |
| TEST(Value, Sorting) { |
| Value::AllocatorType allocator; |
| Value a(kArrayType); |
| a.PushBack(5, allocator); |
| a.PushBack(1, allocator); |
| a.PushBack(3, allocator); |
| std::sort(a.Begin(), a.End(), ValueIntComparer()); |
| EXPECT_EQ(1, a[0].GetInt()); |
| EXPECT_EQ(3, a[1].GetInt()); |
| EXPECT_EQ(5, a[2].GetInt()); |
| } |
| #endif |
| |
| // http://stackoverflow.com/questions/35222230/ |
| |
| static void MergeDuplicateKey(Value& v, Value::AllocatorType& a) { |
| if (v.IsObject()) { |
| // Convert all key:value into key:[value] |
| for (Value::MemberIterator itr = v.MemberBegin(); itr != v.MemberEnd(); ++itr) |
| itr->value = Value(kArrayType).Move().PushBack(itr->value, a); |
| |
| // Merge arrays if key is duplicated |
| for (Value::MemberIterator itr = v.MemberBegin(); itr != v.MemberEnd();) { |
| Value::MemberIterator itr2 = v.FindMember(itr->name); |
| if (itr != itr2) { |
| itr2->value.PushBack(itr->value[0], a); |
| itr = v.EraseMember(itr); |
| } |
| else |
| ++itr; |
| } |
| |
| // Convert key:[values] back to key:value if there is only one value |
| for (Value::MemberIterator itr = v.MemberBegin(); itr != v.MemberEnd(); ++itr) { |
| if (itr->value.Size() == 1) |
| itr->value = itr->value[0]; |
| MergeDuplicateKey(itr->value, a); // Recursion on the value |
| } |
| } |
| else if (v.IsArray()) |
| for (Value::ValueIterator itr = v.Begin(); itr != v.End(); ++itr) |
| MergeDuplicateKey(*itr, a); |
| } |
| |
| TEST(Value, MergeDuplicateKey) { |
| Document d; |
| d.Parse( |
| "{" |
| " \"key1\": {" |
| " \"a\": \"asdf\"," |
| " \"b\": \"foo\"," |
| " \"b\": \"bar\"," |
| " \"c\": \"fdas\"" |
| " }" |
| "}"); |
| |
| Document d2; |
| d2.Parse( |
| "{" |
| " \"key1\": {" |
| " \"a\": \"asdf\"," |
| " \"b\": [" |
| " \"foo\"," |
| " \"bar\"" |
| " ]," |
| " \"c\": \"fdas\"" |
| " }" |
| "}"); |
| |
| EXPECT_NE(d2, d); |
| MergeDuplicateKey(d, d.GetAllocator()); |
| EXPECT_EQ(d2, d); |
| } |
| |
| #ifdef __clang__ |
| RAPIDJSON_DIAG_POP |
| #endif |
