]>
Commit | Line | Data |
---|---|---|
31f18b77 FG |
1 | // Tencent is pleased to support the open source community by making RapidJSON available. |
2 | // | |
1e59de90 | 3 | // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. |
31f18b77 FG |
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 "perftest.h" | |
16 | ||
17 | #if TEST_MISC | |
18 | ||
19 | #define __STDC_FORMAT_MACROS | |
20 | #include "rapidjson/stringbuffer.h" | |
21 | ||
22 | #define protected public | |
23 | #include "rapidjson/writer.h" | |
24 | #undef private | |
25 | ||
26 | class Misc : public PerfTest { | |
27 | }; | |
28 | ||
29 | // Copyright (c) 2008-2010 Bjoern Hoehrmann <bjoern@hoehrmann.de> | |
30 | // See http://bjoern.hoehrmann.de/utf-8/decoder/dfa/ for details. | |
31 | ||
32 | #define UTF8_ACCEPT 0 | |
33 | #define UTF8_REJECT 12 | |
34 | ||
35 | static const unsigned char utf8d[] = { | |
36 | // The first part of the table maps bytes to character classes that | |
37 | // to reduce the size of the transition table and create bitmasks. | |
38 | 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, | |
39 | 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, | |
40 | 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, | |
41 | 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, | |
42 | 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, | |
43 | 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, | |
44 | 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, | |
45 | 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, | |
46 | ||
47 | // The second part is a transition table that maps a combination | |
48 | // of a state of the automaton and a character class to a state. | |
49 | 0,12,24,36,60,96,84,12,12,12,48,72, 12,12,12,12,12,12,12,12,12,12,12,12, | |
50 | 12, 0,12,12,12,12,12, 0,12, 0,12,12, 12,24,12,12,12,12,12,24,12,24,12,12, | |
51 | 12,12,12,12,12,12,12,24,12,12,12,12, 12,24,12,12,12,12,12,12,12,24,12,12, | |
52 | 12,12,12,12,12,12,12,36,12,36,12,12, 12,36,12,12,12,12,12,36,12,36,12,12, | |
53 | 12,36,12,12,12,12,12,12,12,12,12,12, | |
54 | }; | |
55 | ||
56 | static unsigned inline decode(unsigned* state, unsigned* codep, unsigned byte) { | |
57 | unsigned type = utf8d[byte]; | |
58 | ||
59 | *codep = (*state != UTF8_ACCEPT) ? | |
60 | (byte & 0x3fu) | (*codep << 6) : | |
61 | (0xff >> type) & (byte); | |
62 | ||
63 | *state = utf8d[256 + *state + type]; | |
64 | return *state; | |
65 | } | |
66 | ||
67 | static bool IsUTF8(unsigned char* s) { | |
68 | unsigned codepoint, state = 0; | |
69 | ||
70 | while (*s) | |
71 | decode(&state, &codepoint, *s++); | |
72 | ||
73 | return state == UTF8_ACCEPT; | |
74 | } | |
75 | ||
76 | TEST_F(Misc, Hoehrmann_IsUTF8) { | |
77 | for (size_t i = 0; i < kTrialCount; i++) { | |
78 | EXPECT_TRUE(IsUTF8((unsigned char*)json_)); | |
79 | } | |
80 | } | |
81 | ||
82 | //////////////////////////////////////////////////////////////////////////////// | |
83 | // CountDecimalDigit: Count number of decimal places | |
84 | ||
85 | inline unsigned CountDecimalDigit_naive(unsigned n) { | |
86 | unsigned count = 1; | |
87 | while (n >= 10) { | |
88 | n /= 10; | |
89 | count++; | |
90 | } | |
91 | return count; | |
92 | } | |
93 | ||
94 | inline unsigned CountDecimalDigit_enroll4(unsigned n) { | |
95 | unsigned count = 1; | |
96 | while (n >= 10000) { | |
97 | n /= 10000u; | |
98 | count += 4; | |
99 | } | |
100 | if (n < 10) return count; | |
101 | if (n < 100) return count + 1; | |
102 | if (n < 1000) return count + 2; | |
103 | return count + 3; | |
104 | } | |
105 | ||
106 | inline unsigned CountDecimalDigit64_enroll4(uint64_t n) { | |
107 | unsigned count = 1; | |
108 | while (n >= 10000) { | |
109 | n /= 10000u; | |
110 | count += 4; | |
111 | } | |
112 | if (n < 10) return count; | |
113 | if (n < 100) return count + 1; | |
114 | if (n < 1000) return count + 2; | |
115 | return count + 3; | |
116 | } | |
117 | ||
118 | inline unsigned CountDecimalDigit_fast(unsigned n) { | |
119 | static const uint32_t powers_of_10[] = { | |
120 | 0, | |
121 | 10, | |
122 | 100, | |
123 | 1000, | |
124 | 10000, | |
125 | 100000, | |
126 | 1000000, | |
127 | 10000000, | |
128 | 100000000, | |
129 | 1000000000 | |
130 | }; | |
131 | ||
132 | #if defined(_M_IX86) || defined(_M_X64) | |
133 | unsigned long i = 0; | |
134 | _BitScanReverse(&i, n | 1); | |
135 | uint32_t t = (i + 1) * 1233 >> 12; | |
136 | #elif defined(__GNUC__) | |
137 | uint32_t t = (32 - __builtin_clz(n | 1)) * 1233 >> 12; | |
138 | #else | |
139 | #error | |
140 | #endif | |
141 | return t - (n < powers_of_10[t]) + 1; | |
142 | } | |
143 | ||
144 | inline unsigned CountDecimalDigit64_fast(uint64_t n) { | |
145 | static const uint64_t powers_of_10[] = { | |
146 | 0, | |
147 | 10, | |
148 | 100, | |
149 | 1000, | |
150 | 10000, | |
151 | 100000, | |
152 | 1000000, | |
153 | 10000000, | |
154 | 100000000, | |
155 | 1000000000, | |
156 | 10000000000, | |
157 | 100000000000, | |
158 | 1000000000000, | |
159 | 10000000000000, | |
160 | 100000000000000, | |
161 | 1000000000000000, | |
162 | 10000000000000000, | |
163 | 100000000000000000, | |
164 | 1000000000000000000, | |
165 | 10000000000000000000U | |
166 | }; | |
167 | ||
168 | #if defined(_M_IX86) | |
169 | uint64_t m = n | 1; | |
170 | unsigned long i = 0; | |
171 | if (_BitScanReverse(&i, m >> 32)) | |
172 | i += 32; | |
173 | else | |
174 | _BitScanReverse(&i, m & 0xFFFFFFFF); | |
175 | uint32_t t = (i + 1) * 1233 >> 12; | |
176 | #elif defined(_M_X64) | |
177 | unsigned long i = 0; | |
178 | _BitScanReverse64(&i, n | 1); | |
179 | uint32_t t = (i + 1) * 1233 >> 12; | |
180 | #elif defined(__GNUC__) | |
181 | uint32_t t = (64 - __builtin_clzll(n | 1)) * 1233 >> 12; | |
182 | #else | |
183 | #error | |
184 | #endif | |
185 | ||
186 | return t - (n < powers_of_10[t]) + 1; | |
187 | } | |
188 | ||
189 | #if 0 | |
190 | // Exhaustive, very slow | |
191 | TEST_F(Misc, CountDecimalDigit_Verify) { | |
192 | unsigned i = 0; | |
193 | do { | |
194 | if (i % (65536 * 256) == 0) | |
195 | printf("%u\n", i); | |
196 | ASSERT_EQ(CountDecimalDigit_enroll4(i), CountDecimalDigit_fast(i)); | |
197 | i++; | |
198 | } while (i != 0); | |
199 | } | |
200 | ||
201 | static const unsigned kDigits10Trial = 1000000000u; | |
202 | TEST_F(Misc, CountDecimalDigit_naive) { | |
203 | unsigned sum = 0; | |
204 | for (unsigned i = 0; i < kDigits10Trial; i++) | |
205 | sum += CountDecimalDigit_naive(i); | |
206 | printf("%u\n", sum); | |
207 | } | |
208 | ||
209 | TEST_F(Misc, CountDecimalDigit_enroll4) { | |
210 | unsigned sum = 0; | |
211 | for (unsigned i = 0; i < kDigits10Trial; i++) | |
212 | sum += CountDecimalDigit_enroll4(i); | |
213 | printf("%u\n", sum); | |
214 | } | |
215 | ||
216 | TEST_F(Misc, CountDecimalDigit_fast) { | |
217 | unsigned sum = 0; | |
218 | for (unsigned i = 0; i < kDigits10Trial; i++) | |
219 | sum += CountDecimalDigit_fast(i); | |
220 | printf("%u\n", sum); | |
221 | } | |
222 | #endif | |
223 | ||
224 | TEST_F(Misc, CountDecimalDigit64_VerifyFast) { | |
225 | uint64_t i = 1, j; | |
226 | do { | |
227 | //printf("%" PRIu64 "\n", i); | |
228 | ASSERT_EQ(CountDecimalDigit64_enroll4(i), CountDecimalDigit64_fast(i)); | |
229 | j = i; | |
230 | i *= 3; | |
231 | } while (j < i); | |
232 | } | |
233 | ||
234 | //////////////////////////////////////////////////////////////////////////////// | |
235 | // integer-to-string conversion | |
236 | ||
237 | // https://gist.github.com/anonymous/7179097 | |
238 | static const int randval[] ={ | |
239 | 936116, 369532, 453755, -72860, 209713, 268347, 435278, -360266, -416287, -182064, | |
240 | -644712, 944969, 640463, -366588, 471577, -69401, -744294, -505829, 923883, 831785, | |
241 | -601136, -636767, -437054, 591718, 100758, 231907, -719038, 973540, -605220, 506659, | |
242 | -871653, 462533, 764843, -919138, 404305, -630931, -288711, -751454, -173726, -718208, | |
243 | 432689, -281157, 360737, 659827, 19174, -376450, 769984, -858198, 439127, 734703, | |
244 | -683426, 7, 386135, 186997, -643900, -744422, -604708, -629545, 42313, -933592, | |
245 | -635566, 182308, 439024, -367219, -73924, -516649, 421935, -470515, 413507, -78952, | |
246 | -427917, -561158, 737176, 94538, 572322, 405217, 709266, -357278, -908099, -425447, | |
247 | 601119, 750712, -862285, -177869, 900102, 384877, 157859, -641680, 503738, -702558, | |
248 | 278225, 463290, 268378, -212840, 580090, 347346, -473985, -950968, -114547, -839893, | |
249 | -738032, -789424, 409540, 493495, 432099, 119755, 905004, -174834, 338266, 234298, | |
250 | 74641, -965136, -754593, 685273, 466924, 920560, 385062, 796402, -67229, 994864, | |
251 | 376974, 299869, -647540, -128724, 469890, -163167, -547803, -743363, 486463, -621028, | |
252 | 612288, 27459, -514224, 126342, -66612, 803409, -777155, -336453, -284002, 472451, | |
253 | 342390, -163630, 908356, -456147, -825607, 268092, -974715, 287227, 227890, -524101, | |
254 | 616370, -782456, 922098, -624001, -813690, 171605, -192962, 796151, 707183, -95696, | |
255 | -23163, -721260, 508892, 430715, 791331, 482048, -996102, 863274, 275406, -8279, | |
256 | -556239, -902076, 268647, -818565, 260069, -798232, -172924, -566311, -806503, -885992, | |
257 | 813969, -78468, 956632, 304288, 494867, -508784, 381751, 151264, 762953, 76352, | |
258 | 594902, 375424, 271700, -743062, 390176, 924237, 772574, 676610, 435752, -153847, | |
259 | 3959, -971937, -294181, -538049, -344620, -170136, 19120, -703157, 868152, -657961, | |
260 | -818631, 219015, -872729, -940001, -956570, 880727, -345910, 942913, -942271, -788115, | |
261 | 225294, 701108, -517736, -416071, 281940, 488730, 942698, 711494, 838382, -892302, | |
262 | -533028, 103052, 528823, 901515, 949577, 159364, 718227, -241814, -733661, -462928, | |
263 | -495829, 165170, 513580, -629188, -509571, -459083, 198437, 77198, -644612, 811276, | |
264 | -422298, -860842, -52584, 920369, 686424, -530667, -243476, 49763, 345866, -411960, | |
265 | -114863, 470810, -302860, 683007, -509080, 2, -174981, -772163, -48697, 447770, | |
266 | -268246, 213268, 269215, 78810, -236340, -639140, -864323, 505113, -986569, -325215, | |
267 | 541859, 163070, -819998, -645161, -583336, 573414, 696417, -132375, 3, -294501, | |
268 | 320435, 682591, 840008, 351740, 426951, 609354, 898154, -943254, 227321, -859793, | |
269 | -727993, 44137, -497965, -782239, 14955, -746080, -243366, 9837, -233083, 606507, | |
270 | -995864, -615287, -994307, 602715, 770771, -315040, 610860, 446102, -307120, 710728, | |
271 | -590392, -230474, -762625, -637525, 134963, -202700, -766902, -985541, 218163, 682009, | |
272 | 926051, 525156, -61195, 403211, -810098, 245539, -431733, 179998, -806533, 745943, | |
273 | 447597, 131973, -187130, 826019, 286107, -937230, -577419, 20254, 681802, -340500, | |
274 | 323080, 266283, -667617, 309656, 416386, 611863, 759991, -534257, 523112, -634892, | |
275 | -169913, -204905, -909867, -882185, -944908, 741811, -717675, 967007, -317396, 407230, | |
276 | -412805, 792905, 994873, 744793, -456797, 713493, 355232, 116900, -945199, 880539, | |
277 | 342505, -580824, -262273, 982968, -349497, -735488, 311767, -455191, 570918, 389734, | |
278 | -958386, 10262, -99267, 155481, 304210, 204724, 704367, -144893, -233664, -671441, | |
279 | 896849, 408613, 762236, 322697, 981321, 688476, 13663, -970704, -379507, 896412, | |
280 | 977084, 348869, 875948, 341348, 318710, 512081, 6163, 669044, 833295, 811883, | |
281 | 708756, -802534, -536057, 608413, -389625, -694603, 541106, -110037, 720322, -540581, | |
282 | 645420, 32980, 62442, 510157, -981870, -87093, -325960, -500494, -718291, -67889, | |
283 | 991501, 374804, 769026, -978869, 294747, 714623, 413327, -199164, 671368, 804789, | |
284 | -362507, 798196, -170790, -568895, -869379, 62020, -316693, -837793, 644994, -39341, | |
285 | -417504, -243068, -957756, 99072, 622234, -739992, 225668, 8863, -505910, 82483, | |
286 | -559244, 241572, 1315, -36175, -54990, 376813, -11, 162647, -688204, -486163, | |
287 | -54934, -197470, 744223, -762707, 732540, 996618, 351561, -445933, -898491, 486531, | |
288 | 456151, 15276, 290186, -817110, -52995, 313046, -452533, -96267, 94470, -500176, | |
289 | -818026, -398071, -810548, -143325, -819741, 1338, -897676, -101577, -855445, 37309, | |
290 | 285742, 953804, -777927, -926962, -811217, -936744, -952245, -802300, -490188, -964953, | |
291 | -552279, 329142, -570048, -505756, 682898, -381089, -14352, 175138, 152390, -582268, | |
292 | -485137, 717035, 805329, 239572, -730409, 209643, -184403, -385864, 675086, 819648, | |
293 | 629058, -527109, -488666, -171981, 532788, 552441, 174666, 984921, 766514, 758787, | |
294 | 716309, 338801, -978004, -412163, 876079, -734212, 789557, -160491, -522719, 56644, | |
295 | -991, -286038, -53983, 663740, 809812, 919889, -717502, -137704, 220511, 184396, | |
296 | -825740, -588447, 430870, 124309, 135956, 558662, -307087, -788055, -451328, 812260, | |
297 | 931601, 324347, -482989, -117858, -278861, 189068, -172774, 929057, 293787, 198161, | |
298 | -342386, -47173, 906555, -759955, -12779, 777604, -97869, 899320, 927486, -25284, | |
299 | -848550, 259450, -485856, -17820, 88, 171400, 235492, -326783, -340793, 886886, | |
300 | 112428, -246280, 5979, 648444, -114982, 991013, -56489, -9497, 419706, 632820, | |
301 | -341664, 393926, -848977, -22538, 257307, 773731, -905319, 491153, 734883, -868212, | |
302 | -951053, 644458, -580758, 764735, 584316, 297077, 28852, -397710, -953669, 201772, | |
303 | 879050, -198237, -588468, 448102, -116837, 770007, -231812, 642906, -582166, -885828, | |
304 | 9, 305082, -996577, 303559, 75008, -772956, -447960, 599825, -295552, 870739, | |
305 | -386278, -950300, 485359, -457081, 629461, -850276, 550496, -451755, -620841, -11766, | |
306 | -950137, 832337, 28711, -273398, -507197, 91921, -271360, -705991, -753220, -388968, | |
307 | 967945, 340434, -320883, -662793, -554617, -574568, 477946, -6148, -129519, 689217, | |
308 | 920020, -656315, -974523, -212525, 80921, -612532, 645096, 545655, 655713, -591631, | |
309 | -307385, -816688, -618823, -113713, 526430, 673063, 735916, -809095, -850417, 639004, | |
310 | 432281, -388185, 270708, 860146, -39902, -786157, -258180, -246169, -966720, -264957, | |
311 | 548072, -306010, -57367, -635665, 933824, 70553, -989936, -488741, 72411, -452509, | |
312 | 529831, 956277, 449019, -577850, -360986, -803418, 48833, 296073, 203430, 609591, | |
313 | 715483, 470964, 658106, -718254, -96424, 790163, 334739, 181070, -373578, 5, | |
314 | -435088, 329841, 330939, -256602, 394355, 912412, 231910, 927278, -661933, 788539, | |
315 | -769664, -893274, -96856, 298205, 901043, -608122, -527430, 183618, -553963, -35246, | |
316 | -393924, 948832, -483198, 594501, 35460, -407007, 93494, -336881, -634072, 984205, | |
317 | -812161, 944664, -31062, 753872, 823933, -69566, 50445, 290147, 85134, 34706, | |
318 | 551902, 405202, -991246, -84642, 154341, 316432, -695101, -651588, -5030, 137564, | |
319 | -294665, 332541, 528307, -90572, -344923, 523766, -758498, -968047, 339028, 494578, | |
320 | 593129, -725773, 31834, -718406, -208638, 159665, -2043, 673344, -442767, 75816, | |
321 | 755442, 769257, -158730, -410272, 691688, 589550, -878398, -184121, 460679, 346312, | |
322 | 294163, -544602, 653308, 254167, -276979, 52073, -892684, 887653, -41222, 983065, | |
323 | -68258, -408799, -99069, -674069, -863635, -32890, 622757, -743862, 40872, -4837, | |
324 | -967228, 522370, -903951, -818669, 524459, 514702, 925801, 20007, -299229, 579348, | |
325 | 626021, 430089, 348139, -562692, -607728, -130606, -928451, -424793, -458647, -448892, | |
326 | -312230, 143337, 109746, 880042, -339658, -785614, 938995, 540916, 118429, 661351, | |
327 | -402967, 404729, -40918, -976535, 743230, 713110, 440182, -381314, -499252, 74613, | |
328 | 193652, 912717, 491323, 583633, 324691, 459397, 281253, 195540, -2764, -888651, | |
329 | 892449, 132663, -478373, -430002, -314551, 527826, 247165, 557966, 554778, 481531, | |
330 | -946634, 431685, -769059, -348371, 174046, 184597, -354867, 584422, 227390, -850397, | |
331 | -542924, -849093, -737769, 325359, 736314, 269101, 767940, 674809, 81413, -447458, | |
332 | 445076, 189072, 906218, 502688, -718476, -863827, -731381, 100660, 623249, 710008, | |
333 | 572060, 922203, 685740, 55096, 263394, -243695, -353910, -516788, 388471, 455165, | |
334 | 844103, -643772, 363976, 268875, -899450, 104470, 104029, -238874, -274659, 732969, | |
335 | -676443, 953291, -916289, -861849, -242344, 958083, -479593, -970395, 799831, 277841, | |
336 | -243236, -283462, -201510, 166263, -259105, -575706, 878926, 891064, 895297, 655262, | |
337 | -34807, -809833, -89281, 342585, 554920, 1, 902141, -333425, 139703, 852318, | |
338 | -618438, 329498, -932596, -692836, -513372, 733656, -523411, 85779, 500478, -682697, | |
339 | -502836, 138776, 156341, -420037, -557964, -556378, 710993, -50383, -877159, 916334, | |
340 | 132996, 583516, -603392, -111615, -12288, -780214, 476780, 123327, 137607, 519956, | |
341 | 745837, 17358, -158581, -53490 | |
342 | }; | |
343 | static const size_t randvalCount = sizeof(randval) / sizeof(randval[0]); | |
344 | static const size_t kItoaTrialCount = 10000; | |
345 | ||
346 | static const char digits[201] = | |
347 | "0001020304050607080910111213141516171819" | |
348 | "2021222324252627282930313233343536373839" | |
349 | "4041424344454647484950515253545556575859" | |
350 | "6061626364656667686970717273747576777879" | |
351 | "8081828384858687888990919293949596979899"; | |
352 | ||
353 | // Prevent code being optimized out | |
354 | //#define OUTPUT_LENGTH(length) printf("", length) | |
355 | #define OUTPUT_LENGTH(length) printf("%u\n", (unsigned)length) | |
356 | ||
357 | template<typename OutputStream> | |
358 | class Writer1 { | |
359 | public: | |
360 | Writer1() : os_() {} | |
361 | Writer1(OutputStream& os) : os_(&os) {} | |
362 | ||
363 | void Reset(OutputStream& os) { | |
364 | os_ = &os; | |
365 | } | |
366 | ||
367 | bool WriteInt(int i) { | |
368 | if (i < 0) { | |
369 | os_->Put('-'); | |
370 | i = -i; | |
371 | } | |
372 | return WriteUint((unsigned)i); | |
373 | } | |
374 | ||
375 | bool WriteUint(unsigned u) { | |
376 | char buffer[10]; | |
377 | char *p = buffer; | |
378 | do { | |
379 | *p++ = char(u % 10) + '0'; | |
380 | u /= 10; | |
381 | } while (u > 0); | |
382 | ||
383 | do { | |
384 | --p; | |
385 | os_->Put(*p); | |
386 | } while (p != buffer); | |
387 | return true; | |
388 | } | |
389 | ||
390 | bool WriteInt64(int64_t i64) { | |
391 | if (i64 < 0) { | |
392 | os_->Put('-'); | |
393 | i64 = -i64; | |
394 | } | |
395 | WriteUint64((uint64_t)i64); | |
396 | return true; | |
397 | } | |
398 | ||
399 | bool WriteUint64(uint64_t u64) { | |
400 | char buffer[20]; | |
401 | char *p = buffer; | |
402 | do { | |
403 | *p++ = char(u64 % 10) + '0'; | |
404 | u64 /= 10; | |
405 | } while (u64 > 0); | |
406 | ||
407 | do { | |
408 | --p; | |
409 | os_->Put(*p); | |
410 | } while (p != buffer); | |
411 | return true; | |
412 | } | |
413 | ||
414 | private: | |
415 | OutputStream* os_; | |
416 | }; | |
417 | ||
418 | template<> | |
419 | bool Writer1<rapidjson::StringBuffer>::WriteUint(unsigned u) { | |
420 | char buffer[10]; | |
421 | char* p = buffer; | |
422 | do { | |
423 | *p++ = char(u % 10) + '0'; | |
424 | u /= 10; | |
425 | } while (u > 0); | |
426 | ||
427 | char* d = os_->Push(p - buffer); | |
428 | do { | |
429 | --p; | |
430 | *d++ = *p; | |
431 | } while (p != buffer); | |
432 | return true; | |
433 | } | |
434 | ||
1e59de90 | 435 | // Using digits LUT to reduce division/modulo |
31f18b77 FG |
436 | template<typename OutputStream> |
437 | class Writer2 { | |
438 | public: | |
439 | Writer2() : os_() {} | |
440 | Writer2(OutputStream& os) : os_(&os) {} | |
441 | ||
442 | void Reset(OutputStream& os) { | |
443 | os_ = &os; | |
444 | } | |
445 | ||
446 | bool WriteInt(int i) { | |
447 | if (i < 0) { | |
448 | os_->Put('-'); | |
449 | i = -i; | |
450 | } | |
451 | return WriteUint((unsigned)i); | |
452 | } | |
453 | ||
454 | bool WriteUint(unsigned u) { | |
455 | char buffer[10]; | |
456 | char* p = buffer; | |
457 | while (u >= 100) { | |
458 | const unsigned i = (u % 100) << 1; | |
459 | u /= 100; | |
460 | *p++ = digits[i + 1]; | |
461 | *p++ = digits[i]; | |
462 | } | |
463 | if (u < 10) | |
464 | *p++ = char(u) + '0'; | |
465 | else { | |
466 | const unsigned i = u << 1; | |
467 | *p++ = digits[i + 1]; | |
468 | *p++ = digits[i]; | |
469 | } | |
470 | ||
471 | do { | |
472 | --p; | |
473 | os_->Put(*p); | |
474 | } while (p != buffer); | |
475 | return true; | |
476 | } | |
477 | ||
478 | bool WriteInt64(int64_t i64) { | |
479 | if (i64 < 0) { | |
480 | os_->Put('-'); | |
481 | i64 = -i64; | |
482 | } | |
483 | WriteUint64((uint64_t)i64); | |
484 | return true; | |
485 | } | |
486 | ||
487 | bool WriteUint64(uint64_t u64) { | |
488 | char buffer[20]; | |
489 | char* p = buffer; | |
490 | while (u64 >= 100) { | |
491 | const unsigned i = static_cast<unsigned>(u64 % 100) << 1; | |
492 | u64 /= 100; | |
493 | *p++ = digits[i + 1]; | |
494 | *p++ = digits[i]; | |
495 | } | |
496 | if (u64 < 10) | |
497 | *p++ = char(u64) + '0'; | |
498 | else { | |
499 | const unsigned i = static_cast<unsigned>(u64) << 1; | |
500 | *p++ = digits[i + 1]; | |
501 | *p++ = digits[i]; | |
502 | } | |
503 | ||
504 | do { | |
505 | --p; | |
506 | os_->Put(*p); | |
507 | } while (p != buffer); | |
508 | return true; | |
509 | } | |
510 | ||
511 | private: | |
512 | OutputStream* os_; | |
513 | }; | |
514 | ||
515 | // First pass to count digits | |
516 | template<typename OutputStream> | |
517 | class Writer3 { | |
518 | public: | |
519 | Writer3() : os_() {} | |
520 | Writer3(OutputStream& os) : os_(&os) {} | |
521 | ||
522 | void Reset(OutputStream& os) { | |
523 | os_ = &os; | |
524 | } | |
525 | ||
526 | bool WriteInt(int i) { | |
527 | if (i < 0) { | |
528 | os_->Put('-'); | |
529 | i = -i; | |
530 | } | |
531 | return WriteUint((unsigned)i); | |
532 | } | |
533 | ||
534 | bool WriteUint(unsigned u) { | |
535 | char buffer[10]; | |
536 | char *p = buffer; | |
537 | do { | |
538 | *p++ = char(u % 10) + '0'; | |
539 | u /= 10; | |
540 | } while (u > 0); | |
541 | ||
542 | do { | |
543 | --p; | |
544 | os_->Put(*p); | |
545 | } while (p != buffer); | |
546 | return true; | |
547 | } | |
548 | ||
549 | bool WriteInt64(int64_t i64) { | |
550 | if (i64 < 0) { | |
551 | os_->Put('-'); | |
552 | i64 = -i64; | |
553 | } | |
554 | WriteUint64((uint64_t)i64); | |
555 | return true; | |
556 | } | |
557 | ||
558 | bool WriteUint64(uint64_t u64) { | |
559 | char buffer[20]; | |
560 | char *p = buffer; | |
561 | do { | |
562 | *p++ = char(u64 % 10) + '0'; | |
563 | u64 /= 10; | |
564 | } while (u64 > 0); | |
565 | ||
566 | do { | |
567 | --p; | |
568 | os_->Put(*p); | |
569 | } while (p != buffer); | |
570 | return true; | |
571 | } | |
572 | ||
573 | private: | |
574 | void WriteUintReverse(char* d, unsigned u) { | |
575 | do { | |
576 | *--d = char(u % 10) + '0'; | |
577 | u /= 10; | |
578 | } while (u > 0); | |
579 | } | |
580 | ||
581 | void WriteUint64Reverse(char* d, uint64_t u) { | |
582 | do { | |
583 | *--d = char(u % 10) + '0'; | |
584 | u /= 10; | |
585 | } while (u > 0); | |
586 | } | |
587 | ||
588 | OutputStream* os_; | |
589 | }; | |
590 | ||
591 | template<> | |
592 | inline bool Writer3<rapidjson::StringBuffer>::WriteUint(unsigned u) { | |
593 | unsigned digit = CountDecimalDigit_fast(u); | |
594 | WriteUintReverse(os_->Push(digit) + digit, u); | |
595 | return true; | |
596 | } | |
597 | ||
598 | template<> | |
599 | inline bool Writer3<rapidjson::InsituStringStream>::WriteUint(unsigned u) { | |
600 | unsigned digit = CountDecimalDigit_fast(u); | |
601 | WriteUintReverse(os_->Push(digit) + digit, u); | |
602 | return true; | |
603 | } | |
604 | ||
605 | template<> | |
606 | inline bool Writer3<rapidjson::StringBuffer>::WriteUint64(uint64_t u) { | |
607 | unsigned digit = CountDecimalDigit64_fast(u); | |
608 | WriteUint64Reverse(os_->Push(digit) + digit, u); | |
609 | return true; | |
610 | } | |
611 | ||
612 | template<> | |
613 | inline bool Writer3<rapidjson::InsituStringStream>::WriteUint64(uint64_t u) { | |
614 | unsigned digit = CountDecimalDigit64_fast(u); | |
615 | WriteUint64Reverse(os_->Push(digit) + digit, u); | |
616 | return true; | |
617 | } | |
618 | ||
1e59de90 | 619 | // Using digits LUT to reduce division/modulo, two passes |
31f18b77 FG |
620 | template<typename OutputStream> |
621 | class Writer4 { | |
622 | public: | |
623 | Writer4() : os_() {} | |
624 | Writer4(OutputStream& os) : os_(&os) {} | |
625 | ||
626 | void Reset(OutputStream& os) { | |
627 | os_ = &os; | |
628 | } | |
629 | ||
630 | bool WriteInt(int i) { | |
631 | if (i < 0) { | |
632 | os_->Put('-'); | |
633 | i = -i; | |
634 | } | |
635 | return WriteUint((unsigned)i); | |
636 | } | |
637 | ||
638 | bool WriteUint(unsigned u) { | |
639 | char buffer[10]; | |
640 | char* p = buffer; | |
641 | while (u >= 100) { | |
642 | const unsigned i = (u % 100) << 1; | |
643 | u /= 100; | |
644 | *p++ = digits[i + 1]; | |
645 | *p++ = digits[i]; | |
646 | } | |
647 | if (u < 10) | |
648 | *p++ = char(u) + '0'; | |
649 | else { | |
650 | const unsigned i = u << 1; | |
651 | *p++ = digits[i + 1]; | |
652 | *p++ = digits[i]; | |
653 | } | |
654 | ||
655 | do { | |
656 | --p; | |
657 | os_->Put(*p); | |
658 | } while (p != buffer); | |
659 | return true; | |
660 | } | |
661 | ||
662 | bool WriteInt64(int64_t i64) { | |
663 | if (i64 < 0) { | |
664 | os_->Put('-'); | |
665 | i64 = -i64; | |
666 | } | |
667 | WriteUint64((uint64_t)i64); | |
668 | return true; | |
669 | } | |
670 | ||
671 | bool WriteUint64(uint64_t u64) { | |
672 | char buffer[20]; | |
673 | char* p = buffer; | |
674 | while (u64 >= 100) { | |
675 | const unsigned i = static_cast<unsigned>(u64 % 100) << 1; | |
676 | u64 /= 100; | |
677 | *p++ = digits[i + 1]; | |
678 | *p++ = digits[i]; | |
679 | } | |
680 | if (u64 < 10) | |
681 | *p++ = char(u64) + '0'; | |
682 | else { | |
683 | const unsigned i = static_cast<unsigned>(u64) << 1; | |
684 | *p++ = digits[i + 1]; | |
685 | *p++ = digits[i]; | |
686 | } | |
687 | ||
688 | do { | |
689 | --p; | |
690 | os_->Put(*p); | |
691 | } while (p != buffer); | |
692 | return true; | |
693 | } | |
694 | ||
695 | private: | |
696 | void WriteUintReverse(char* d, unsigned u) { | |
697 | while (u >= 100) { | |
698 | const unsigned i = (u % 100) << 1; | |
699 | u /= 100; | |
700 | *--d = digits[i + 1]; | |
701 | *--d = digits[i]; | |
702 | } | |
703 | if (u < 10) { | |
704 | *--d = char(u) + '0'; | |
705 | } | |
706 | else { | |
707 | const unsigned i = u << 1; | |
708 | *--d = digits[i + 1]; | |
709 | *--d = digits[i]; | |
710 | } | |
711 | } | |
712 | ||
713 | void WriteUint64Reverse(char* d, uint64_t u) { | |
714 | while (u >= 100) { | |
715 | const unsigned i = (u % 100) << 1; | |
716 | u /= 100; | |
717 | *--d = digits[i + 1]; | |
718 | *--d = digits[i]; | |
719 | } | |
720 | if (u < 10) { | |
721 | *--d = char(u) + '0'; | |
722 | } | |
723 | else { | |
724 | const unsigned i = u << 1; | |
725 | *--d = digits[i + 1]; | |
726 | *--d = digits[i]; | |
727 | } | |
728 | } | |
729 | ||
730 | OutputStream* os_; | |
731 | }; | |
732 | ||
733 | template<> | |
734 | inline bool Writer4<rapidjson::StringBuffer>::WriteUint(unsigned u) { | |
735 | unsigned digit = CountDecimalDigit_fast(u); | |
736 | WriteUintReverse(os_->Push(digit) + digit, u); | |
737 | return true; | |
738 | } | |
739 | ||
740 | template<> | |
741 | inline bool Writer4<rapidjson::InsituStringStream>::WriteUint(unsigned u) { | |
742 | unsigned digit = CountDecimalDigit_fast(u); | |
743 | WriteUintReverse(os_->Push(digit) + digit, u); | |
744 | return true; | |
745 | } | |
746 | ||
747 | template<> | |
748 | inline bool Writer4<rapidjson::StringBuffer>::WriteUint64(uint64_t u) { | |
749 | unsigned digit = CountDecimalDigit64_fast(u); | |
750 | WriteUint64Reverse(os_->Push(digit) + digit, u); | |
751 | return true; | |
752 | } | |
753 | ||
754 | template<> | |
755 | inline bool Writer4<rapidjson::InsituStringStream>::WriteUint64(uint64_t u) { | |
756 | unsigned digit = CountDecimalDigit64_fast(u); | |
757 | WriteUint64Reverse(os_->Push(digit) + digit, u); | |
758 | return true; | |
759 | } | |
760 | ||
761 | template <typename Writer> | |
762 | void itoa_Writer_StringBufferVerify() { | |
763 | rapidjson::StringBuffer sb; | |
764 | Writer writer(sb); | |
765 | for (size_t j = 0; j < randvalCount; j++) { | |
766 | char buffer[32]; | |
767 | sprintf(buffer, "%d", randval[j]); | |
768 | writer.WriteInt(randval[j]); | |
769 | ASSERT_STREQ(buffer, sb.GetString()); | |
770 | sb.Clear(); | |
771 | } | |
772 | } | |
773 | ||
774 | template <typename Writer> | |
775 | void itoa_Writer_InsituStringStreamVerify() { | |
776 | Writer writer; | |
777 | for (size_t j = 0; j < randvalCount; j++) { | |
778 | char buffer[32]; | |
779 | sprintf(buffer, "%d", randval[j]); | |
780 | char buffer2[32]; | |
781 | rapidjson::InsituStringStream ss(buffer2); | |
782 | writer.Reset(ss); | |
783 | char* begin = ss.PutBegin(); | |
784 | writer.WriteInt(randval[j]); | |
785 | ss.Put('\0'); | |
786 | ss.PutEnd(begin); | |
787 | ASSERT_STREQ(buffer, buffer2); | |
788 | } | |
789 | } | |
790 | ||
791 | template <typename Writer> | |
792 | void itoa_Writer_StringBuffer() { | |
793 | size_t length = 0; | |
794 | ||
795 | rapidjson::StringBuffer sb; | |
796 | Writer writer(sb); | |
797 | ||
798 | for (size_t i = 0; i < kItoaTrialCount; i++) { | |
799 | for (size_t j = 0; j < randvalCount; j++) { | |
800 | writer.WriteInt(randval[j]); | |
801 | length += sb.GetSize(); | |
802 | sb.Clear(); | |
803 | } | |
804 | } | |
805 | OUTPUT_LENGTH(length); | |
806 | } | |
807 | ||
808 | template <typename Writer> | |
809 | void itoa_Writer_InsituStringStream() { | |
810 | size_t length = 0; | |
811 | ||
812 | char buffer[32]; | |
813 | Writer writer; | |
814 | for (size_t i = 0; i < kItoaTrialCount; i++) { | |
815 | for (size_t j = 0; j < randvalCount; j++) { | |
816 | rapidjson::InsituStringStream ss(buffer); | |
817 | writer.Reset(ss); | |
818 | char* begin = ss.PutBegin(); | |
819 | writer.WriteInt(randval[j]); | |
820 | length += ss.PutEnd(begin); | |
821 | } | |
822 | } | |
823 | OUTPUT_LENGTH(length); | |
824 | }; | |
825 | ||
826 | template <typename Writer> | |
827 | void itoa64_Writer_StringBufferVerify() { | |
828 | rapidjson::StringBuffer sb; | |
829 | Writer writer(sb); | |
830 | for (size_t j = 0; j < randvalCount; j++) { | |
831 | char buffer[32]; | |
832 | int64_t x = randval[j] * randval[j]; | |
833 | sprintf(buffer, "%" PRIi64, x); | |
834 | writer.WriteInt64(x); | |
835 | ASSERT_STREQ(buffer, sb.GetString()); | |
836 | sb.Clear(); | |
837 | } | |
838 | } | |
839 | ||
840 | template <typename Writer> | |
841 | void itoa64_Writer_InsituStringStreamVerify() { | |
842 | Writer writer; | |
843 | for (size_t j = 0; j < randvalCount; j++) { | |
844 | char buffer[32]; | |
845 | int64_t x = randval[j] * randval[j]; | |
846 | sprintf(buffer, "%" PRIi64, x); | |
847 | char buffer2[32]; | |
848 | rapidjson::InsituStringStream ss(buffer2); | |
849 | writer.Reset(ss); | |
850 | char* begin = ss.PutBegin(); | |
851 | writer.WriteInt64(x); | |
852 | ss.Put('\0'); | |
853 | ss.PutEnd(begin); | |
854 | ASSERT_STREQ(buffer, buffer2); | |
855 | } | |
856 | } | |
857 | ||
858 | template <typename Writer> | |
859 | void itoa64_Writer_StringBuffer() { | |
860 | size_t length = 0; | |
861 | ||
862 | rapidjson::StringBuffer sb; | |
863 | Writer writer(sb); | |
864 | ||
865 | for (size_t i = 0; i < kItoaTrialCount; i++) { | |
866 | for (size_t j = 0; j < randvalCount; j++) { | |
867 | writer.WriteInt64(randval[j] * randval[j]); | |
868 | length += sb.GetSize(); | |
869 | sb.Clear(); | |
870 | } | |
871 | } | |
872 | OUTPUT_LENGTH(length); | |
873 | } | |
874 | ||
875 | template <typename Writer> | |
876 | void itoa64_Writer_InsituStringStream() { | |
877 | size_t length = 0; | |
878 | ||
879 | char buffer[32]; | |
880 | Writer writer; | |
881 | for (size_t i = 0; i < kItoaTrialCount; i++) { | |
882 | for (size_t j = 0; j < randvalCount; j++) { | |
883 | rapidjson::InsituStringStream ss(buffer); | |
884 | writer.Reset(ss); | |
885 | char* begin = ss.PutBegin(); | |
886 | writer.WriteInt64(randval[j] * randval[j]); | |
887 | length += ss.PutEnd(begin); | |
888 | } | |
889 | } | |
890 | OUTPUT_LENGTH(length); | |
891 | }; | |
892 | ||
893 | // Full specialization for InsituStringStream to prevent memory copying | |
894 | // (normally we will not use InsituStringStream for writing, just for testing) | |
895 | ||
896 | namespace rapidjson { | |
897 | ||
898 | template<> | |
899 | bool rapidjson::Writer<InsituStringStream>::WriteInt(int i) { | |
900 | char *buffer = os_->Push(11); | |
901 | const char* end = internal::i32toa(i, buffer); | |
902 | os_->Pop(11 - (end - buffer)); | |
903 | return true; | |
904 | } | |
905 | ||
906 | template<> | |
907 | bool Writer<InsituStringStream>::WriteUint(unsigned u) { | |
908 | char *buffer = os_->Push(10); | |
909 | const char* end = internal::u32toa(u, buffer); | |
910 | os_->Pop(10 - (end - buffer)); | |
911 | return true; | |
912 | } | |
913 | ||
914 | template<> | |
915 | bool Writer<InsituStringStream>::WriteInt64(int64_t i64) { | |
916 | char *buffer = os_->Push(21); | |
917 | const char* end = internal::i64toa(i64, buffer); | |
918 | os_->Pop(21 - (end - buffer)); | |
919 | return true; | |
920 | } | |
921 | ||
922 | template<> | |
923 | bool Writer<InsituStringStream>::WriteUint64(uint64_t u) { | |
924 | char *buffer = os_->Push(20); | |
925 | const char* end = internal::u64toa(u, buffer); | |
926 | os_->Pop(20 - (end - buffer)); | |
927 | return true; | |
928 | } | |
929 | ||
930 | } // namespace rapidjson | |
931 | ||
932 | TEST_F(Misc, itoa_Writer_StringBufferVerify) { itoa_Writer_StringBufferVerify<rapidjson::Writer<rapidjson::StringBuffer> >(); } | |
933 | TEST_F(Misc, itoa_Writer1_StringBufferVerify) { itoa_Writer_StringBufferVerify<Writer1<rapidjson::StringBuffer> >(); } | |
934 | TEST_F(Misc, itoa_Writer2_StringBufferVerify) { itoa_Writer_StringBufferVerify<Writer2<rapidjson::StringBuffer> >(); } | |
935 | TEST_F(Misc, itoa_Writer3_StringBufferVerify) { itoa_Writer_StringBufferVerify<Writer3<rapidjson::StringBuffer> >(); } | |
936 | TEST_F(Misc, itoa_Writer4_StringBufferVerify) { itoa_Writer_StringBufferVerify<Writer4<rapidjson::StringBuffer> >(); } | |
937 | TEST_F(Misc, itoa_Writer_InsituStringStreamVerify) { itoa_Writer_InsituStringStreamVerify<rapidjson::Writer<rapidjson::InsituStringStream> >(); } | |
938 | TEST_F(Misc, itoa_Writer1_InsituStringStreamVerify) { itoa_Writer_InsituStringStreamVerify<Writer1<rapidjson::InsituStringStream> >(); } | |
939 | TEST_F(Misc, itoa_Writer2_InsituStringStreamVerify) { itoa_Writer_InsituStringStreamVerify<Writer2<rapidjson::InsituStringStream> >(); } | |
940 | TEST_F(Misc, itoa_Writer3_InsituStringStreamVerify) { itoa_Writer_InsituStringStreamVerify<Writer3<rapidjson::InsituStringStream> >(); } | |
941 | TEST_F(Misc, itoa_Writer4_InsituStringStreamVerify) { itoa_Writer_InsituStringStreamVerify<Writer4<rapidjson::InsituStringStream> >(); } | |
942 | TEST_F(Misc, itoa_Writer_StringBuffer) { itoa_Writer_StringBuffer<rapidjson::Writer<rapidjson::StringBuffer> >(); } | |
943 | TEST_F(Misc, itoa_Writer1_StringBuffer) { itoa_Writer_StringBuffer<Writer1<rapidjson::StringBuffer> >(); } | |
944 | TEST_F(Misc, itoa_Writer2_StringBuffer) { itoa_Writer_StringBuffer<Writer2<rapidjson::StringBuffer> >(); } | |
945 | TEST_F(Misc, itoa_Writer3_StringBuffer) { itoa_Writer_StringBuffer<Writer3<rapidjson::StringBuffer> >(); } | |
946 | TEST_F(Misc, itoa_Writer4_StringBuffer) { itoa_Writer_StringBuffer<Writer4<rapidjson::StringBuffer> >(); } | |
947 | TEST_F(Misc, itoa_Writer_InsituStringStream) { itoa_Writer_InsituStringStream<rapidjson::Writer<rapidjson::InsituStringStream> >(); } | |
948 | TEST_F(Misc, itoa_Writer1_InsituStringStream) { itoa_Writer_InsituStringStream<Writer1<rapidjson::InsituStringStream> >(); } | |
949 | TEST_F(Misc, itoa_Writer2_InsituStringStream) { itoa_Writer_InsituStringStream<Writer2<rapidjson::InsituStringStream> >(); } | |
950 | TEST_F(Misc, itoa_Writer3_InsituStringStream) { itoa_Writer_InsituStringStream<Writer3<rapidjson::InsituStringStream> >(); } | |
951 | TEST_F(Misc, itoa_Writer4_InsituStringStream) { itoa_Writer_InsituStringStream<Writer4<rapidjson::InsituStringStream> >(); } | |
952 | ||
953 | TEST_F(Misc, itoa64_Writer_StringBufferVerify) { itoa64_Writer_StringBufferVerify<rapidjson::Writer<rapidjson::StringBuffer> >(); } | |
954 | TEST_F(Misc, itoa64_Writer1_StringBufferVerify) { itoa64_Writer_StringBufferVerify<Writer1<rapidjson::StringBuffer> >(); } | |
955 | TEST_F(Misc, itoa64_Writer2_StringBufferVerify) { itoa64_Writer_StringBufferVerify<Writer2<rapidjson::StringBuffer> >(); } | |
956 | TEST_F(Misc, itoa64_Writer3_StringBufferVerify) { itoa64_Writer_StringBufferVerify<Writer3<rapidjson::StringBuffer> >(); } | |
957 | TEST_F(Misc, itoa64_Writer4_StringBufferVerify) { itoa64_Writer_StringBufferVerify<Writer4<rapidjson::StringBuffer> >(); } | |
958 | TEST_F(Misc, itoa64_Writer_InsituStringStreamVerify) { itoa64_Writer_InsituStringStreamVerify<rapidjson::Writer<rapidjson::InsituStringStream> >(); } | |
959 | TEST_F(Misc, itoa64_Writer1_InsituStringStreamVerify) { itoa64_Writer_InsituStringStreamVerify<Writer1<rapidjson::InsituStringStream> >(); } | |
960 | TEST_F(Misc, itoa64_Writer2_InsituStringStreamVerify) { itoa64_Writer_InsituStringStreamVerify<Writer2<rapidjson::InsituStringStream> >(); } | |
961 | TEST_F(Misc, itoa64_Writer3_InsituStringStreamVerify) { itoa64_Writer_InsituStringStreamVerify<Writer3<rapidjson::InsituStringStream> >(); } | |
962 | TEST_F(Misc, itoa64_Writer4_InsituStringStreamVerify) { itoa64_Writer_InsituStringStreamVerify<Writer4<rapidjson::InsituStringStream> >(); } | |
963 | TEST_F(Misc, itoa64_Writer_StringBuffer) { itoa64_Writer_StringBuffer<rapidjson::Writer<rapidjson::StringBuffer> >(); } | |
964 | TEST_F(Misc, itoa64_Writer1_StringBuffer) { itoa64_Writer_StringBuffer<Writer1<rapidjson::StringBuffer> >(); } | |
965 | TEST_F(Misc, itoa64_Writer2_StringBuffer) { itoa64_Writer_StringBuffer<Writer2<rapidjson::StringBuffer> >(); } | |
966 | TEST_F(Misc, itoa64_Writer3_StringBuffer) { itoa64_Writer_StringBuffer<Writer3<rapidjson::StringBuffer> >(); } | |
967 | TEST_F(Misc, itoa64_Writer4_StringBuffer) { itoa64_Writer_StringBuffer<Writer4<rapidjson::StringBuffer> >(); } | |
968 | TEST_F(Misc, itoa64_Writer_InsituStringStream) { itoa64_Writer_InsituStringStream<rapidjson::Writer<rapidjson::InsituStringStream> >(); } | |
969 | TEST_F(Misc, itoa64_Writer1_InsituStringStream) { itoa64_Writer_InsituStringStream<Writer1<rapidjson::InsituStringStream> >(); } | |
970 | TEST_F(Misc, itoa64_Writer2_InsituStringStream) { itoa64_Writer_InsituStringStream<Writer2<rapidjson::InsituStringStream> >(); } | |
971 | TEST_F(Misc, itoa64_Writer3_InsituStringStream) { itoa64_Writer_InsituStringStream<Writer3<rapidjson::InsituStringStream> >(); } | |
972 | TEST_F(Misc, itoa64_Writer4_InsituStringStream) { itoa64_Writer_InsituStringStream<Writer4<rapidjson::InsituStringStream> >(); } | |
973 | ||
974 | #endif // TEST_MISC |