rj_schema 0.0.1

data/ext/rj_schema/rapidjson/test/CMakeLists.txt

@@ -0,0 +1,20 @@
+find_package(GTestSrc)
+
+IF(GTESTSRC_FOUND)
+    enable_testing()
+
+    if (WIN32 AND (NOT CYGWIN) AND (NOT MINGW))
+        set(gtest_disable_pthreads ON)
+        set(gtest_force_shared_crt ON)
+    endif()
+
+    add_subdirectory(${GTEST_SOURCE_DIR} ${CMAKE_BINARY_DIR}/googletest)
+    include_directories(SYSTEM ${GTEST_INCLUDE_DIR})
+
+    set(TEST_LIBRARIES gtest gtest_main)
+
+    add_custom_target(tests ALL)
+    add_subdirectory(perftest)
+    add_subdirectory(unittest)
+
+ENDIF(GTESTSRC_FOUND)

data/ext/rj_schema/rapidjson/test/perftest/CMakeLists.txt

@@ -0,0 +1,28 @@
+set(PERFTEST_SOURCES
+    misctest.cpp
+    perftest.cpp
+    platformtest.cpp
+    rapidjsontest.cpp
+    schematest.cpp)
+
+add_executable(perftest ${PERFTEST_SOURCES})
+target_link_libraries(perftest ${TEST_LIBRARIES})
+
+add_dependencies(tests perftest)
+
+find_program(CCACHE_FOUND ccache)
+if(CCACHE_FOUND)
+    set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ccache)
+    set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ccache)
+    if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Qunused-arguments -fcolor-diagnostics")
+    endif()
+endif(CCACHE_FOUND)
+
+set_property(DIRECTORY PROPERTY COMPILE_OPTIONS ${EXTRA_CXX_FLAGS})
+
+IF(NOT (CMAKE_BUILD_TYPE STREQUAL "Debug"))
+add_test(NAME perftest
+    COMMAND ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/perftest
+    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/bin)
+ENDIF()

data/ext/rj_schema/rapidjson/test/perftest/misctest.cpp

@@ -0,0 +1,974 @@
+// 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. All rights reserved.
+//
+// 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 "perftest.h"
+
+#if TEST_MISC
+
+#define __STDC_FORMAT_MACROS
+#include "rapidjson/stringbuffer.h"
+
+#define protected public
+#include "rapidjson/writer.h"
+#undef private
+
+class Misc : public PerfTest {
+};
+
+// Copyright (c) 2008-2010 Bjoern Hoehrmann <bjoern@hoehrmann.de>
+// See http://bjoern.hoehrmann.de/utf-8/decoder/dfa/ for details.
+
+#define UTF8_ACCEPT 0
+#define UTF8_REJECT 12
+
+static const unsigned char utf8d[] = {
+    // The first part of the table maps bytes to character classes that
+    // to reduce the size of the transition table and create bitmasks.
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,  9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+    7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
+    8,8,2,2,2,2,2,2,2,2,2,2,2,2,2,2,  2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+    10,3,3,3,3,3,3,3,3,3,3,3,3,4,3,3, 11,6,6,6,5,8,8,8,8,8,8,8,8,8,8,8,
+
+    // The second part is a transition table that maps a combination
+    // of a state of the automaton and a character class to a state.
+    0,12,24,36,60,96,84,12,12,12,48,72, 12,12,12,12,12,12,12,12,12,12,12,12,
+    12, 0,12,12,12,12,12, 0,12, 0,12,12, 12,24,12,12,12,12,12,24,12,24,12,12,
+    12,12,12,12,12,12,12,24,12,12,12,12, 12,24,12,12,12,12,12,12,12,24,12,12,
+    12,12,12,12,12,12,12,36,12,36,12,12, 12,36,12,12,12,12,12,36,12,36,12,12,
+    12,36,12,12,12,12,12,12,12,12,12,12, 
+};
+
+static unsigned inline decode(unsigned* state, unsigned* codep, unsigned byte) {
+    unsigned type = utf8d[byte];
+
+    *codep = (*state != UTF8_ACCEPT) ?
+        (byte & 0x3fu) | (*codep << 6) :
+    (0xff >> type) & (byte);
+
+    *state = utf8d[256 + *state + type];
+    return *state;
+}
+
+static bool IsUTF8(unsigned char* s) {
+    unsigned codepoint, state = 0;
+
+    while (*s)
+        decode(&state, &codepoint, *s++);
+
+    return state == UTF8_ACCEPT;
+}
+
+TEST_F(Misc, Hoehrmann_IsUTF8) {
+    for (size_t i = 0; i < kTrialCount; i++) {
+        EXPECT_TRUE(IsUTF8((unsigned char*)json_));
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// CountDecimalDigit: Count number of decimal places
+
+inline unsigned CountDecimalDigit_naive(unsigned n) {
+    unsigned count = 1;
+    while (n >= 10) {
+        n /= 10;
+        count++;
+    }
+    return count;
+}
+
+inline unsigned CountDecimalDigit_enroll4(unsigned n) {
+    unsigned count = 1;
+    while (n >= 10000) {
+        n /= 10000u;
+        count += 4;
+    }
+    if (n < 10) return count;
+    if (n < 100) return count + 1;
+    if (n < 1000) return count + 2;
+    return count + 3;
+}
+
+inline unsigned CountDecimalDigit64_enroll4(uint64_t n) {
+    unsigned count = 1;
+    while (n >= 10000) {
+        n /= 10000u;
+        count += 4;
+    }
+    if (n < 10) return count;
+    if (n < 100) return count + 1;
+    if (n < 1000) return count + 2;
+    return count + 3;
+}
+
+inline unsigned CountDecimalDigit_fast(unsigned n) {
+    static const uint32_t powers_of_10[] = {
+        0,
+        10,
+        100,
+        1000,
+        10000,
+        100000,
+        1000000,
+        10000000,
+        100000000,
+        1000000000
+    };
+
+#if defined(_M_IX86) || defined(_M_X64)
+    unsigned long i = 0;
+    _BitScanReverse(&i, n | 1);
+    uint32_t t = (i + 1) * 1233 >> 12;
+#elif defined(__GNUC__)
+    uint32_t t = (32 - __builtin_clz(n | 1)) * 1233 >> 12;
+#else
+#error
+#endif
+    return t - (n < powers_of_10[t]) + 1;
+}
+
+inline unsigned CountDecimalDigit64_fast(uint64_t n) {
+    static const uint64_t powers_of_10[] = {
+        0,
+        10,
+        100,
+        1000,
+        10000,
+        100000,
+        1000000,
+        10000000,
+        100000000,
+        1000000000,
+        10000000000,
+        100000000000,
+        1000000000000,
+        10000000000000,
+        100000000000000,
+        1000000000000000,
+        10000000000000000,
+        100000000000000000,
+        1000000000000000000,
+        10000000000000000000U
+    };
+
+#if defined(_M_IX86)
+    uint64_t m = n | 1;
+    unsigned long i = 0;
+    if (_BitScanReverse(&i, m >> 32))
+        i += 32;
+    else
+        _BitScanReverse(&i, m & 0xFFFFFFFF);
+    uint32_t t = (i + 1) * 1233 >> 12;
+#elif defined(_M_X64)
+    unsigned long i = 0;
+    _BitScanReverse64(&i, n | 1);
+    uint32_t t = (i + 1) * 1233 >> 12;
+#elif defined(__GNUC__)
+    uint32_t t = (64 - __builtin_clzll(n | 1)) * 1233 >> 12;
+#else
+#error
+#endif
+
+    return t - (n < powers_of_10[t]) + 1;
+}
+
+#if 0
+// Exhaustive, very slow
+TEST_F(Misc, CountDecimalDigit_Verify) {
+    unsigned i = 0;
+    do {
+        if (i % (65536 * 256) == 0)
+            printf("%u\n", i);
+        ASSERT_EQ(CountDecimalDigit_enroll4(i), CountDecimalDigit_fast(i));
+        i++;
+    } while (i != 0);
+}
+
+static const unsigned kDigits10Trial = 1000000000u;
+TEST_F(Misc, CountDecimalDigit_naive) {
+    unsigned sum = 0;
+    for (unsigned i = 0; i < kDigits10Trial; i++)
+        sum += CountDecimalDigit_naive(i);
+    printf("%u\n", sum);
+}
+
+TEST_F(Misc, CountDecimalDigit_enroll4) {
+    unsigned sum = 0;
+    for (unsigned i = 0; i < kDigits10Trial; i++)
+        sum += CountDecimalDigit_enroll4(i);
+    printf("%u\n", sum);
+}
+
+TEST_F(Misc, CountDecimalDigit_fast) {
+    unsigned sum = 0;
+    for (unsigned i = 0; i < kDigits10Trial; i++)
+        sum += CountDecimalDigit_fast(i);
+    printf("%u\n", sum);
+}
+#endif
+
+TEST_F(Misc, CountDecimalDigit64_VerifyFast) {
+    uint64_t i = 1, j;
+    do {
+        //printf("%" PRIu64 "\n", i);
+        ASSERT_EQ(CountDecimalDigit64_enroll4(i), CountDecimalDigit64_fast(i));
+        j = i;
+        i *= 3;
+    } while (j < i);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// integer-to-string conversion
+
+// https://gist.github.com/anonymous/7179097
+static const int randval[] ={
+     936116,  369532,  453755,  -72860,  209713,  268347,  435278, -360266, -416287, -182064,
+    -644712,  944969,  640463, -366588,  471577,  -69401, -744294, -505829,  923883,  831785,
+    -601136, -636767, -437054,  591718,  100758,  231907, -719038,  973540, -605220,  506659,
+    -871653,  462533,  764843, -919138,  404305, -630931, -288711, -751454, -173726, -718208,
+     432689, -281157,  360737,  659827,   19174, -376450,  769984, -858198,  439127,  734703,
+    -683426,       7,  386135,  186997, -643900, -744422, -604708, -629545,   42313, -933592,
+    -635566,  182308,  439024, -367219,  -73924, -516649,  421935, -470515,  413507,  -78952,
+    -427917, -561158,  737176,   94538,  572322,  405217,  709266, -357278, -908099, -425447,
+     601119,  750712, -862285, -177869,  900102,  384877,  157859, -641680,  503738, -702558,
+     278225,  463290,  268378, -212840,  580090,  347346, -473985, -950968, -114547, -839893,
+    -738032, -789424,  409540,  493495,  432099,  119755,  905004, -174834,  338266,  234298,
+      74641, -965136, -754593,  685273,  466924,  920560,  385062,  796402,  -67229,  994864,
+     376974,  299869, -647540, -128724,  469890, -163167, -547803, -743363,  486463, -621028,
+     612288,   27459, -514224,  126342,  -66612,  803409, -777155, -336453, -284002,  472451,
+     342390, -163630,  908356, -456147, -825607,  268092, -974715,  287227,  227890, -524101,
+     616370, -782456,  922098, -624001, -813690,  171605, -192962,  796151,  707183,  -95696,
+     -23163, -721260,  508892,  430715,  791331,  482048, -996102,  863274,  275406,   -8279,
+    -556239, -902076,  268647, -818565,  260069, -798232, -172924, -566311, -806503, -885992,
+     813969,  -78468,  956632,  304288,  494867, -508784,  381751,  151264,  762953,   76352,
+     594902,  375424,  271700, -743062,  390176,  924237,  772574,  676610,  435752, -153847,
+       3959, -971937, -294181, -538049, -344620, -170136,   19120, -703157,  868152, -657961,
+    -818631,  219015, -872729, -940001, -956570,  880727, -345910,  942913, -942271, -788115,
+     225294,  701108, -517736, -416071,  281940,  488730,  942698,  711494,  838382, -892302,
+    -533028,  103052,  528823,  901515,  949577,  159364,  718227, -241814, -733661, -462928,
+    -495829,  165170,  513580, -629188, -509571, -459083,  198437,   77198, -644612,  811276,
+    -422298, -860842,  -52584,  920369,  686424, -530667, -243476,   49763,  345866, -411960,
+    -114863,  470810, -302860,  683007, -509080,       2, -174981, -772163,  -48697,  447770,
+    -268246,  213268,  269215,   78810, -236340, -639140, -864323,  505113, -986569, -325215,
+     541859,  163070, -819998, -645161, -583336,  573414,  696417, -132375,       3, -294501,
+     320435,  682591,  840008,  351740,  426951,  609354,  898154, -943254,  227321, -859793,
+    -727993,   44137, -497965, -782239,   14955, -746080, -243366,    9837, -233083,  606507,
+    -995864, -615287, -994307,  602715,  770771, -315040,  610860,  446102, -307120,  710728,
+    -590392, -230474, -762625, -637525,  134963, -202700, -766902, -985541,  218163,  682009,
+     926051,  525156,  -61195,  403211, -810098,  245539, -431733,  179998, -806533,  745943,
+     447597,  131973, -187130,  826019,  286107, -937230, -577419,   20254,  681802, -340500,
+     323080,  266283, -667617,  309656,  416386,  611863,  759991, -534257,  523112, -634892,
+    -169913, -204905, -909867, -882185, -944908,  741811, -717675,  967007, -317396,  407230,
+    -412805,  792905,  994873,  744793, -456797,  713493,  355232,  116900, -945199,  880539,
+     342505, -580824, -262273,  982968, -349497, -735488,  311767, -455191,  570918,  389734,
+    -958386,   10262,  -99267,  155481,  304210,  204724,  704367, -144893, -233664, -671441,
+     896849,  408613,  762236,  322697,  981321,  688476,   13663, -970704, -379507,  896412,
+     977084,  348869,  875948,  341348,  318710,  512081,    6163,  669044,  833295,  811883,
+     708756, -802534, -536057,  608413, -389625, -694603,  541106, -110037,  720322, -540581,
+     645420,   32980,   62442,  510157, -981870,  -87093, -325960, -500494, -718291,  -67889,
+     991501,  374804,  769026, -978869,  294747,  714623,  413327, -199164,  671368,  804789,
+    -362507,  798196, -170790, -568895, -869379,   62020, -316693, -837793,  644994,  -39341,
+    -417504, -243068, -957756,   99072,  622234, -739992,  225668,    8863, -505910,   82483,
+    -559244,  241572,    1315,  -36175,  -54990,  376813,     -11,  162647, -688204, -486163,
+     -54934, -197470,  744223, -762707,  732540,  996618,  351561, -445933, -898491,  486531,
+     456151,   15276,  290186, -817110,  -52995,  313046, -452533,  -96267,   94470, -500176,
+    -818026, -398071, -810548, -143325, -819741,    1338, -897676, -101577, -855445,   37309,
+     285742,  953804, -777927, -926962, -811217, -936744, -952245, -802300, -490188, -964953,
+    -552279,  329142, -570048, -505756,  682898, -381089,  -14352,  175138,  152390, -582268,
+    -485137,  717035,  805329,  239572, -730409,  209643, -184403, -385864,  675086,  819648,
+     629058, -527109, -488666, -171981,  532788,  552441,  174666,  984921,  766514,  758787,
+     716309,  338801, -978004, -412163,  876079, -734212,  789557, -160491, -522719,   56644,
+       -991, -286038,  -53983,  663740,  809812,  919889, -717502, -137704,  220511,  184396,
+    -825740, -588447,  430870,  124309,  135956,  558662, -307087, -788055, -451328,  812260,
+     931601,  324347, -482989, -117858, -278861,  189068, -172774,  929057,  293787,  198161,
+    -342386,  -47173,  906555, -759955,  -12779,  777604,  -97869,  899320,  927486,  -25284,
+    -848550,  259450, -485856,  -17820,      88,  171400,  235492, -326783, -340793,  886886,
+     112428, -246280,    5979,  648444, -114982,  991013,  -56489,   -9497,  419706,  632820,
+    -341664,  393926, -848977,  -22538,  257307,  773731, -905319,  491153,  734883, -868212,
+    -951053,  644458, -580758,  764735,  584316,  297077,   28852, -397710, -953669,  201772,
+     879050, -198237, -588468,  448102, -116837,  770007, -231812,  642906, -582166, -885828,
+          9,  305082, -996577,  303559,   75008, -772956, -447960,  599825, -295552,  870739,
+    -386278, -950300,  485359, -457081,  629461, -850276,  550496, -451755, -620841,  -11766,
+    -950137,  832337,   28711, -273398, -507197,   91921, -271360, -705991, -753220, -388968,
+     967945,  340434, -320883, -662793, -554617, -574568,  477946,   -6148, -129519,  689217,
+     920020, -656315, -974523, -212525,   80921, -612532,  645096,  545655,  655713, -591631,
+    -307385, -816688, -618823, -113713,  526430,  673063,  735916, -809095, -850417,  639004,
+     432281, -388185,  270708,  860146,  -39902, -786157, -258180, -246169, -966720, -264957,
+     548072, -306010,  -57367, -635665,  933824,   70553, -989936, -488741,   72411, -452509,
+     529831,  956277,  449019, -577850, -360986, -803418,   48833,  296073,  203430,  609591,
+     715483,  470964,  658106, -718254,  -96424,  790163,  334739,  181070, -373578,       5,
+    -435088,  329841,  330939, -256602,  394355,  912412,  231910,  927278, -661933,  788539,
+    -769664, -893274,  -96856,  298205,  901043, -608122, -527430,  183618, -553963,  -35246,
+    -393924,  948832, -483198,  594501,   35460, -407007,   93494, -336881, -634072,  984205,
+    -812161,  944664,  -31062,  753872,  823933,  -69566,   50445,  290147,   85134,   34706,
+     551902,  405202, -991246,  -84642,  154341,  316432, -695101, -651588,   -5030,  137564,
+    -294665,  332541,  528307,  -90572, -344923,  523766, -758498, -968047,  339028,  494578,
+     593129, -725773,   31834, -718406, -208638,  159665,   -2043,  673344, -442767,   75816,
+     755442,  769257, -158730, -410272,  691688,  589550, -878398, -184121,  460679,  346312,
+     294163, -544602,  653308,  254167, -276979,   52073, -892684,  887653,  -41222,  983065,
+     -68258, -408799,  -99069, -674069, -863635,  -32890,  622757, -743862,   40872,   -4837,
+    -967228,  522370, -903951, -818669,  524459,  514702,  925801,   20007, -299229,  579348,
+     626021,  430089,  348139, -562692, -607728, -130606, -928451, -424793, -458647, -448892,
+    -312230,  143337,  109746,  880042, -339658, -785614,  938995,  540916,  118429,  661351,
+    -402967,  404729,  -40918, -976535,  743230,  713110,  440182, -381314, -499252,   74613,
+     193652,  912717,  491323,  583633,  324691,  459397,  281253,  195540,   -2764, -888651,
+     892449,  132663, -478373, -430002, -314551,  527826,  247165,  557966,  554778,  481531,
+    -946634,  431685, -769059, -348371,  174046,  184597, -354867,  584422,  227390, -850397,
+    -542924, -849093, -737769,  325359,  736314,  269101,  767940,  674809,   81413, -447458,
+     445076,  189072,  906218,  502688, -718476, -863827, -731381,  100660,  623249,  710008,
+     572060,  922203,  685740,   55096,  263394, -243695, -353910, -516788,  388471,  455165,
+     844103, -643772,  363976,  268875, -899450,  104470,  104029, -238874, -274659,  732969,
+    -676443,  953291, -916289, -861849, -242344,  958083, -479593, -970395,  799831,  277841,
+    -243236, -283462, -201510,  166263, -259105, -575706,  878926,  891064,  895297,  655262,
+     -34807, -809833,  -89281,  342585,  554920,       1,  902141, -333425,  139703,  852318,
+    -618438,  329498, -932596, -692836, -513372,  733656, -523411,   85779,  500478, -682697,
+    -502836,  138776,  156341, -420037, -557964, -556378,  710993,  -50383, -877159,  916334,
+     132996,  583516, -603392, -111615,  -12288, -780214,  476780,  123327,  137607,  519956,
+     745837,   17358, -158581,  -53490
+};
+static const size_t randvalCount = sizeof(randval) / sizeof(randval[0]);
+static const size_t kItoaTrialCount = 10000;
+
+static const char digits[201] =
+"0001020304050607080910111213141516171819"
+"2021222324252627282930313233343536373839"
+"4041424344454647484950515253545556575859"
+"6061626364656667686970717273747576777879"
+"8081828384858687888990919293949596979899";
+
+// Prevent code being optimized out
+//#define OUTPUT_LENGTH(length) printf("", length)
+#define OUTPUT_LENGTH(length) printf("%u\n", (unsigned)length)
+
+template<typename OutputStream>
+class Writer1 {
+public:
+    Writer1() : os_() {}
+    Writer1(OutputStream& os) : os_(&os) {}
+
+    void Reset(OutputStream& os) {
+        os_ = &os;
+    }
+
+    bool WriteInt(int i) {
+        if (i < 0) {
+            os_->Put('-');
+            i = -i;
+        }
+        return WriteUint((unsigned)i);
+    }
+
+    bool WriteUint(unsigned u) {
+        char buffer[10];
+        char *p = buffer;
+        do {
+            *p++ = char(u % 10) + '0';
+            u /= 10;
+        } while (u > 0);
+
+        do {
+            --p;
+            os_->Put(*p);
+        } while (p != buffer);
+        return true;
+    }
+
+    bool WriteInt64(int64_t i64) {
+        if (i64 < 0) {
+            os_->Put('-');
+            i64 = -i64;
+        }
+        WriteUint64((uint64_t)i64);
+        return true;
+    }
+
+    bool WriteUint64(uint64_t u64) {
+        char buffer[20];
+        char *p = buffer;
+        do {
+            *p++ = char(u64 % 10) + '0';
+            u64 /= 10;
+        } while (u64 > 0);
+
+        do {
+            --p;
+            os_->Put(*p);
+        } while (p != buffer);
+        return true;
+    }
+
+private:
+    OutputStream* os_;
+};
+
+template<>
+bool Writer1<rapidjson::StringBuffer>::WriteUint(unsigned u) {
+    char buffer[10];
+    char* p = buffer;
+    do {
+        *p++ = char(u % 10) + '0';
+        u /= 10;
+    } while (u > 0);
+
+    char* d = os_->Push(p - buffer);
+    do {
+        --p;
+        *d++ = *p;
+    } while (p != buffer);
+    return true;
+}
+
+// Using digits LUT to reduce divsion/modulo
+template<typename OutputStream>
+class Writer2 {
+public:
+    Writer2() : os_() {}
+    Writer2(OutputStream& os) : os_(&os) {}
+
+    void Reset(OutputStream& os) {
+        os_ = &os;
+    }
+
+    bool WriteInt(int i) {
+        if (i < 0) {
+            os_->Put('-');
+            i = -i;
+        }
+        return WriteUint((unsigned)i);
+    }
+
+    bool WriteUint(unsigned u) {
+        char buffer[10];
+        char* p = buffer;
+        while (u >= 100) {
+            const unsigned i = (u % 100) << 1;
+            u /= 100;
+            *p++ = digits[i + 1];
+            *p++ = digits[i];
+        }
+        if (u < 10)
+            *p++ = char(u) + '0';
+        else {
+            const unsigned i = u << 1;
+            *p++ = digits[i + 1];
+            *p++ = digits[i];
+        }
+
+        do {
+            --p;
+            os_->Put(*p);
+        } while (p != buffer);
+        return true;
+    }
+
+    bool WriteInt64(int64_t i64) {
+        if (i64 < 0) {
+            os_->Put('-');
+            i64 = -i64;
+        }
+        WriteUint64((uint64_t)i64);
+        return true;
+    }
+
+    bool WriteUint64(uint64_t u64) {
+        char buffer[20];
+        char* p = buffer;
+        while (u64 >= 100) {
+            const unsigned i = static_cast<unsigned>(u64 % 100) << 1;
+            u64 /= 100;
+            *p++ = digits[i + 1];
+            *p++ = digits[i];
+        }
+        if (u64 < 10)
+            *p++ = char(u64) + '0';
+        else {
+            const unsigned i = static_cast<unsigned>(u64) << 1;
+            *p++ = digits[i + 1];
+            *p++ = digits[i];
+        }
+
+        do {
+            --p;
+            os_->Put(*p);
+        } while (p != buffer);
+        return true;
+    }
+
+private:
+    OutputStream* os_;
+};
+
+// First pass to count digits
+template<typename OutputStream>
+class Writer3 {
+public:
+    Writer3() : os_() {}
+    Writer3(OutputStream& os) : os_(&os) {}
+
+    void Reset(OutputStream& os) {
+        os_ = &os;
+    }
+
+    bool WriteInt(int i) {
+        if (i < 0) {
+            os_->Put('-');
+            i = -i;
+        }
+        return WriteUint((unsigned)i);
+    }
+
+    bool WriteUint(unsigned u) {
+        char buffer[10];
+        char *p = buffer;
+        do {
+            *p++ = char(u % 10) + '0';
+            u /= 10;
+        } while (u > 0);
+
+        do {
+            --p;
+            os_->Put(*p);
+        } while (p != buffer);
+        return true;
+    }
+
+    bool WriteInt64(int64_t i64) {
+        if (i64 < 0) {
+            os_->Put('-');
+            i64 = -i64;
+        }
+        WriteUint64((uint64_t)i64);
+        return true;
+    }
+
+    bool WriteUint64(uint64_t u64) {
+        char buffer[20];
+        char *p = buffer;
+        do {
+            *p++ = char(u64 % 10) + '0';
+            u64 /= 10;
+        } while (u64 > 0);
+
+        do {
+            --p;
+            os_->Put(*p);
+        } while (p != buffer);
+        return true;
+    }
+
+private:
+    void WriteUintReverse(char* d, unsigned u) {
+        do {
+            *--d = char(u % 10) + '0';
+            u /= 10;
+        } while (u > 0);
+    }
+
+    void WriteUint64Reverse(char* d, uint64_t u) {
+        do {
+            *--d = char(u % 10) + '0';
+            u /= 10;
+        } while (u > 0);
+    }
+
+    OutputStream* os_;
+};
+
+template<>
+inline bool Writer3<rapidjson::StringBuffer>::WriteUint(unsigned u) {
+    unsigned digit = CountDecimalDigit_fast(u);
+    WriteUintReverse(os_->Push(digit) + digit, u);
+    return true;
+}
+
+template<>
+inline bool Writer3<rapidjson::InsituStringStream>::WriteUint(unsigned u) {
+    unsigned digit = CountDecimalDigit_fast(u);
+    WriteUintReverse(os_->Push(digit) + digit, u);
+    return true;
+}
+
+template<>
+inline bool Writer3<rapidjson::StringBuffer>::WriteUint64(uint64_t u) {
+    unsigned digit = CountDecimalDigit64_fast(u);
+    WriteUint64Reverse(os_->Push(digit) + digit, u);
+    return true;
+}
+
+template<>
+inline bool Writer3<rapidjson::InsituStringStream>::WriteUint64(uint64_t u) {
+    unsigned digit = CountDecimalDigit64_fast(u);
+    WriteUint64Reverse(os_->Push(digit) + digit, u);
+    return true;
+}
+
+// Using digits LUT to reduce divsion/modulo, two passes
+template<typename OutputStream>
+class Writer4 {
+public:
+    Writer4() : os_() {}
+    Writer4(OutputStream& os) : os_(&os) {}
+
+    void Reset(OutputStream& os) {
+        os_ = &os;
+    }
+
+    bool WriteInt(int i) {
+        if (i < 0) {
+            os_->Put('-');
+            i = -i;
+        }
+        return WriteUint((unsigned)i);
+    }
+
+    bool WriteUint(unsigned u) {
+        char buffer[10];
+        char* p = buffer;
+        while (u >= 100) {
+            const unsigned i = (u % 100) << 1;
+            u /= 100;
+            *p++ = digits[i + 1];
+            *p++ = digits[i];
+        }
+        if (u < 10)
+            *p++ = char(u) + '0';
+        else {
+            const unsigned i = u << 1;
+            *p++ = digits[i + 1];
+            *p++ = digits[i];
+        }
+
+        do {
+            --p;
+            os_->Put(*p);
+        } while (p != buffer);
+        return true;
+    }
+
+    bool WriteInt64(int64_t i64) {
+        if (i64 < 0) {
+            os_->Put('-');
+            i64 = -i64;
+        }
+        WriteUint64((uint64_t)i64);
+        return true;
+    }
+
+    bool WriteUint64(uint64_t u64) {
+        char buffer[20];
+        char* p = buffer;
+        while (u64 >= 100) {
+            const unsigned i = static_cast<unsigned>(u64 % 100) << 1;
+            u64 /= 100;
+            *p++ = digits[i + 1];
+            *p++ = digits[i];
+        }
+        if (u64 < 10)
+            *p++ = char(u64) + '0';
+        else {
+            const unsigned i = static_cast<unsigned>(u64) << 1;
+            *p++ = digits[i + 1];
+            *p++ = digits[i];
+        }
+
+        do {
+            --p;
+            os_->Put(*p);
+        } while (p != buffer);
+        return true;
+    }
+
+private:
+    void WriteUintReverse(char* d, unsigned u) {
+        while (u >= 100) {
+            const unsigned i = (u % 100) << 1;
+            u /= 100;
+            *--d = digits[i + 1];
+            *--d = digits[i];
+        }
+        if (u < 10) {
+            *--d = char(u) + '0';
+        }
+        else {
+            const unsigned i = u << 1;
+            *--d = digits[i + 1];
+            *--d = digits[i];
+        }
+    }
+
+    void WriteUint64Reverse(char* d, uint64_t u) {
+        while (u >= 100) {
+            const unsigned i = (u % 100) << 1;
+            u /= 100;
+            *--d = digits[i + 1];
+            *--d = digits[i];
+        }
+        if (u < 10) {
+            *--d = char(u) + '0';
+        }
+        else {
+            const unsigned i = u << 1;
+            *--d = digits[i + 1];
+            *--d = digits[i];
+        }
+    }
+
+    OutputStream* os_;
+};
+
+template<>
+inline bool Writer4<rapidjson::StringBuffer>::WriteUint(unsigned u) {
+    unsigned digit = CountDecimalDigit_fast(u);
+    WriteUintReverse(os_->Push(digit) + digit, u);
+    return true;
+}
+
+template<>
+inline bool Writer4<rapidjson::InsituStringStream>::WriteUint(unsigned u) {
+    unsigned digit = CountDecimalDigit_fast(u);
+    WriteUintReverse(os_->Push(digit) + digit, u);
+    return true;
+}
+
+template<>
+inline bool Writer4<rapidjson::StringBuffer>::WriteUint64(uint64_t u) {
+    unsigned digit = CountDecimalDigit64_fast(u);
+    WriteUint64Reverse(os_->Push(digit) + digit, u);
+    return true;
+}
+
+template<>
+inline bool Writer4<rapidjson::InsituStringStream>::WriteUint64(uint64_t u) {
+    unsigned digit = CountDecimalDigit64_fast(u);
+    WriteUint64Reverse(os_->Push(digit) + digit, u);
+    return true;
+}
+
+template <typename Writer>
+void itoa_Writer_StringBufferVerify() {
+    rapidjson::StringBuffer sb;
+    Writer writer(sb);
+    for (size_t j = 0; j < randvalCount; j++) {
+        char buffer[32];
+        sprintf(buffer, "%d", randval[j]);
+        writer.WriteInt(randval[j]);
+        ASSERT_STREQ(buffer, sb.GetString());
+        sb.Clear();
+    }
+}
+
+template <typename Writer>
+void itoa_Writer_InsituStringStreamVerify() {
+    Writer writer;
+    for (size_t j = 0; j < randvalCount; j++) {
+        char buffer[32];
+        sprintf(buffer, "%d", randval[j]);
+        char buffer2[32];
+        rapidjson::InsituStringStream ss(buffer2);
+        writer.Reset(ss);
+        char* begin = ss.PutBegin();
+        writer.WriteInt(randval[j]);
+        ss.Put('\0');
+        ss.PutEnd(begin);
+        ASSERT_STREQ(buffer, buffer2);
+    }
+}
+
+template <typename Writer>
+void itoa_Writer_StringBuffer() {
+    size_t length = 0;
+
+    rapidjson::StringBuffer sb;
+    Writer writer(sb);
+
+    for (size_t i = 0; i < kItoaTrialCount; i++) {
+        for (size_t j = 0; j < randvalCount; j++) {
+            writer.WriteInt(randval[j]);
+            length += sb.GetSize();
+            sb.Clear();
+        }
+    }
+    OUTPUT_LENGTH(length);
+}
+
+template <typename Writer>
+void itoa_Writer_InsituStringStream() {
+    size_t length = 0;
+
+    char buffer[32];
+    Writer writer;
+    for (size_t i = 0; i < kItoaTrialCount; i++) {
+        for (size_t j = 0; j < randvalCount; j++) {
+            rapidjson::InsituStringStream ss(buffer);
+            writer.Reset(ss);
+            char* begin = ss.PutBegin();
+            writer.WriteInt(randval[j]);
+            length += ss.PutEnd(begin);
+        }
+    }
+    OUTPUT_LENGTH(length);
+};
+
+template <typename Writer>
+void itoa64_Writer_StringBufferVerify() {
+    rapidjson::StringBuffer sb;
+    Writer writer(sb);
+    for (size_t j = 0; j < randvalCount; j++) {
+        char buffer[32];
+        int64_t x = randval[j] * randval[j];
+        sprintf(buffer, "%" PRIi64, x);
+        writer.WriteInt64(x);
+        ASSERT_STREQ(buffer, sb.GetString());
+        sb.Clear();
+    }
+}
+
+template <typename Writer>
+void itoa64_Writer_InsituStringStreamVerify() {
+    Writer writer;
+    for (size_t j = 0; j < randvalCount; j++) {
+        char buffer[32];
+        int64_t x = randval[j] * randval[j];
+        sprintf(buffer, "%" PRIi64, x);
+        char buffer2[32];
+        rapidjson::InsituStringStream ss(buffer2);
+        writer.Reset(ss);
+        char* begin = ss.PutBegin();
+        writer.WriteInt64(x);
+        ss.Put('\0');
+        ss.PutEnd(begin);
+        ASSERT_STREQ(buffer, buffer2);
+    }
+}
+
+template <typename Writer>
+void itoa64_Writer_StringBuffer() {
+    size_t length = 0;
+
+    rapidjson::StringBuffer sb;
+    Writer writer(sb);
+
+    for (size_t i = 0; i < kItoaTrialCount; i++) {
+        for (size_t j = 0; j < randvalCount; j++) {
+            writer.WriteInt64(randval[j] * randval[j]);
+            length += sb.GetSize();
+            sb.Clear();
+        }
+    }
+    OUTPUT_LENGTH(length);
+}
+
+template <typename Writer>
+void itoa64_Writer_InsituStringStream() {
+    size_t length = 0;
+
+    char buffer[32];
+    Writer writer;
+    for (size_t i = 0; i < kItoaTrialCount; i++) {
+        for (size_t j = 0; j < randvalCount; j++) {
+            rapidjson::InsituStringStream ss(buffer);
+            writer.Reset(ss);
+            char* begin = ss.PutBegin();
+            writer.WriteInt64(randval[j] * randval[j]);
+            length += ss.PutEnd(begin);
+        }
+    }
+    OUTPUT_LENGTH(length);
+};
+
+// Full specialization for InsituStringStream to prevent memory copying 
+// (normally we will not use InsituStringStream for writing, just for testing)
+
+namespace rapidjson {
+
+template<>
+bool rapidjson::Writer<InsituStringStream>::WriteInt(int i) {
+    char *buffer = os_->Push(11);
+    const char* end = internal::i32toa(i, buffer);
+    os_->Pop(11 - (end - buffer));
+    return true;
+}
+
+template<>
+bool Writer<InsituStringStream>::WriteUint(unsigned u) {
+    char *buffer = os_->Push(10);
+    const char* end = internal::u32toa(u, buffer);
+    os_->Pop(10 - (end - buffer));
+    return true;
+}
+
+template<>
+bool Writer<InsituStringStream>::WriteInt64(int64_t i64) {
+    char *buffer = os_->Push(21);
+    const char* end = internal::i64toa(i64, buffer);
+    os_->Pop(21 - (end - buffer));
+    return true;
+}
+
+template<>
+bool Writer<InsituStringStream>::WriteUint64(uint64_t u) {
+    char *buffer = os_->Push(20);
+    const char* end = internal::u64toa(u, buffer);
+    os_->Pop(20 - (end - buffer));
+    return true;
+}
+
+} // namespace rapidjson
+
+TEST_F(Misc, itoa_Writer_StringBufferVerify) { itoa_Writer_StringBufferVerify<rapidjson::Writer<rapidjson::StringBuffer> >(); }
+TEST_F(Misc, itoa_Writer1_StringBufferVerify) { itoa_Writer_StringBufferVerify<Writer1<rapidjson::StringBuffer> >(); }
+TEST_F(Misc, itoa_Writer2_StringBufferVerify) { itoa_Writer_StringBufferVerify<Writer2<rapidjson::StringBuffer> >(); }
+TEST_F(Misc, itoa_Writer3_StringBufferVerify) { itoa_Writer_StringBufferVerify<Writer3<rapidjson::StringBuffer> >(); }
+TEST_F(Misc, itoa_Writer4_StringBufferVerify) { itoa_Writer_StringBufferVerify<Writer4<rapidjson::StringBuffer> >(); }
+TEST_F(Misc, itoa_Writer_InsituStringStreamVerify) { itoa_Writer_InsituStringStreamVerify<rapidjson::Writer<rapidjson::InsituStringStream> >(); }
+TEST_F(Misc, itoa_Writer1_InsituStringStreamVerify) { itoa_Writer_InsituStringStreamVerify<Writer1<rapidjson::InsituStringStream> >(); }
+TEST_F(Misc, itoa_Writer2_InsituStringStreamVerify) { itoa_Writer_InsituStringStreamVerify<Writer2<rapidjson::InsituStringStream> >(); }
+TEST_F(Misc, itoa_Writer3_InsituStringStreamVerify) { itoa_Writer_InsituStringStreamVerify<Writer3<rapidjson::InsituStringStream> >(); }
+TEST_F(Misc, itoa_Writer4_InsituStringStreamVerify) { itoa_Writer_InsituStringStreamVerify<Writer4<rapidjson::InsituStringStream> >(); }
+TEST_F(Misc, itoa_Writer_StringBuffer) { itoa_Writer_StringBuffer<rapidjson::Writer<rapidjson::StringBuffer> >(); }
+TEST_F(Misc, itoa_Writer1_StringBuffer) { itoa_Writer_StringBuffer<Writer1<rapidjson::StringBuffer> >(); }
+TEST_F(Misc, itoa_Writer2_StringBuffer) { itoa_Writer_StringBuffer<Writer2<rapidjson::StringBuffer> >(); }
+TEST_F(Misc, itoa_Writer3_StringBuffer) { itoa_Writer_StringBuffer<Writer3<rapidjson::StringBuffer> >(); }
+TEST_F(Misc, itoa_Writer4_StringBuffer) { itoa_Writer_StringBuffer<Writer4<rapidjson::StringBuffer> >(); }
+TEST_F(Misc, itoa_Writer_InsituStringStream) { itoa_Writer_InsituStringStream<rapidjson::Writer<rapidjson::InsituStringStream> >(); }
+TEST_F(Misc, itoa_Writer1_InsituStringStream) { itoa_Writer_InsituStringStream<Writer1<rapidjson::InsituStringStream> >(); }
+TEST_F(Misc, itoa_Writer2_InsituStringStream) { itoa_Writer_InsituStringStream<Writer2<rapidjson::InsituStringStream> >(); }
+TEST_F(Misc, itoa_Writer3_InsituStringStream) { itoa_Writer_InsituStringStream<Writer3<rapidjson::InsituStringStream> >(); }
+TEST_F(Misc, itoa_Writer4_InsituStringStream) { itoa_Writer_InsituStringStream<Writer4<rapidjson::InsituStringStream> >(); }
+
+TEST_F(Misc, itoa64_Writer_StringBufferVerify) { itoa64_Writer_StringBufferVerify<rapidjson::Writer<rapidjson::StringBuffer> >(); }
+TEST_F(Misc, itoa64_Writer1_StringBufferVerify) { itoa64_Writer_StringBufferVerify<Writer1<rapidjson::StringBuffer> >(); }
+TEST_F(Misc, itoa64_Writer2_StringBufferVerify) { itoa64_Writer_StringBufferVerify<Writer2<rapidjson::StringBuffer> >(); }
+TEST_F(Misc, itoa64_Writer3_StringBufferVerify) { itoa64_Writer_StringBufferVerify<Writer3<rapidjson::StringBuffer> >(); }
+TEST_F(Misc, itoa64_Writer4_StringBufferVerify) { itoa64_Writer_StringBufferVerify<Writer4<rapidjson::StringBuffer> >(); }
+TEST_F(Misc, itoa64_Writer_InsituStringStreamVerify) { itoa64_Writer_InsituStringStreamVerify<rapidjson::Writer<rapidjson::InsituStringStream> >(); }
+TEST_F(Misc, itoa64_Writer1_InsituStringStreamVerify) { itoa64_Writer_InsituStringStreamVerify<Writer1<rapidjson::InsituStringStream> >(); }
+TEST_F(Misc, itoa64_Writer2_InsituStringStreamVerify) { itoa64_Writer_InsituStringStreamVerify<Writer2<rapidjson::InsituStringStream> >(); }
+TEST_F(Misc, itoa64_Writer3_InsituStringStreamVerify) { itoa64_Writer_InsituStringStreamVerify<Writer3<rapidjson::InsituStringStream> >(); }
+TEST_F(Misc, itoa64_Writer4_InsituStringStreamVerify) { itoa64_Writer_InsituStringStreamVerify<Writer4<rapidjson::InsituStringStream> >(); }
+TEST_F(Misc, itoa64_Writer_StringBuffer) { itoa64_Writer_StringBuffer<rapidjson::Writer<rapidjson::StringBuffer> >(); }
+TEST_F(Misc, itoa64_Writer1_StringBuffer) { itoa64_Writer_StringBuffer<Writer1<rapidjson::StringBuffer> >(); }
+TEST_F(Misc, itoa64_Writer2_StringBuffer) { itoa64_Writer_StringBuffer<Writer2<rapidjson::StringBuffer> >(); }
+TEST_F(Misc, itoa64_Writer3_StringBuffer) { itoa64_Writer_StringBuffer<Writer3<rapidjson::StringBuffer> >(); }
+TEST_F(Misc, itoa64_Writer4_StringBuffer) { itoa64_Writer_StringBuffer<Writer4<rapidjson::StringBuffer> >(); }
+TEST_F(Misc, itoa64_Writer_InsituStringStream) { itoa64_Writer_InsituStringStream<rapidjson::Writer<rapidjson::InsituStringStream> >(); }
+TEST_F(Misc, itoa64_Writer1_InsituStringStream) { itoa64_Writer_InsituStringStream<Writer1<rapidjson::InsituStringStream> >(); }
+TEST_F(Misc, itoa64_Writer2_InsituStringStream) { itoa64_Writer_InsituStringStream<Writer2<rapidjson::InsituStringStream> >(); }
+TEST_F(Misc, itoa64_Writer3_InsituStringStream) { itoa64_Writer_InsituStringStream<Writer3<rapidjson::InsituStringStream> >(); }
+TEST_F(Misc, itoa64_Writer4_InsituStringStream) { itoa64_Writer_InsituStringStream<Writer4<rapidjson::InsituStringStream> >(); }
+
+#endif // TEST_MISC