gdax-orderbook-hpp/demo/dependencies/rapidjson-1.1.0/test/unittest/writertest.cpp

   1 // Tencent is pleased to support the open source community by making RapidJSON available.
   2 //
   3 // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
   4 //
   5 // Licensed under the MIT License (the "License"); you may not use this file except
   6 // in compliance with the License. You may obtain a copy of the License at
   7 //
   8 // http://opensource.org/licenses/MIT
   9 //
  10 // Unless required by applicable law or agreed to in writing, software distributed
  11 // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
  12 // CONDITIONS OF ANY KIND, either express or implied. See the License for the
  13 // specific language governing permissions and limitations under the License.
  14
  15 #include "unittest.h"
  16
  17 #include "rapidjson/document.h"
  18 #include "rapidjson/reader.h"
  19 #include "rapidjson/writer.h"
  20 #include "rapidjson/stringbuffer.h"
  21 #include "rapidjson/memorybuffer.h"
  22
  23 using namespace rapidjson;
  24
  25 TEST(Writer, Compact) {
  26     StringStream s("{ \"hello\" : \"world\", \"t\" : true , \"f\" : false, \"n\": null, \"i\":123, \"pi\": 3.1416, \"a\":[1, 2, 3] } ");
  27     StringBuffer buffer;
  28     Writer<StringBuffer> writer(buffer);
  29     buffer.ShrinkToFit();
  30     Reader reader;
  31     reader.Parse<0>(s, writer);
  32     EXPECT_STREQ("{\"hello\":\"world\",\"t\":true,\"f\":false,\"n\":null,\"i\":123,\"pi\":3.1416,\"a\":[1,2,3]}", buffer.GetString());
  33     EXPECT_EQ(77u, buffer.GetSize());
  34     EXPECT_TRUE(writer.IsComplete());
  35 }
  36
  37 // json -> parse -> writer -> json
  38 #define TEST_ROUNDTRIP(json) \
  39     { \
  40         StringStream s(json); \
  41         StringBuffer buffer; \
  42         Writer<StringBuffer> writer(buffer); \
  43         Reader reader; \
  44         reader.Parse<kParseFullPrecisionFlag>(s, writer); \
  45         EXPECT_STREQ(json, buffer.GetString()); \
  46         EXPECT_TRUE(writer.IsComplete()); \
  47     }
  48
  49 TEST(Writer, Root) {
  50     TEST_ROUNDTRIP("null");
  51     TEST_ROUNDTRIP("true");
  52     TEST_ROUNDTRIP("false");
  53     TEST_ROUNDTRIP("0");
  54     TEST_ROUNDTRIP("\"foo\"");
  55     TEST_ROUNDTRIP("[]");
  56     TEST_ROUNDTRIP("{}");
  57 }
  58
  59 TEST(Writer, Int) {
  60     TEST_ROUNDTRIP("[-1]");
  61     TEST_ROUNDTRIP("[-123]");
  62     TEST_ROUNDTRIP("[-2147483648]");
  63 }
  64
  65 TEST(Writer, UInt) {
  66     TEST_ROUNDTRIP("[0]");
  67     TEST_ROUNDTRIP("[1]");
  68     TEST_ROUNDTRIP("[123]");
  69     TEST_ROUNDTRIP("[2147483647]");
  70     TEST_ROUNDTRIP("[4294967295]");
  71 }
  72
  73 TEST(Writer, Int64) {
  74     TEST_ROUNDTRIP("[-1234567890123456789]");
  75     TEST_ROUNDTRIP("[-9223372036854775808]");
  76 }
  77
  78 TEST(Writer, Uint64) {
  79     TEST_ROUNDTRIP("[1234567890123456789]");
  80     TEST_ROUNDTRIP("[9223372036854775807]");
  81 }
  82
  83 TEST(Writer, String) {
  84     TEST_ROUNDTRIP("[\"Hello\"]");
  85     TEST_ROUNDTRIP("[\"Hello\\u0000World\"]");
  86     TEST_ROUNDTRIP("[\"\\\"\\\\/\\b\\f\\n\\r\\t\"]");
  87
  88 #if RAPIDJSON_HAS_STDSTRING
  89     {
  90         StringBuffer buffer;
  91         Writer<StringBuffer> writer(buffer);
  92         writer.String(std::string("Hello\n"));
  93         EXPECT_STREQ("\"Hello\\n\"", buffer.GetString());
  94     }
  95 #endif
  96 }
  97
  98 TEST(Writer, ScanWriteUnescapedString) {
  99     const char json[] = "[\" \\\"0123456789ABCDEF\"]";
 100     //                       ^ scanning stops here.
 101     char buffer2[sizeof(json) + 32];
 102
 103     // Use different offset to test different alignments
 104     for (int i = 0; i < 32; i++) {
 105         char* p = buffer2 + i;
 106         memcpy(p, json, sizeof(json));
 107         TEST_ROUNDTRIP(p);
 108     }
 109 }
 110
 111 TEST(Writer, Double) {
 112     TEST_ROUNDTRIP("[1.2345,1.2345678,0.123456789012,1234567.8]");
 113     TEST_ROUNDTRIP("0.0");
 114     TEST_ROUNDTRIP("-0.0"); // Issue #289
 115     TEST_ROUNDTRIP("1e30");
 116     TEST_ROUNDTRIP("1.0");
 117     TEST_ROUNDTRIP("5e-324"); // Min subnormal positive double
 118     TEST_ROUNDTRIP("2.225073858507201e-308"); // Max subnormal positive double
 119     TEST_ROUNDTRIP("2.2250738585072014e-308"); // Min normal positive double
 120     TEST_ROUNDTRIP("1.7976931348623157e308"); // Max double
 121
 122 }
 123
 124 // UTF8 -> TargetEncoding -> UTF8
 125 template <typename TargetEncoding>
 126 void TestTranscode(const char* json) {
 127     StringStream s(json);
 128     GenericStringBuffer<TargetEncoding> buffer;
 129     Writer<GenericStringBuffer<TargetEncoding>, UTF8<>, TargetEncoding> writer(buffer);
 130     Reader reader;
 131     reader.Parse(s, writer);
 132
 133     StringBuffer buffer2;
 134     Writer<StringBuffer> writer2(buffer2);
 135     GenericReader<TargetEncoding, UTF8<> > reader2;
 136     GenericStringStream<TargetEncoding> s2(buffer.GetString());
 137     reader2.Parse(s2, writer2);
 138
 139     EXPECT_STREQ(json, buffer2.GetString());
 140 }
 141
 142 TEST(Writer, Transcode) {
 143     const char json[] = "{\"hello\":\"world\",\"t\":true,\"f\":false,\"n\":null,\"i\":123,\"pi\":3.1416,\"a\":[1,2,3],\"dollar\":\"\x24\",\"cents\":\"\xC2\xA2\",\"euro\":\"\xE2\x82\xAC\",\"gclef\":\"\xF0\x9D\x84\x9E\"}";
 144
 145     // UTF8 -> UTF16 -> UTF8
 146     TestTranscode<UTF8<> >(json);
 147
 148     // UTF8 -> ASCII -> UTF8
 149     TestTranscode<ASCII<> >(json);
 150
 151     // UTF8 -> UTF16 -> UTF8
 152     TestTranscode<UTF16<> >(json);
 153
 154     // UTF8 -> UTF32 -> UTF8
 155     TestTranscode<UTF32<> >(json);
 156
 157     // UTF8 -> AutoUTF -> UTF8
 158     UTFType types[] = { kUTF8, kUTF16LE , kUTF16BE, kUTF32LE , kUTF32BE };
 159     for (size_t i = 0; i < 5; i++) {
 160         StringStream s(json);
 161         MemoryBuffer buffer;
 162         AutoUTFOutputStream<unsigned, MemoryBuffer> os(buffer, types[i], true);
 163         Writer<AutoUTFOutputStream<unsigned, MemoryBuffer>, UTF8<>, AutoUTF<unsigned> > writer(os);
 164         Reader reader;
 165         reader.Parse(s, writer);
 166
 167         StringBuffer buffer2;
 168         Writer<StringBuffer> writer2(buffer2);
 169         GenericReader<AutoUTF<unsigned>, UTF8<> > reader2;
 170         MemoryStream s2(buffer.GetBuffer(), buffer.GetSize());
 171         AutoUTFInputStream<unsigned, MemoryStream> is(s2);
 172         reader2.Parse(is, writer2);
 173
 174         EXPECT_STREQ(json, buffer2.GetString());
 175     }
 176
 177 }
 178
 179 #include <sstream>
 180
 181 class OStreamWrapper {
 182 public:
 183     typedef char Ch;
 184
 185     OStreamWrapper(std::ostream& os) : os_(os) {}
 186
 187     Ch Peek() const { assert(false); return '\0'; }
 188     Ch Take() { assert(false); return '\0'; }
 189     size_t Tell() const { return 0; }
 190
 191     Ch* PutBegin() { assert(false); return 0; }
 192     void Put(Ch c) { os_.put(c); }
 193     void Flush() { os_.flush(); }
 194     size_t PutEnd(Ch*) { assert(false); return 0; }
 195
 196 private:
 197     OStreamWrapper(const OStreamWrapper&);
 198     OStreamWrapper& operator=(const OStreamWrapper&);
 199
 200     std::ostream& os_;
 201 };
 202
 203 TEST(Writer, OStreamWrapper) {
 204     StringStream s("{ \"hello\" : \"world\", \"t\" : true , \"f\" : false, \"n\": null, \"i\":123, \"pi\": 3.1416, \"a\":[1, 2, 3], \"u64\": 1234567890123456789, \"i64\":-1234567890123456789 } ");
 205
 206     std::stringstream ss;
 207     OStreamWrapper os(ss);
 208
 209     Writer<OStreamWrapper> writer(os);
 210
 211     Reader reader;
 212     reader.Parse<0>(s, writer);
 213
 214     std::string actual = ss.str();
 215     EXPECT_STREQ("{\"hello\":\"world\",\"t\":true,\"f\":false,\"n\":null,\"i\":123,\"pi\":3.1416,\"a\":[1,2,3],\"u64\":1234567890123456789,\"i64\":-1234567890123456789}", actual.c_str());
 216 }
 217
 218 TEST(Writer, AssertRootMayBeAnyValue) {
 219 #define T(x)\
 220     {\
 221         StringBuffer buffer;\
 222         Writer<StringBuffer> writer(buffer);\
 223         EXPECT_TRUE(x);\
 224     }
 225     T(writer.Bool(false));
 226     T(writer.Bool(true));
 227     T(writer.Null());
 228     T(writer.Int(0));
 229     T(writer.Uint(0));
 230     T(writer.Int64(0));
 231     T(writer.Uint64(0));
 232     T(writer.Double(0));
 233     T(writer.String("foo"));
 234 #undef T
 235 }
 236
 237 TEST(Writer, AssertIncorrectObjectLevel) {
 238     StringBuffer buffer;
 239     Writer<StringBuffer> writer(buffer);
 240     writer.StartObject();
 241     writer.EndObject();
 242     ASSERT_THROW(writer.EndObject(), AssertException);
 243 }
 244
 245 TEST(Writer, AssertIncorrectArrayLevel) {
 246     StringBuffer buffer;
 247     Writer<StringBuffer> writer(buffer);
 248     writer.StartArray();
 249     writer.EndArray();
 250     ASSERT_THROW(writer.EndArray(), AssertException);
 251 }
 252
 253 TEST(Writer, AssertIncorrectEndObject) {
 254     StringBuffer buffer;
 255     Writer<StringBuffer> writer(buffer);
 256     writer.StartObject();
 257     ASSERT_THROW(writer.EndArray(), AssertException);
 258 }
 259
 260 TEST(Writer, AssertIncorrectEndArray) {
 261     StringBuffer buffer;
 262     Writer<StringBuffer> writer(buffer);
 263     writer.StartObject();
 264     ASSERT_THROW(writer.EndArray(), AssertException);
 265 }
 266
 267 TEST(Writer, AssertObjectKeyNotString) {
 268 #define T(x)\
 269     {\
 270         StringBuffer buffer;\
 271         Writer<StringBuffer> writer(buffer);\
 272         writer.StartObject();\
 273         ASSERT_THROW(x, AssertException); \
 274     }
 275     T(writer.Bool(false));
 276     T(writer.Bool(true));
 277     T(writer.Null());
 278     T(writer.Int(0));
 279     T(writer.Uint(0));
 280     T(writer.Int64(0));
 281     T(writer.Uint64(0));
 282     T(writer.Double(0));
 283     T(writer.StartObject());
 284     T(writer.StartArray());
 285 #undef T
 286 }
 287
 288 TEST(Writer, AssertMultipleRoot) {
 289     StringBuffer buffer;
 290     Writer<StringBuffer> writer(buffer);
 291
 292     writer.StartObject();
 293     writer.EndObject();
 294     ASSERT_THROW(writer.StartObject(), AssertException);
 295
 296     writer.Reset(buffer);
 297     writer.Null();
 298     ASSERT_THROW(writer.Int(0), AssertException);
 299
 300     writer.Reset(buffer);
 301     writer.String("foo");
 302     ASSERT_THROW(writer.StartArray(), AssertException);
 303
 304     writer.Reset(buffer);
 305     writer.StartArray();
 306     writer.EndArray();
 307     //ASSERT_THROW(writer.Double(3.14), AssertException);
 308 }
 309
 310 TEST(Writer, RootObjectIsComplete) {
 311     StringBuffer buffer;
 312     Writer<StringBuffer> writer(buffer);
 313     EXPECT_FALSE(writer.IsComplete());
 314     writer.StartObject();
 315     EXPECT_FALSE(writer.IsComplete());
 316     writer.String("foo");
 317     EXPECT_FALSE(writer.IsComplete());
 318     writer.Int(1);
 319     EXPECT_FALSE(writer.IsComplete());
 320     writer.EndObject();
 321     EXPECT_TRUE(writer.IsComplete());
 322 }
 323
 324 TEST(Writer, RootArrayIsComplete) {
 325     StringBuffer buffer;
 326     Writer<StringBuffer> writer(buffer);
 327     EXPECT_FALSE(writer.IsComplete());
 328     writer.StartArray();
 329     EXPECT_FALSE(writer.IsComplete());
 330     writer.String("foo");
 331     EXPECT_FALSE(writer.IsComplete());
 332     writer.Int(1);
 333     EXPECT_FALSE(writer.IsComplete());
 334     writer.EndArray();
 335     EXPECT_TRUE(writer.IsComplete());
 336 }
 337
 338 TEST(Writer, RootValueIsComplete) {
 339 #define T(x)\
 340     {\
 341         StringBuffer buffer;\
 342         Writer<StringBuffer> writer(buffer);\
 343         EXPECT_FALSE(writer.IsComplete()); \
 344         x; \
 345         EXPECT_TRUE(writer.IsComplete()); \
 346     }
 347     T(writer.Null());
 348     T(writer.Bool(true));
 349     T(writer.Bool(false));
 350     T(writer.Int(0));
 351     T(writer.Uint(0));
 352     T(writer.Int64(0));
 353     T(writer.Uint64(0));
 354     T(writer.Double(0));
 355     T(writer.String(""));
 356 #undef T
 357 }
 358
 359 TEST(Writer, InvalidEncoding) {
 360     // Fail in decoding invalid UTF-8 sequence http://www.cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-test.txt
 361     {
 362         GenericStringBuffer<UTF16<> > buffer;
 363         Writer<GenericStringBuffer<UTF16<> >, UTF8<>, UTF16<> > writer(buffer);
 364         writer.StartArray();
 365         EXPECT_FALSE(writer.String("\xfe"));
 366         EXPECT_FALSE(writer.String("\xff"));
 367         EXPECT_FALSE(writer.String("\xfe\xfe\xff\xff"));
 368         writer.EndArray();
 369     }
 370
 371     // Fail in encoding
 372     {
 373         StringBuffer buffer;
 374         Writer<StringBuffer, UTF32<> > writer(buffer);
 375         static const UTF32<>::Ch s[] = { 0x110000, 0 }; // Out of U+0000 to U+10FFFF
 376         EXPECT_FALSE(writer.String(s));
 377     }
 378
 379     // Fail in unicode escaping in ASCII output
 380     {
 381         StringBuffer buffer;
 382         Writer<StringBuffer, UTF32<>, ASCII<> > writer(buffer);
 383         static const UTF32<>::Ch s[] = { 0x110000, 0 }; // Out of U+0000 to U+10FFFF
 384         EXPECT_FALSE(writer.String(s));
 385     }
 386 }
 387
 388 TEST(Writer, ValidateEncoding) {
 389     {
 390         StringBuffer buffer;
 391         Writer<StringBuffer, UTF8<>, UTF8<>, CrtAllocator, kWriteValidateEncodingFlag> writer(buffer);
 392         writer.StartArray();
 393         EXPECT_TRUE(writer.String("\x24"));             // Dollar sign U+0024
 394         EXPECT_TRUE(writer.String("\xC2\xA2"));         // Cents sign U+00A2
 395         EXPECT_TRUE(writer.String("\xE2\x82\xAC"));     // Euro sign U+20AC
 396         EXPECT_TRUE(writer.String("\xF0\x9D\x84\x9E")); // G clef sign U+1D11E
 397         writer.EndArray();
 398         EXPECT_STREQ("[\"\x24\",\"\xC2\xA2\",\"\xE2\x82\xAC\",\"\xF0\x9D\x84\x9E\"]", buffer.GetString());
 399     }
 400
 401     // Fail in decoding invalid UTF-8 sequence http://www.cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-test.txt
 402     {
 403         StringBuffer buffer;
 404         Writer<StringBuffer, UTF8<>, UTF8<>, CrtAllocator, kWriteValidateEncodingFlag> writer(buffer);
 405         writer.StartArray();
 406         EXPECT_FALSE(writer.String("\xfe"));
 407         EXPECT_FALSE(writer.String("\xff"));
 408         EXPECT_FALSE(writer.String("\xfe\xfe\xff\xff"));
 409         writer.EndArray();
 410     }
 411 }
 412
 413 TEST(Writer, InvalidEventSequence) {
 414     // {]
 415     {
 416         StringBuffer buffer;
 417         Writer<StringBuffer> writer(buffer);
 418         writer.StartObject();
 419         EXPECT_THROW(writer.EndArray(), AssertException);
 420         EXPECT_FALSE(writer.IsComplete());
 421     }
 422
 423     // [}
 424     {
 425         StringBuffer buffer;
 426         Writer<StringBuffer> writer(buffer);
 427         writer.StartArray();
 428         EXPECT_THROW(writer.EndObject(), AssertException);
 429         EXPECT_FALSE(writer.IsComplete());
 430     }
 431
 432     // { 1:
 433     {
 434         StringBuffer buffer;
 435         Writer<StringBuffer> writer(buffer);
 436         writer.StartObject();
 437         EXPECT_THROW(writer.Int(1), AssertException);
 438         EXPECT_FALSE(writer.IsComplete());
 439     }
 440 }
 441
 442 TEST(Writer, NaN) {
 443     double nan = std::numeric_limits<double>::quiet_NaN();
 444
 445     EXPECT_TRUE(internal::Double(nan).IsNan());
 446     StringBuffer buffer;
 447     {
 448         Writer<StringBuffer> writer(buffer);
 449         EXPECT_FALSE(writer.Double(nan));
 450     }
 451     {
 452         Writer<StringBuffer, UTF8<>, UTF8<>, CrtAllocator, kWriteNanAndInfFlag> writer(buffer);
 453         EXPECT_TRUE(writer.Double(nan));
 454         EXPECT_STREQ("NaN", buffer.GetString());
 455     }
 456     GenericStringBuffer<UTF16<> > buffer2;
 457     Writer<GenericStringBuffer<UTF16<> > > writer2(buffer2);
 458     EXPECT_FALSE(writer2.Double(nan));
 459 }
 460
 461 TEST(Writer, Inf) {
 462     double inf = std::numeric_limits<double>::infinity();
 463
 464     EXPECT_TRUE(internal::Double(inf).IsInf());
 465     StringBuffer buffer;
 466     {
 467         Writer<StringBuffer> writer(buffer);
 468         EXPECT_FALSE(writer.Double(inf));
 469     }
 470     {
 471         Writer<StringBuffer> writer(buffer);
 472         EXPECT_FALSE(writer.Double(-inf));
 473     }
 474     {
 475         Writer<StringBuffer, UTF8<>, UTF8<>, CrtAllocator, kWriteNanAndInfFlag> writer(buffer);
 476         EXPECT_TRUE(writer.Double(inf));
 477     }
 478     {
 479         Writer<StringBuffer, UTF8<>, UTF8<>, CrtAllocator, kWriteNanAndInfFlag> writer(buffer);
 480         EXPECT_TRUE(writer.Double(-inf));
 481     }
 482     EXPECT_STREQ("Infinity-Infinity", buffer.GetString());
 483 }
 484
 485 TEST(Writer, RawValue) {
 486     StringBuffer buffer;
 487     Writer<StringBuffer> writer(buffer);
 488     writer.StartObject();
 489     writer.Key("a");
 490     writer.Int(1);
 491     writer.Key("raw");
 492     const char json[] = "[\"Hello\\nWorld\", 123.456]";
 493     writer.RawValue(json, strlen(json), kArrayType);
 494     writer.EndObject();
 495     EXPECT_TRUE(writer.IsComplete());
 496     EXPECT_STREQ("{\"a\":1,\"raw\":[\"Hello\\nWorld\", 123.456]}", buffer.GetString());
 497 }