1 //===-- StreamTest.cpp ------------------------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "lldb/Utility/StreamString.h"
10 #include "gtest/gtest.h"
11 
12 using namespace lldb_private;
13 
14 namespace {
15 struct StreamTest : ::testing::Test {
16   // Note: Stream is an abstract class, so we use StreamString to test it. To
17   // make it easier to change this later, only methods in this class explicitly
18   // refer to the StringStream class.
19   StreamString s;
20   // We return here a std::string because that way gtest can print better
21   // assertion messages.
22   std::string TakeValue() {
23     std::string result = s.GetString().str();
24     s.Clear();
25     return result;
26   }
27 };
28 }
29 
30 namespace {
31 // A StreamTest where we expect the Stream output to be binary.
32 struct BinaryStreamTest : StreamTest {
33   void SetUp() override {
34     s.GetFlags().Set(Stream::eBinary);
35   }
36 };
37 }
38 
39 TEST_F(StreamTest, AddressPrefix) {
40   s.Address(0x1, 1, "foo");
41   EXPECT_EQ("foo0x01", TakeValue());
42 }
43 
44 TEST_F(StreamTest, AddressEmptyPrefix) {
45   s.Address(0x1, 1, nullptr);
46   EXPECT_EQ("0x01", TakeValue());
47   s.Address(0x1, 1, "");
48   EXPECT_EQ("0x01", TakeValue());
49 }
50 
51 TEST_F(StreamTest, AddressSuffix) {
52   s.Address(0x1, 1, nullptr, "foo");
53   EXPECT_EQ("0x01foo", TakeValue());
54 }
55 
56 TEST_F(StreamTest, AddressNoSuffix) {
57   s.Address(0x1, 1, nullptr, nullptr);
58   EXPECT_EQ("0x01", TakeValue());
59   s.Address(0x1, 1, nullptr, "");
60   EXPECT_EQ("0x01", TakeValue());
61 }
62 
63 TEST_F(StreamTest, AddressPrefixAndSuffix) {
64   s.Address(0x1, 1, "foo", "bar");
65   EXPECT_EQ("foo0x01bar", TakeValue());
66 }
67 
68 TEST_F(StreamTest, AddressSize) {
69   s.Address(0x0, 0);
70   EXPECT_EQ("0x0", TakeValue());
71   s.Address(0x1, 0);
72   EXPECT_EQ("0x1", TakeValue());
73 
74   s.Address(0x1, 1);
75   EXPECT_EQ("0x01", TakeValue());
76   s.Address(0xf1, 1);
77   EXPECT_EQ("0xf1", TakeValue());
78   s.Address(0xff, 1);
79   EXPECT_EQ("0xff", TakeValue());
80   s.Address(0x100, 1);
81   EXPECT_EQ("0x100", TakeValue());
82 
83   s.Address(0xf00, 4);
84   EXPECT_EQ("0x00000f00", TakeValue());
85   s.Address(0x100, 8);
86   EXPECT_EQ("0x0000000000000100", TakeValue());
87   s.Address(0x100, 10);
88   EXPECT_EQ("0x00000000000000000100", TakeValue());
89   s.Address(0x1234, 10);
90   EXPECT_EQ("0x00000000000000001234", TakeValue());
91 }
92 
93 TEST_F(StreamTest, AddressRange) {
94   s.AddressRange(0x100, 0x101, 2);
95   EXPECT_EQ("[0x0100-0x0101)", TakeValue());
96 }
97 
98 TEST_F(StreamTest, AddressRangeEmptyRange) {
99   s.AddressRange(0x100, 0x100, 2);
100   EXPECT_EQ("[0x0100-0x0100)", TakeValue());
101   s.AddressRange(0x0, 0x0, 2);
102   EXPECT_EQ("[0x0000-0x0000)", TakeValue());
103 }
104 
105 TEST_F(StreamTest, AddressRangeInvalidRange) {
106   s.AddressRange(0x100, 0x0FF, 2);
107   EXPECT_EQ("[0x0100-0x00ff)", TakeValue());
108   s.AddressRange(0x100, 0x0, 2);
109   EXPECT_EQ("[0x0100-0x0000)", TakeValue());
110 }
111 
112 TEST_F(StreamTest, AddressRangeSize) {
113   s.AddressRange(0x100, 0x101, 0);
114   EXPECT_EQ("[0x100-0x101)", TakeValue());
115   s.AddressRange(0x100, 0x101, 2);
116   EXPECT_EQ("[0x0100-0x0101)", TakeValue());
117   s.AddressRange(0x100, 0x101, 4);
118   EXPECT_EQ("[0x00000100-0x00000101)", TakeValue());
119 
120   s.AddressRange(0x100, 0x101, 4);
121   EXPECT_EQ("[0x00000100-0x00000101)", TakeValue());
122   s.AddressRange(0x1, 0x101, 4);
123   EXPECT_EQ("[0x00000001-0x00000101)", TakeValue());
124   s.AddressRange(0x101, 0x1, 4);
125   EXPECT_EQ("[0x00000101-0x00000001)", TakeValue());
126 
127   s.AddressRange(0x1, 0x101, 1);
128   EXPECT_EQ("[0x01-0x101)", TakeValue());
129 }
130 
131 TEST_F(StreamTest, ChangingByteOrder) {
132   s.SetByteOrder(lldb::eByteOrderPDP);
133   EXPECT_EQ(lldb::eByteOrderPDP, s.GetByteOrder());
134 }
135 
136 TEST_F(StreamTest, PutChar) {
137   s.PutChar('a');
138   EXPECT_EQ(1U, s.GetWrittenBytes());
139   EXPECT_EQ("a", TakeValue());
140 
141   s.PutChar('1');
142   EXPECT_EQ(1U, s.GetWrittenBytes());
143   EXPECT_EQ("1", TakeValue());
144 }
145 
146 TEST_F(StreamTest, PutCharWhitespace) {
147   s.PutChar(' ');
148   EXPECT_EQ(1U, s.GetWrittenBytes());
149   EXPECT_EQ(" ", TakeValue());
150 
151   s.PutChar('\n');
152   EXPECT_EQ(1U, s.GetWrittenBytes());
153   EXPECT_EQ("\n", TakeValue());
154 
155   s.PutChar('\r');
156   EXPECT_EQ(1U, s.GetWrittenBytes());
157   EXPECT_EQ("\r", TakeValue());
158 
159   s.PutChar('\t');
160   EXPECT_EQ(1U, s.GetWrittenBytes());
161   EXPECT_EQ("\t", TakeValue());
162 }
163 
164 TEST_F(StreamTest, PutCString) {
165   s.PutCString("");
166   EXPECT_EQ(0U, s.GetWrittenBytes());
167   EXPECT_EQ("", TakeValue());
168 
169   s.PutCString("foobar");
170   EXPECT_EQ(6U, s.GetWrittenBytes());
171   EXPECT_EQ("foobar", TakeValue());
172 
173   s.PutCString(" ");
174   EXPECT_EQ(1U, s.GetWrittenBytes());
175   EXPECT_EQ(" ", TakeValue());
176 }
177 
178 TEST_F(StreamTest, PutCStringWithStringRef) {
179   s.PutCString(llvm::StringRef(""));
180   EXPECT_EQ(0U, s.GetWrittenBytes());
181   EXPECT_EQ("", TakeValue());
182 
183   s.PutCString(llvm::StringRef("foobar"));
184   EXPECT_EQ(6U, s.GetWrittenBytes());
185   EXPECT_EQ("foobar", TakeValue());
186 
187   s.PutCString(llvm::StringRef(" "));
188   EXPECT_EQ(1U, s.GetWrittenBytes());
189   EXPECT_EQ(" ", TakeValue());
190 }
191 
192 TEST_F(StreamTest, QuotedCString) {
193   s.QuotedCString("foo");
194   EXPECT_EQ(5U, s.GetWrittenBytes());
195   EXPECT_EQ(R"("foo")", TakeValue());
196 
197   s.QuotedCString("ba r");
198   EXPECT_EQ(6U, s.GetWrittenBytes());
199   EXPECT_EQ(R"("ba r")", TakeValue());
200 
201   s.QuotedCString(" ");
202   EXPECT_EQ(3U, s.GetWrittenBytes());
203   EXPECT_EQ(R"(" ")", TakeValue());
204 }
205 
206 TEST_F(StreamTest, PutCharNull) {
207   s.PutChar('\0');
208   EXPECT_EQ(1U, s.GetWrittenBytes());
209   EXPECT_EQ(std::string("\0", 1), TakeValue());
210 
211   s.PutChar('a');
212   EXPECT_EQ(1U, s.GetWrittenBytes());
213   EXPECT_EQ(std::string("a", 1), TakeValue());
214 }
215 
216 TEST_F(StreamTest, PutStringAsRawHex8) {
217   s.PutStringAsRawHex8("");
218   EXPECT_EQ(0U, s.GetWrittenBytes());
219   EXPECT_EQ("", TakeValue());
220 
221   s.PutStringAsRawHex8("foobar");
222   EXPECT_EQ(12U, s.GetWrittenBytes());
223   EXPECT_EQ("666f6f626172", TakeValue());
224 
225   s.PutStringAsRawHex8(" ");
226   EXPECT_EQ(2U, s.GetWrittenBytes());
227   EXPECT_EQ("20", TakeValue());
228 }
229 
230 TEST_F(StreamTest, PutHex8) {
231   s.PutHex8((uint8_t)55);
232   EXPECT_EQ(2U, s.GetWrittenBytes());
233   EXPECT_EQ("37", TakeValue());
234 
235   s.PutHex8(std::numeric_limits<uint8_t>::max());
236   EXPECT_EQ(2U, s.GetWrittenBytes());
237   EXPECT_EQ("ff", TakeValue());
238 
239   s.PutHex8((uint8_t)0);
240   EXPECT_EQ(2U, s.GetWrittenBytes());
241   EXPECT_EQ("00", TakeValue());
242 }
243 
244 TEST_F(StreamTest, PutNHex8) {
245   s.PutNHex8(0, (uint8_t)55);
246   EXPECT_EQ(0U, s.GetWrittenBytes());
247   EXPECT_EQ("", TakeValue());
248 
249   s.PutNHex8(1, (uint8_t)55);
250   EXPECT_EQ(2U, s.GetWrittenBytes());
251   EXPECT_EQ("37", TakeValue());
252 
253   s.PutNHex8(2, (uint8_t)55);
254   EXPECT_EQ(4U, s.GetWrittenBytes());
255   EXPECT_EQ("3737", TakeValue());
256 
257   s.PutNHex8(1, (uint8_t)56);
258   EXPECT_EQ(2U, s.GetWrittenBytes());
259   EXPECT_EQ("38", TakeValue());
260 }
261 
262 TEST_F(StreamTest, PutHex16ByteOrderLittle) {
263   s.PutHex16(0x1234U, lldb::eByteOrderLittle);
264   EXPECT_EQ(4U, s.GetWrittenBytes());
265   EXPECT_EQ("3412", TakeValue());
266 
267   s.PutHex16(std::numeric_limits<uint16_t>::max(), lldb::eByteOrderLittle);
268   EXPECT_EQ(4U, s.GetWrittenBytes());
269   EXPECT_EQ("ffff", TakeValue());
270 
271   s.PutHex16(0U, lldb::eByteOrderLittle);
272   EXPECT_EQ(4U, s.GetWrittenBytes());
273   EXPECT_EQ("0000", TakeValue());
274 }
275 
276 TEST_F(StreamTest, PutHex16ByteOrderBig) {
277   s.PutHex16(0x1234U, lldb::eByteOrderBig);
278   EXPECT_EQ(4U, s.GetWrittenBytes());
279   EXPECT_EQ("1234", TakeValue());
280 
281   s.PutHex16(std::numeric_limits<uint16_t>::max(), lldb::eByteOrderBig);
282   EXPECT_EQ(4U, s.GetWrittenBytes());
283   EXPECT_EQ("ffff", TakeValue());
284 
285   s.PutHex16(0U, lldb::eByteOrderBig);
286   EXPECT_EQ(4U, s.GetWrittenBytes());
287   EXPECT_EQ("0000", TakeValue());
288 }
289 
290 TEST_F(StreamTest, PutHex32ByteOrderLittle) {
291   s.PutHex32(0x12345678U, lldb::eByteOrderLittle);
292   EXPECT_EQ(8U, s.GetWrittenBytes());
293   EXPECT_EQ("78563412", TakeValue());
294 
295   s.PutHex32(std::numeric_limits<uint32_t>::max(), lldb::eByteOrderLittle);
296   EXPECT_EQ(8U, s.GetWrittenBytes());
297   EXPECT_EQ("ffffffff", TakeValue());
298 
299   s.PutHex32(0U, lldb::eByteOrderLittle);
300   EXPECT_EQ(8U, s.GetWrittenBytes());
301   EXPECT_EQ("00000000", TakeValue());
302 }
303 
304 TEST_F(StreamTest, PutHex32ByteOrderBig) {
305   s.PutHex32(0x12345678U, lldb::eByteOrderBig);
306   EXPECT_EQ(8U, s.GetWrittenBytes());
307   EXPECT_EQ("12345678", TakeValue());
308 
309   s.PutHex32(std::numeric_limits<uint32_t>::max(), lldb::eByteOrderBig);
310   EXPECT_EQ(8U, s.GetWrittenBytes());
311   EXPECT_EQ("ffffffff", TakeValue());
312 
313   s.PutHex32(0U, lldb::eByteOrderBig);
314   EXPECT_EQ(8U, s.GetWrittenBytes());
315   EXPECT_EQ("00000000", TakeValue());
316 }
317 
318 TEST_F(StreamTest, PutHex64ByteOrderLittle) {
319   s.PutHex64(0x1234567890ABCDEFU, lldb::eByteOrderLittle);
320   EXPECT_EQ(16U, s.GetWrittenBytes());
321   EXPECT_EQ("efcdab9078563412", TakeValue());
322 
323   s.PutHex64(std::numeric_limits<uint64_t>::max(), lldb::eByteOrderLittle);
324   EXPECT_EQ(16U, s.GetWrittenBytes());
325   EXPECT_EQ("ffffffffffffffff", TakeValue());
326 
327   s.PutHex64(0U, lldb::eByteOrderLittle);
328   EXPECT_EQ(16U, s.GetWrittenBytes());
329   EXPECT_EQ("0000000000000000", TakeValue());
330 }
331 
332 TEST_F(StreamTest, PutHex64ByteOrderBig) {
333   s.PutHex64(0x1234567890ABCDEFU, lldb::eByteOrderBig);
334   EXPECT_EQ(16U, s.GetWrittenBytes());
335   EXPECT_EQ("1234567890abcdef", TakeValue());
336 
337   s.PutHex64(std::numeric_limits<uint64_t>::max(), lldb::eByteOrderBig);
338   EXPECT_EQ(16U, s.GetWrittenBytes());
339   EXPECT_EQ("ffffffffffffffff", TakeValue());
340 
341   s.PutHex64(0U, lldb::eByteOrderBig);
342   EXPECT_EQ(16U, s.GetWrittenBytes());
343   EXPECT_EQ("0000000000000000", TakeValue());
344 }
345 
346 TEST_F(StreamTest, PutMaxHex64ByteOrderBig) {
347   std::size_t bytes;
348   bytes = s.PutMaxHex64(0x12U, 1, lldb::eByteOrderBig);
349   EXPECT_EQ(2U, bytes);
350   bytes = s.PutMaxHex64(0x1234U, 2, lldb::eByteOrderBig);
351   EXPECT_EQ(4U, bytes);
352   bytes = s.PutMaxHex64(0x12345678U, 4, lldb::eByteOrderBig);
353   EXPECT_EQ(8U, bytes);
354   bytes = s.PutMaxHex64(0x1234567890ABCDEFU, 8, lldb::eByteOrderBig);
355   EXPECT_EQ(16U, bytes);
356   EXPECT_EQ(30U, s.GetWrittenBytes());
357   EXPECT_EQ("121234123456781234567890abcdef", TakeValue());
358 }
359 
360 TEST_F(StreamTest, PutMaxHex64ByteOrderLittle) {
361   std::size_t bytes;
362   bytes = s.PutMaxHex64(0x12U, 1, lldb::eByteOrderLittle);
363   EXPECT_EQ(2U, bytes);
364   bytes = s.PutMaxHex64(0x1234U, 2, lldb::eByteOrderLittle);
365   EXPECT_EQ(4U, bytes);
366   bytes = s.PutMaxHex64(0x12345678U, 4, lldb::eByteOrderLittle);
367   EXPECT_EQ(8U, bytes);
368   bytes = s.PutMaxHex64(0x1234567890ABCDEFU, 8, lldb::eByteOrderLittle);
369   EXPECT_EQ(16U, bytes);
370   EXPECT_EQ(30U, s.GetWrittenBytes());
371   EXPECT_EQ("12341278563412efcdab9078563412", TakeValue());
372 }
373 
374 // Shift operator tests.
375 
376 TEST_F(StreamTest, ShiftOperatorChars) {
377   s << 'a' << 'b';
378   EXPECT_EQ(2U, s.GetWrittenBytes());
379   EXPECT_EQ("ab", TakeValue());
380 }
381 
382 TEST_F(StreamTest, ShiftOperatorStrings) {
383   s << "cstring\n";
384   EXPECT_EQ(8U, s.GetWrittenBytes());
385   s << llvm::StringRef("llvm::StringRef\n");
386   EXPECT_EQ(24U, s.GetWrittenBytes());
387   EXPECT_EQ("cstring\nllvm::StringRef\n", TakeValue());
388 }
389 
390 TEST_F(StreamTest, ShiftOperatorPtr) {
391   // This test is a bit tricky because pretty much everything related to
392   // pointer printing seems to lead to UB or IB. So let's make the most basic
393   // test that just checks that we print *something*. This way we at least know
394   // that pointer printing doesn't do really bad things (e.g. crashing, reading
395   // OOB/uninitialized memory which the sanitizers would spot).
396 
397   // Shift our own pointer to the output.
398   int i = 3;
399   int *ptr = &i;
400   s << ptr;
401 
402   EXPECT_NE(0U, s.GetWrittenBytes());
403   EXPECT_TRUE(!TakeValue().empty());
404 }
405 
406 TEST_F(StreamTest, PutPtr) {
407   // See the ShiftOperatorPtr test for the rationale.
408   int i = 3;
409   int *ptr = &i;
410   s.PutPointer(ptr);
411 
412   EXPECT_NE(0U, s.GetWrittenBytes());
413   EXPECT_TRUE(!TakeValue().empty());
414 }
415 
416 // Alias to make it more clear that 'invalid' means for the Stream interface
417 // that it should use the host byte order.
418 const static auto hostByteOrder = lldb::eByteOrderInvalid;
419 
420 // PutRawBytes/PutBytesAsRawHex tests.
421 
422 TEST_F(StreamTest, PutBytesAsRawHex8ToBigEndian) {
423   uint32_t value = 0x12345678;
424   s.PutBytesAsRawHex8(static_cast<void*>(&value), sizeof(value),
425                       hostByteOrder, lldb::eByteOrderBig);
426   EXPECT_EQ(8U, s.GetWrittenBytes());
427   EXPECT_EQ("78563412", TakeValue());
428 }
429 
430 TEST_F(StreamTest, PutRawBytesToBigEndian) {
431   uint32_t value = 0x12345678;
432   s.PutRawBytes(static_cast<void*>(&value), sizeof(value),
433                       hostByteOrder, lldb::eByteOrderBig);
434   EXPECT_EQ(4U, s.GetWrittenBytes());
435   EXPECT_EQ("\x78\x56\x34\x12", TakeValue());
436 }
437 
438 TEST_F(StreamTest, PutBytesAsRawHex8ToLittleEndian) {
439   uint32_t value = 0x12345678;
440   s.PutBytesAsRawHex8(static_cast<void*>(&value), sizeof(value),
441                       hostByteOrder, lldb::eByteOrderLittle);
442   EXPECT_EQ(8U, s.GetWrittenBytes());
443   EXPECT_EQ("12345678", TakeValue());
444 }
445 
446 TEST_F(StreamTest, PutRawBytesToLittleEndian) {
447   uint32_t value = 0x12345678;
448   s.PutRawBytes(static_cast<void*>(&value), sizeof(value),
449                       hostByteOrder, lldb::eByteOrderLittle);
450   EXPECT_EQ(4U, s.GetWrittenBytes());
451   EXPECT_EQ("\x12\x34\x56\x78", TakeValue());
452 }
453 
454 TEST_F(StreamTest, PutBytesAsRawHex8ToMixedEndian) {
455   uint32_t value = 0x12345678;
456   s.PutBytesAsRawHex8(static_cast<void*>(&value), sizeof(value),
457                       hostByteOrder, lldb::eByteOrderPDP);
458 
459   // FIXME: PDP byte order is not actually implemented but Stream just silently
460   // prints the value in some random byte order...
461 #if 0
462   EXPECT_EQ("34127856", TakeValue());
463 #endif
464 }
465 
466 TEST_F(StreamTest, PutRawBytesToMixedEndian) {
467   uint32_t value = 0x12345678;
468   s.PutRawBytes(static_cast<void*>(&value), sizeof(value),
469                       lldb::eByteOrderInvalid, lldb::eByteOrderPDP);
470 
471   // FIXME: PDP byte order is not actually implemented but Stream just silently
472   // prints the value in some random byte order...
473 #if 0
474   EXPECT_EQ("\x34\x12\x78\x56", TakeValue());
475 #endif
476 }
477 
478 // ULEB128 support for binary streams.
479 
480 TEST_F(BinaryStreamTest, PutULEB128OneByte) {
481   auto bytes = s.PutULEB128(0x74ULL);
482   EXPECT_EQ(1U, s.GetWrittenBytes());
483   EXPECT_EQ("\x74", TakeValue());
484   EXPECT_EQ(1U, bytes);
485 }
486 
487 TEST_F(BinaryStreamTest, PutULEB128TwoBytes) {
488   auto bytes = s.PutULEB128(0x1985ULL);
489   EXPECT_EQ(2U, s.GetWrittenBytes());
490   EXPECT_EQ("\x85\x33", TakeValue());
491   EXPECT_EQ(2U, bytes);
492 }
493 
494 TEST_F(BinaryStreamTest, PutULEB128ThreeBytes) {
495   auto bytes = s.PutULEB128(0x5023ULL);
496   EXPECT_EQ(3U, s.GetWrittenBytes());
497   EXPECT_EQ("\xA3\xA0\x1", TakeValue());
498   EXPECT_EQ(3U, bytes);
499 }
500 
501 TEST_F(BinaryStreamTest, PutULEB128FourBytes) {
502   auto bytes = s.PutULEB128(0xA48032ULL);
503   EXPECT_EQ(4U, s.GetWrittenBytes());
504   EXPECT_EQ("\xB2\x80\x92\x5", TakeValue());
505   EXPECT_EQ(4U, bytes);
506 }
507 
508 TEST_F(BinaryStreamTest, PutULEB128FiveBytes) {
509   auto bytes = s.PutULEB128(0x12345678ULL);
510   EXPECT_EQ(5U, s.GetWrittenBytes());
511   EXPECT_EQ("\xF8\xAC\xD1\x91\x1", TakeValue());
512   EXPECT_EQ(5U, bytes);
513 }
514 
515 TEST_F(BinaryStreamTest, PutULEB128SixBytes) {
516   auto bytes = s.PutULEB128(0xABFE3FAFDFULL);
517   EXPECT_EQ(6U, s.GetWrittenBytes());
518   EXPECT_EQ("\xDF\xDF\xFE\xF1\xBF\x15", TakeValue());
519   EXPECT_EQ(6U, bytes);
520 }
521 
522 TEST_F(BinaryStreamTest, PutULEB128SevenBytes) {
523   auto bytes = s.PutULEB128(0xDABFE3FAFDFULL);
524   EXPECT_EQ(7U, s.GetWrittenBytes());
525   EXPECT_EQ("\xDF\xDF\xFE\xF1\xBF\xB5\x3", TakeValue());
526   EXPECT_EQ(7U, bytes);
527 }
528 
529 TEST_F(BinaryStreamTest, PutULEB128EightBytes) {
530   auto bytes = s.PutULEB128(0x7CDABFE3FAFDFULL);
531   EXPECT_EQ(8U, s.GetWrittenBytes());
532   EXPECT_EQ("\xDF\xDF\xFE\xF1\xBF\xB5\xF3\x3", TakeValue());
533   EXPECT_EQ(8U, bytes);
534 }
535 
536 TEST_F(BinaryStreamTest, PutULEB128NineBytes) {
537   auto bytes = s.PutULEB128(0x327CDABFE3FAFDFULL);
538   EXPECT_EQ(9U, s.GetWrittenBytes());
539   EXPECT_EQ("\xDF\xDF\xFE\xF1\xBF\xB5\xF3\x93\x3", TakeValue());
540   EXPECT_EQ(9U, bytes);
541 }
542 
543 TEST_F(BinaryStreamTest, PutULEB128MaxValue) {
544   auto bytes = s.PutULEB128(std::numeric_limits<uint64_t>::max());
545   EXPECT_EQ(10U, s.GetWrittenBytes());
546   EXPECT_EQ("\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x1", TakeValue());
547   EXPECT_EQ(10U, bytes);
548 }
549 
550 TEST_F(BinaryStreamTest, PutULEB128Zero) {
551   auto bytes = s.PutULEB128(0x0U);
552   EXPECT_EQ(1U, s.GetWrittenBytes());
553   EXPECT_EQ(std::string("\0", 1), TakeValue());
554   EXPECT_EQ(1U, bytes);
555 }
556 
557 TEST_F(BinaryStreamTest, PutULEB128One) {
558   auto bytes = s.PutULEB128(0x1U);
559   EXPECT_EQ(1U, s.GetWrittenBytes());
560   EXPECT_EQ("\x1", TakeValue());
561   EXPECT_EQ(1U, bytes);
562 }
563 
564 // SLEB128 support for binary streams.
565 
566 TEST_F(BinaryStreamTest, PutSLEB128OneByte) {
567   auto bytes = s.PutSLEB128(0x74LL);
568   EXPECT_EQ(2U, s.GetWrittenBytes());
569   EXPECT_EQ(std::string("\xF4\0", 2), TakeValue());
570   EXPECT_EQ(2U, bytes);
571 }
572 
573 TEST_F(BinaryStreamTest, PutSLEB128TwoBytes) {
574   auto bytes = s.PutSLEB128(0x1985LL);
575   EXPECT_EQ(2U, s.GetWrittenBytes());
576   EXPECT_EQ("\x85\x33", TakeValue());
577   EXPECT_EQ(2U, bytes);
578 }
579 
580 TEST_F(BinaryStreamTest, PutSLEB128ThreeBytes) {
581   auto bytes = s.PutSLEB128(0x5023LL);
582   EXPECT_EQ(3U, s.GetWrittenBytes());
583   EXPECT_EQ("\xA3\xA0\x1", TakeValue());
584   EXPECT_EQ(3U, bytes);
585 }
586 
587 TEST_F(BinaryStreamTest, PutSLEB128FourBytes) {
588   auto bytes = s.PutSLEB128(0xA48032LL);
589   EXPECT_EQ(4U, s.GetWrittenBytes());
590   EXPECT_EQ("\xB2\x80\x92\x5", TakeValue());
591   EXPECT_EQ(4U, bytes);
592 }
593 
594 TEST_F(BinaryStreamTest, PutSLEB128FiveBytes) {
595   auto bytes = s.PutSLEB128(0x12345678LL);
596   EXPECT_EQ(5U, s.GetWrittenBytes());
597   EXPECT_EQ("\xF8\xAC\xD1\x91\x1", TakeValue());
598   EXPECT_EQ(5U, bytes);
599 }
600 
601 TEST_F(BinaryStreamTest, PutSLEB128SixBytes) {
602   auto bytes = s.PutSLEB128(0xABFE3FAFDFLL);
603   EXPECT_EQ(6U, s.GetWrittenBytes());
604   EXPECT_EQ("\xDF\xDF\xFE\xF1\xBF\x15", TakeValue());
605   EXPECT_EQ(6U, bytes);
606 }
607 
608 TEST_F(BinaryStreamTest, PutSLEB128SevenBytes) {
609   auto bytes = s.PutSLEB128(0xDABFE3FAFDFLL);
610   EXPECT_EQ(7U, s.GetWrittenBytes());
611   EXPECT_EQ("\xDF\xDF\xFE\xF1\xBF\xB5\x3", TakeValue());
612   EXPECT_EQ(7U, bytes);
613 }
614 
615 TEST_F(BinaryStreamTest, PutSLEB128EightBytes) {
616   auto bytes = s.PutSLEB128(0x7CDABFE3FAFDFLL);
617   EXPECT_EQ(8U, s.GetWrittenBytes());
618   EXPECT_EQ("\xDF\xDF\xFE\xF1\xBF\xB5\xF3\x3", TakeValue());
619   EXPECT_EQ(8U, bytes);
620 }
621 
622 TEST_F(BinaryStreamTest, PutSLEB128NineBytes) {
623   auto bytes = s.PutSLEB128(0x327CDABFE3FAFDFLL);
624   EXPECT_EQ(9U, s.GetWrittenBytes());
625   EXPECT_EQ("\xDF\xDF\xFE\xF1\xBF\xB5\xF3\x93\x3", TakeValue());
626   EXPECT_EQ(9U, bytes);
627 }
628 
629 TEST_F(BinaryStreamTest, PutSLEB128MaxValue) {
630   auto bytes = s.PutSLEB128(std::numeric_limits<int64_t>::max());
631   EXPECT_EQ(10U, s.GetWrittenBytes());
632   EXPECT_EQ(std::string("\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0", 10), TakeValue());
633   EXPECT_EQ(10U, bytes);
634 }
635 
636 TEST_F(BinaryStreamTest, PutSLEB128Zero) {
637   auto bytes = s.PutSLEB128(0x0);
638   EXPECT_EQ(1U, s.GetWrittenBytes());
639   EXPECT_EQ(std::string("\0", 1), TakeValue());
640   EXPECT_EQ(1U, bytes);
641 }
642 
643 TEST_F(BinaryStreamTest, PutSLEB128One) {
644   auto bytes = s.PutSLEB128(0x1);
645   EXPECT_EQ(1U, s.GetWrittenBytes());
646   EXPECT_EQ(std::string("\x1", 1), TakeValue());
647   EXPECT_EQ(1U, bytes);
648 }
649 
650 // SLEB128/ULEB128 support for non-binary streams.
651 
652 // The logic for this is very simple, so it should be enough to test some basic
653 // use cases.
654 
655 TEST_F(StreamTest, PutULEB128) {
656   auto bytes = s.PutULEB128(0x74ULL);
657   EXPECT_EQ(4U, s.GetWrittenBytes());
658   EXPECT_EQ("0x74", TakeValue());
659   EXPECT_EQ(4U, bytes);
660 }
661 
662 TEST_F(StreamTest, PutSLEB128) {
663   auto bytes = s.PutSLEB128(0x1985LL);
664   EXPECT_EQ(6U, s.GetWrittenBytes());
665   EXPECT_EQ("0x6533", TakeValue());
666   EXPECT_EQ(6U, bytes);
667 }
668