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