1 //===- llvm/unittest/Support/raw_ostream_test.cpp - raw_ostream tests -----===// 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 "llvm/ADT/SmallString.h" 10 #include "llvm/Support/Errc.h" 11 #include "llvm/Support/FileSystem.h" 12 #include "llvm/Support/FileUtilities.h" 13 #include "llvm/Support/Format.h" 14 #include "llvm/Support/MemoryBuffer.h" 15 #include "llvm/Support/raw_ostream.h" 16 #include "llvm/Testing/Support/Error.h" 17 #include "gtest/gtest.h" 18 19 using namespace llvm; 20 21 namespace { 22 23 template<typename T> std::string printToString(const T &Value) { 24 std::string res; 25 llvm::raw_string_ostream OS(res); 26 OS.SetBuffered(); 27 OS << Value; 28 OS.flush(); 29 return res; 30 } 31 32 /// printToString - Print the given value to a stream which only has \arg 33 /// BytesLeftInBuffer bytes left in the buffer. This is useful for testing edge 34 /// cases in the buffer handling logic. 35 template<typename T> std::string printToString(const T &Value, 36 unsigned BytesLeftInBuffer) { 37 // FIXME: This is relying on internal knowledge of how raw_ostream works to 38 // get the buffer position right. 39 SmallString<256> SVec; 40 assert(BytesLeftInBuffer < 256 && "Invalid buffer count!"); 41 llvm::raw_svector_ostream OS(SVec); 42 unsigned StartIndex = 256 - BytesLeftInBuffer; 43 for (unsigned i = 0; i != StartIndex; ++i) 44 OS << '?'; 45 OS << Value; 46 return std::string(OS.str().substr(StartIndex)); 47 } 48 49 template<typename T> std::string printToStringUnbuffered(const T &Value) { 50 std::string res; 51 llvm::raw_string_ostream OS(res); 52 OS.SetUnbuffered(); 53 OS << Value; 54 return res; 55 } 56 57 struct X {}; 58 59 raw_ostream &operator<<(raw_ostream &OS, const X &) { return OS << 'X'; } 60 61 TEST(raw_ostreamTest, Types_Buffered) { 62 // Char 63 EXPECT_EQ("c", printToString('c')); 64 65 // String 66 EXPECT_EQ("hello", printToString("hello")); 67 EXPECT_EQ("hello", printToString(std::string("hello"))); 68 69 // Int 70 EXPECT_EQ("0", printToString(0)); 71 EXPECT_EQ("2425", printToString(2425)); 72 EXPECT_EQ("-2425", printToString(-2425)); 73 74 // Long long 75 EXPECT_EQ("0", printToString(0LL)); 76 EXPECT_EQ("257257257235709", printToString(257257257235709LL)); 77 EXPECT_EQ("-257257257235709", printToString(-257257257235709LL)); 78 79 // Double 80 EXPECT_EQ("1.100000e+00", printToString(1.1)); 81 82 // void* 83 EXPECT_EQ("0x0", printToString((void*) nullptr)); 84 EXPECT_EQ("0xbeef", printToString((void*) 0xbeefLL)); 85 EXPECT_EQ("0xdeadbeef", printToString((void*) 0xdeadbeefLL)); 86 87 // Min and max. 88 EXPECT_EQ("18446744073709551615", printToString(UINT64_MAX)); 89 EXPECT_EQ("-9223372036854775808", printToString(INT64_MIN)); 90 91 // X, checking free operator<<(). 92 EXPECT_EQ("X", printToString(X{})); 93 } 94 95 TEST(raw_ostreamTest, Types_Unbuffered) { 96 // Char 97 EXPECT_EQ("c", printToStringUnbuffered('c')); 98 99 // String 100 EXPECT_EQ("hello", printToStringUnbuffered("hello")); 101 EXPECT_EQ("hello", printToStringUnbuffered(std::string("hello"))); 102 103 // Int 104 EXPECT_EQ("0", printToStringUnbuffered(0)); 105 EXPECT_EQ("2425", printToStringUnbuffered(2425)); 106 EXPECT_EQ("-2425", printToStringUnbuffered(-2425)); 107 108 // Long long 109 EXPECT_EQ("0", printToStringUnbuffered(0LL)); 110 EXPECT_EQ("257257257235709", printToStringUnbuffered(257257257235709LL)); 111 EXPECT_EQ("-257257257235709", printToStringUnbuffered(-257257257235709LL)); 112 113 // Double 114 EXPECT_EQ("1.100000e+00", printToStringUnbuffered(1.1)); 115 116 // void* 117 EXPECT_EQ("0x0", printToStringUnbuffered((void*) nullptr)); 118 EXPECT_EQ("0xbeef", printToStringUnbuffered((void*) 0xbeefLL)); 119 EXPECT_EQ("0xdeadbeef", printToStringUnbuffered((void*) 0xdeadbeefLL)); 120 121 // Min and max. 122 EXPECT_EQ("18446744073709551615", printToStringUnbuffered(UINT64_MAX)); 123 EXPECT_EQ("-9223372036854775808", printToStringUnbuffered(INT64_MIN)); 124 125 // X, checking free operator<<(). 126 EXPECT_EQ("X", printToString(X{})); 127 } 128 129 TEST(raw_ostreamTest, BufferEdge) { 130 EXPECT_EQ("1.20", printToString(format("%.2f", 1.2), 1)); 131 EXPECT_EQ("1.20", printToString(format("%.2f", 1.2), 2)); 132 EXPECT_EQ("1.20", printToString(format("%.2f", 1.2), 3)); 133 EXPECT_EQ("1.20", printToString(format("%.2f", 1.2), 4)); 134 EXPECT_EQ("1.20", printToString(format("%.2f", 1.2), 10)); 135 } 136 137 TEST(raw_ostreamTest, TinyBuffer) { 138 std::string Str; 139 raw_string_ostream OS(Str); 140 OS.SetBufferSize(1); 141 OS << "hello"; 142 OS << 1; 143 OS << 'w' << 'o' << 'r' << 'l' << 'd'; 144 OS.flush(); 145 EXPECT_EQ("hello1world", Str); 146 } 147 148 TEST(raw_ostreamTest, WriteEscaped) { 149 std::string Str; 150 151 Str = ""; 152 raw_string_ostream(Str).write_escaped("hi"); 153 EXPECT_EQ("hi", Str); 154 155 Str = ""; 156 raw_string_ostream(Str).write_escaped("\\\t\n\""); 157 EXPECT_EQ("\\\\\\t\\n\\\"", Str); 158 159 Str = ""; 160 raw_string_ostream(Str).write_escaped("\1\10\200"); 161 EXPECT_EQ("\\001\\010\\200", Str); 162 } 163 164 TEST(raw_ostreamTest, Justify) { 165 EXPECT_EQ("xyz ", printToString(left_justify("xyz", 6), 6)); 166 EXPECT_EQ("abc", printToString(left_justify("abc", 3), 3)); 167 EXPECT_EQ("big", printToString(left_justify("big", 1), 3)); 168 EXPECT_EQ(" xyz", printToString(right_justify("xyz", 6), 6)); 169 EXPECT_EQ("abc", printToString(right_justify("abc", 3), 3)); 170 EXPECT_EQ("big", printToString(right_justify("big", 1), 3)); 171 EXPECT_EQ(" on ", printToString(center_justify("on", 9), 9)); 172 EXPECT_EQ(" off ", printToString(center_justify("off", 10), 10)); 173 EXPECT_EQ("single ", printToString(center_justify("single", 7), 7)); 174 EXPECT_EQ("none", printToString(center_justify("none", 1), 4)); 175 EXPECT_EQ("none", printToString(center_justify("none", 1), 1)); 176 } 177 178 TEST(raw_ostreamTest, FormatHex) { 179 EXPECT_EQ("0x1234", printToString(format_hex(0x1234, 6), 6)); 180 EXPECT_EQ("0x001234", printToString(format_hex(0x1234, 8), 8)); 181 EXPECT_EQ("0x00001234", printToString(format_hex(0x1234, 10), 10)); 182 EXPECT_EQ("0x1234", printToString(format_hex(0x1234, 4), 6)); 183 EXPECT_EQ("0xff", printToString(format_hex(255, 4), 4)); 184 EXPECT_EQ("0xFF", printToString(format_hex(255, 4, true), 4)); 185 EXPECT_EQ("0x1", printToString(format_hex(1, 3), 3)); 186 EXPECT_EQ("0x12", printToString(format_hex(0x12, 3), 4)); 187 EXPECT_EQ("0x123", printToString(format_hex(0x123, 3), 5)); 188 EXPECT_EQ("FF", printToString(format_hex_no_prefix(0xFF, 2, true), 4)); 189 EXPECT_EQ("ABCD", printToString(format_hex_no_prefix(0xABCD, 2, true), 4)); 190 EXPECT_EQ("0xffffffffffffffff", 191 printToString(format_hex(UINT64_MAX, 18), 18)); 192 EXPECT_EQ("0x8000000000000000", 193 printToString(format_hex((INT64_MIN), 18), 18)); 194 } 195 196 TEST(raw_ostreamTest, FormatDecimal) { 197 EXPECT_EQ(" 0", printToString(format_decimal(0, 4), 4)); 198 EXPECT_EQ(" -1", printToString(format_decimal(-1, 4), 4)); 199 EXPECT_EQ(" -1", printToString(format_decimal(-1, 6), 6)); 200 EXPECT_EQ("1234567890", printToString(format_decimal(1234567890, 10), 10)); 201 EXPECT_EQ(" 9223372036854775807", 202 printToString(format_decimal(INT64_MAX, 21), 21)); 203 EXPECT_EQ(" -9223372036854775808", 204 printToString(format_decimal(INT64_MIN, 21), 21)); 205 } 206 207 static std::string formatted_bytes_str(ArrayRef<uint8_t> Bytes, 208 llvm::Optional<uint64_t> Offset = None, 209 uint32_t NumPerLine = 16, 210 uint8_t ByteGroupSize = 4) { 211 std::string S; 212 raw_string_ostream Str(S); 213 Str << format_bytes(Bytes, Offset, NumPerLine, ByteGroupSize); 214 Str.flush(); 215 return S; 216 } 217 218 static std::string format_bytes_with_ascii_str(ArrayRef<uint8_t> Bytes, 219 Optional<uint64_t> Offset = None, 220 uint32_t NumPerLine = 16, 221 uint8_t ByteGroupSize = 4) { 222 std::string S; 223 raw_string_ostream Str(S); 224 Str << format_bytes_with_ascii(Bytes, Offset, NumPerLine, ByteGroupSize); 225 Str.flush(); 226 return S; 227 } 228 229 TEST(raw_ostreamTest, FormattedHexBytes) { 230 std::vector<uint8_t> Buf = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 231 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 232 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', 233 '1', '2', '3', '4', '5', '6', '7', '8', '9'}; 234 ArrayRef<uint8_t> B(Buf); 235 236 // Test invalid input. 237 EXPECT_EQ("", formatted_bytes_str(ArrayRef<uint8_t>())); 238 EXPECT_EQ("", format_bytes_with_ascii_str(ArrayRef<uint8_t>())); 239 //---------------------------------------------------------------------- 240 // Test hex byte output with the default 4 byte groups 241 //---------------------------------------------------------------------- 242 EXPECT_EQ("61", formatted_bytes_str(B.take_front())); 243 EXPECT_EQ("61626364 65", formatted_bytes_str(B.take_front(5))); 244 // Test that 16 bytes get written to a line correctly. 245 EXPECT_EQ("61626364 65666768 696a6b6c 6d6e6f70", 246 formatted_bytes_str(B.take_front(16))); 247 // Test raw bytes with default 16 bytes per line wrapping. 248 EXPECT_EQ("61626364 65666768 696a6b6c 6d6e6f70\n71", 249 formatted_bytes_str(B.take_front(17))); 250 // Test raw bytes with 1 bytes per line wrapping. 251 EXPECT_EQ("61\n62\n63\n64\n65\n66", 252 formatted_bytes_str(B.take_front(6), None, 1)); 253 // Test raw bytes with 7 bytes per line wrapping. 254 EXPECT_EQ("61626364 656667\n68696a6b 6c6d6e\n6f7071", 255 formatted_bytes_str(B.take_front(17), None, 7)); 256 // Test raw bytes with 8 bytes per line wrapping. 257 EXPECT_EQ("61626364 65666768\n696a6b6c 6d6e6f70\n71", 258 formatted_bytes_str(B.take_front(17), None, 8)); 259 //---------------------------------------------------------------------- 260 // Test hex byte output with the 1 byte groups 261 //---------------------------------------------------------------------- 262 EXPECT_EQ("61 62 63 64 65", 263 formatted_bytes_str(B.take_front(5), None, 16, 1)); 264 // Test that 16 bytes get written to a line correctly. 265 EXPECT_EQ("61 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f 70", 266 formatted_bytes_str(B.take_front(16), None, 16, 1)); 267 // Test raw bytes with default 16 bytes per line wrapping. 268 EXPECT_EQ("61 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f 70\n71", 269 formatted_bytes_str(B.take_front(17), None, 16, 1)); 270 // Test raw bytes with 7 bytes per line wrapping. 271 EXPECT_EQ("61 62 63 64 65 66 67\n68 69 6a 6b 6c 6d 6e\n6f 70 71", 272 formatted_bytes_str(B.take_front(17), None, 7, 1)); 273 // Test raw bytes with 8 bytes per line wrapping. 274 EXPECT_EQ("61 62 63 64 65 66 67 68\n69 6a 6b 6c 6d 6e 6f 70\n71", 275 formatted_bytes_str(B.take_front(17), None, 8, 1)); 276 277 //---------------------------------------------------------------------- 278 // Test hex byte output with the 2 byte groups 279 //---------------------------------------------------------------------- 280 EXPECT_EQ("6162 6364 65", formatted_bytes_str(B.take_front(5), None, 16, 2)); 281 // Test that 16 bytes get written to a line correctly. 282 EXPECT_EQ("6162 6364 6566 6768 696a 6b6c 6d6e 6f70", 283 formatted_bytes_str(B.take_front(16), None, 16, 2)); 284 // Test raw bytes with default 16 bytes per line wrapping. 285 EXPECT_EQ("6162 6364 6566 6768 696a 6b6c 6d6e 6f70\n71", 286 formatted_bytes_str(B.take_front(17), None, 16, 2)); 287 // Test raw bytes with 7 bytes per line wrapping. 288 EXPECT_EQ("6162 6364 6566 67\n6869 6a6b 6c6d 6e\n6f70 71", 289 formatted_bytes_str(B.take_front(17), None, 7, 2)); 290 // Test raw bytes with 8 bytes per line wrapping. 291 EXPECT_EQ("6162 6364 6566 6768\n696a 6b6c 6d6e 6f70\n71", 292 formatted_bytes_str(B.take_front(17), None, 8, 2)); 293 294 //---------------------------------------------------------------------- 295 // Test hex bytes with offset with the default 4 byte groups. 296 //---------------------------------------------------------------------- 297 EXPECT_EQ("0000: 61", formatted_bytes_str(B.take_front(), 0x0)); 298 EXPECT_EQ("1000: 61", formatted_bytes_str(B.take_front(), 0x1000)); 299 EXPECT_EQ("1000: 61\n1001: 62", 300 formatted_bytes_str(B.take_front(2), 0x1000, 1)); 301 //---------------------------------------------------------------------- 302 // Test hex bytes with ASCII with the default 4 byte groups. 303 //---------------------------------------------------------------------- 304 EXPECT_EQ("61626364 65666768 696a6b6c 6d6e6f70 |abcdefghijklmnop|", 305 format_bytes_with_ascii_str(B.take_front(16))); 306 EXPECT_EQ("61626364 65666768 |abcdefgh|\n" 307 "696a6b6c 6d6e6f70 |ijklmnop|", 308 format_bytes_with_ascii_str(B.take_front(16), None, 8)); 309 EXPECT_EQ("61626364 65666768 |abcdefgh|\n696a6b6c |ijkl|", 310 format_bytes_with_ascii_str(B.take_front(12), None, 8)); 311 std::vector<uint8_t> Unprintable = {'a', '\x1e', 'b', '\x1f'}; 312 // Make sure the ASCII is still lined up correctly when fewer bytes than 16 313 // bytes per line are available. The ASCII should still be aligned as if 16 314 // bytes of hex might be displayed. 315 EXPECT_EQ("611e621f |a.b.|", 316 format_bytes_with_ascii_str(Unprintable)); 317 //---------------------------------------------------------------------- 318 // Test hex bytes with ASCII with offsets with the default 4 byte groups. 319 //---------------------------------------------------------------------- 320 EXPECT_EQ("0000: 61626364 65666768 " 321 "696a6b6c 6d6e6f70 |abcdefghijklmnop|", 322 format_bytes_with_ascii_str(B.take_front(16), 0)); 323 EXPECT_EQ("0000: 61626364 65666768 |abcdefgh|\n" 324 "0008: 696a6b6c 6d6e6f70 |ijklmnop|", 325 format_bytes_with_ascii_str(B.take_front(16), 0, 8)); 326 EXPECT_EQ("0000: 61626364 656667 |abcdefg|\n" 327 "0007: 68696a6b 6c |hijkl|", 328 format_bytes_with_ascii_str(B.take_front(12), 0, 7)); 329 330 //---------------------------------------------------------------------- 331 // Test hex bytes with ASCII with offsets with the default 2 byte groups. 332 //---------------------------------------------------------------------- 333 EXPECT_EQ("0000: 6162 6364 6566 6768 " 334 "696a 6b6c 6d6e 6f70 |abcdefghijklmnop|", 335 format_bytes_with_ascii_str(B.take_front(16), 0, 16, 2)); 336 EXPECT_EQ("0000: 6162 6364 6566 6768 |abcdefgh|\n" 337 "0008: 696a 6b6c 6d6e 6f70 |ijklmnop|", 338 format_bytes_with_ascii_str(B.take_front(16), 0, 8, 2)); 339 EXPECT_EQ("0000: 6162 6364 6566 67 |abcdefg|\n" 340 "0007: 6869 6a6b 6c |hijkl|", 341 format_bytes_with_ascii_str(B.take_front(12), 0, 7, 2)); 342 343 //---------------------------------------------------------------------- 344 // Test hex bytes with ASCII with offsets with the default 1 byte groups. 345 //---------------------------------------------------------------------- 346 EXPECT_EQ("0000: 61 62 63 64 65 66 67 68 " 347 "69 6a 6b 6c 6d 6e 6f 70 |abcdefghijklmnop|", 348 format_bytes_with_ascii_str(B.take_front(16), 0, 16, 1)); 349 EXPECT_EQ("0000: 61 62 63 64 65 66 67 68 |abcdefgh|\n" 350 "0008: 69 6a 6b 6c 6d 6e 6f 70 |ijklmnop|", 351 format_bytes_with_ascii_str(B.take_front(16), 0, 8, 1)); 352 EXPECT_EQ("0000: 61 62 63 64 65 66 67 |abcdefg|\n" 353 "0007: 68 69 6a 6b 6c |hijkl|", 354 format_bytes_with_ascii_str(B.take_front(12), 0, 7, 1)); 355 } 356 357 #ifdef LLVM_ON_UNIX 358 TEST(raw_ostreamTest, Colors) { 359 { 360 std::string S; 361 raw_string_ostream Sos(S); 362 Sos.enable_colors(false); 363 Sos.changeColor(raw_ostream::YELLOW); 364 EXPECT_EQ("", Sos.str()); 365 } 366 367 { 368 std::string S; 369 raw_string_ostream Sos(S); 370 Sos.enable_colors(true); 371 Sos.changeColor(raw_ostream::YELLOW); 372 EXPECT_EQ("\x1B[0;33m", Sos.str()); 373 } 374 } 375 #endif 376 377 TEST(raw_fd_ostreamTest, multiple_raw_fd_ostream_to_stdout) { 378 std::error_code EC; 379 380 { raw_fd_ostream("-", EC, sys::fs::OpenFlags::OF_None); } 381 { raw_fd_ostream("-", EC, sys::fs::OpenFlags::OF_None); } 382 } 383 384 TEST(raw_ostreamTest, flush_tied_to_stream_on_write) { 385 std::string TiedToBuffer; 386 raw_string_ostream TiedTo(TiedToBuffer); 387 TiedTo.SetBuffered(); 388 TiedTo << "a"; 389 390 std::string Buffer; 391 raw_string_ostream TiedStream(Buffer); 392 TiedStream.tie(&TiedTo); 393 // Sanity check that the stream hasn't already been flushed. 394 EXPECT_EQ("", TiedToBuffer); 395 396 // Empty string doesn't cause a flush of TiedTo. 397 TiedStream << ""; 398 EXPECT_EQ("", TiedToBuffer); 399 400 // Non-empty strings trigger flush of TiedTo. 401 TiedStream << "abc"; 402 EXPECT_EQ("a", TiedToBuffer); 403 404 // Single char write flushes TiedTo. 405 TiedTo << "c"; 406 TiedStream << 'd'; 407 EXPECT_EQ("ac", TiedToBuffer); 408 409 // Write to buffered stream without flush does not flush TiedTo. 410 TiedStream.SetBuffered(); 411 TiedStream.SetBufferSize(2); 412 TiedTo << "e"; 413 TiedStream << "f"; 414 EXPECT_EQ("ac", TiedToBuffer); 415 416 // Explicit flush of buffered stream flushes TiedTo. 417 TiedStream.flush(); 418 EXPECT_EQ("ace", TiedToBuffer); 419 420 // Explicit flush of buffered stream with empty buffer does not flush TiedTo. 421 TiedTo << "g"; 422 TiedStream.flush(); 423 EXPECT_EQ("ace", TiedToBuffer); 424 425 // Write of data to empty buffer that is greater than buffer size flushes 426 // TiedTo. 427 TiedStream << "hijklm"; 428 EXPECT_EQ("aceg", TiedToBuffer); 429 430 // Write of data that overflows buffer size also flushes TiedTo. 431 TiedStream.flush(); 432 TiedStream << "n"; 433 TiedTo << "o"; 434 TiedStream << "pq"; 435 EXPECT_EQ("acego", TiedToBuffer); 436 437 // Streams can be tied to each other safely. 438 TiedStream.flush(); 439 Buffer = ""; 440 TiedTo.tie(&TiedStream); 441 TiedTo.SetBufferSize(2); 442 TiedStream << "r"; 443 TiedTo << "s"; 444 EXPECT_EQ("", Buffer); 445 EXPECT_EQ("acego", TiedToBuffer); 446 TiedTo << "tuv"; 447 EXPECT_EQ("r", Buffer); 448 TiedStream << "wxy"; 449 EXPECT_EQ("acegostuv", TiedToBuffer); 450 // The x remains in the buffer, since it was written after the flush of 451 // TiedTo. 452 EXPECT_EQ("rwx", Buffer); 453 TiedTo.tie(nullptr); 454 455 // Calling tie with nullptr unties stream. 456 TiedStream.SetUnbuffered(); 457 TiedStream.tie(nullptr); 458 TiedTo << "y"; 459 TiedStream << "0"; 460 EXPECT_EQ("acegostuv", TiedToBuffer); 461 462 TiedTo.flush(); 463 TiedStream.flush(); 464 } 465 466 TEST(raw_ostreamTest, reserve_stream) { 467 std::string Str; 468 raw_string_ostream OS(Str); 469 OS << "11111111111111111111"; 470 uint64_t CurrentPos = OS.tell(); 471 OS.reserveExtraSpace(1000); 472 EXPECT_GE(Str.capacity(), CurrentPos + 1000); 473 OS << "hello"; 474 OS << 1; 475 OS << 'w' << 'o' << 'r' << 'l' << 'd'; 476 OS.flush(); 477 EXPECT_EQ("11111111111111111111hello1world", Str); 478 } 479 480 static void checkFileData(StringRef FileName, StringRef GoldenData) { 481 ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr = 482 MemoryBuffer::getFileOrSTDIN(FileName); 483 EXPECT_FALSE(BufOrErr.getError()); 484 485 EXPECT_EQ((*BufOrErr)->getBufferSize(), GoldenData.size()); 486 EXPECT_EQ(memcmp((*BufOrErr)->getBufferStart(), GoldenData.data(), 487 GoldenData.size()), 488 0); 489 } 490 491 TEST(raw_ostreamTest, writeToOutputFile) { 492 SmallString<64> Path; 493 int FD; 494 ASSERT_FALSE(sys::fs::createTemporaryFile("foo", "bar", FD, Path)); 495 FileRemover Cleanup(Path); 496 497 ASSERT_THAT_ERROR(writeToOutput(Path, 498 [](raw_ostream &Out) -> Error { 499 Out << "HelloWorld"; 500 return Error::success(); 501 }), 502 Succeeded()); 503 checkFileData(Path, "HelloWorld"); 504 } 505 506 TEST(raw_ostreamTest, writeToNonexistingPath) { 507 StringRef FileName = "/_bad/_path"; 508 std::string ErrorMessage = toString(createFileError( 509 FileName, make_error_code(errc::no_such_file_or_directory))); 510 511 EXPECT_THAT_ERROR(writeToOutput(FileName, 512 [](raw_ostream &Out) -> Error { 513 Out << "HelloWorld"; 514 return Error::success(); 515 }), 516 FailedWithMessage(ErrorMessage)); 517 } 518 519 TEST(raw_ostreamTest, writeToDevNull) { 520 bool DevNullIsUsed = false; 521 522 EXPECT_THAT_ERROR( 523 writeToOutput("/dev/null", 524 [&](raw_ostream &Out) -> Error { 525 DevNullIsUsed = 526 testing::internal::CheckedDowncastToActualType< 527 raw_null_ostream, raw_ostream>(&Out); 528 return Error::success(); 529 }), 530 Succeeded()); 531 532 EXPECT_TRUE(DevNullIsUsed); 533 } 534 535 TEST(raw_ostreamTest, writeToStdOut) { 536 outs().flush(); 537 testing::internal::CaptureStdout(); 538 539 EXPECT_THAT_ERROR(writeToOutput("-", 540 [](raw_ostream &Out) -> Error { 541 Out << "HelloWorld"; 542 return Error::success(); 543 }), 544 Succeeded()); 545 outs().flush(); 546 547 std::string CapturedStdOut = testing::internal::GetCapturedStdout(); 548 EXPECT_EQ(CapturedStdOut, "HelloWorld"); 549 } 550 551 } // namespace 552