Add ScopedPrinter unit tests

[Jaysonyan]

Summary

This adds unit tests to the ScopedPrinter class.

Depends on D114223

[Jaysonyan]

Clean up lambda naming.

[jhenderson]

llvm/unittests/Support/ScopedPrinterTest.cpp

22

I don't know what "Fcn" stands for. At a guess, it's either "function" or "functor" or similar. I'd suggest "Func" maybe? Similar throughout.

32

Perhaps avoid the first indent, so that we can see what the initial state is like (or print a string before it).

You also need a test case for unindenting when nothing is left to unindent.

Also missing tests for resetIndent, getIndent and other similar functions that are in the public interface.

49

I'd suggest ordering tests in the same order as the functions in the class.

52

What's the reasoning for the DictScope? I don't see anything in the code that requires it, and it just confuses the test a bit.

129

It may be useful to have an entry in this list with a duplicate value as an earlier one, to show that "first one wins" is the approach taken.

133

I'd suggest using index 1, to show you're not just giving up if the first element doesn't match.

149

I think you need a flag with value 0 in this list, to exercies the if ... continue part.

154–156

You need test cases for when the other input parameters of this function are not the default values.

I believe you may also need soemthing that shows the sort call exists.

222

printList has an overload which takes an additional Printer parameter which doesn't seem to be tested here.

245

I'd split this into three different tests for the three different function names.

253

Might be interesting to show that a 0 offset is still explicitly printed.

279–280

The fact that these two cases are inside the ListScope makes the ListScope look like it's important to the behaviour here, but I don't think it is?

Also, why print twice?

304

Are you sure you need the explicit makeArrayRef function? I thought C-arrays were implicitly convertible? If not, perhaps make them std::array, std::vector or SmallVector to reduce test noise? Applies elsewhere too.

307

I think you're missing a test case for void printBinary(StringRef Label, StringRef Value)

311

I think you need a test case for this if statement: https://github.com/microsoft/llvm/blob/eddbfad05ce3a85732d8bff9f85ef63afc97ad7e/lib/Support/ScopedPrinter.cpp#L25

Also, I think you should have one or more unprintable bytes that get converted to .. Also, I think you should at least one test case that shows what happens when there are too many bytes to fit on the line (probably interesting for both the printBinaryBlock and printBinary cases).

[Jaysonyan]

Address patch comments.

llvm/unittests/Support/ScopedPrinterTest.cpp

52

It's not required for the ScopedPrinter but it is for JSONScopedPrinter. It's possible to remove but it would just mean that we wouldn't be able to reuse this lambda for the JSONScopedPrinter equivalent test.

279–280

Similar to the outside DictScope it is needed produce valid json when testing the JSONScopedPrinter. It's not really needed for testing ScopedPrinter but it allows us to reuse the lambda for both ScopedPrinter and JSONScopedPrinter.

I had added a second print since I thought it made sense to have multiple elements in a list but I realized that's not necessary.

[jhenderson]

Looks like you're still missing tests for startLine and getOStream, which should be simple, but for completeness should be added too.

llvm/unittests/Support/ScopedPrinterTest.cpp

30

Now that you've added separate indent/unindent tests, I'd move PrintIndent to be later in this file, to match the function declaration order.

47

I'd recommend one function under test per TEST, i.e. split this and ResetIndent into their own TESTs.

52

Okay, leave as-is.

90–91

Perhaps add one more indent call between these two lines, so that a) you show that you can indent after an unindent, and b) show that reset is not just an unindent alias, but rather a complete reset.

94

I'd be tempted to put one more indent at the end here, to show that the internal representation is really capped at 0, rather than just getIndentLevel's external result.

104–105

Perhaps add another setPrefix call followed by a print here, to show that the existing prefix can be changed.

I'd also consider calling printIndent in addition to, or instead of printString, since printIndent explicitly adds the prefix itself.

121

As the value you look up is actually "2", you need this duplicate case to match it, so that you still show the "first one wins" behaviour.

125–126

More unnecessary(?) makeArrayRef calls.

154

Lots of makeArrayRef calls in this test, which could be simplified by using std::vector or other containers.

172–179

Not wanting to be too picky, but this still doesn't exercise all arguments (there are three EnumMask arguments, and you only test with two).

[Jaysonyan]

Add missing tests and update existing ones.

llvm/unittests/Support/ScopedPrinterTest.cpp

125–126

After trying for a bit, I don't think I can get rid of these makeArrayRef calls. I think it can't implicitly cast to an ArrayRef because the printEnum method takes in a template list rather than a list of concrete type.

154

Similar comment about template lists not allowing for implicit casts to ArrayRef.

[Jaysonyan]

Update printEnum test

[Jaysonyan]

Add more printList(...) tests.

[jhenderson]

Nearly there, just one actual comment.

llvm/unittests/Support/ScopedPrinterTest.cpp

87

Variable names in this test seem wrong.

I wonder if you should change all the expected strings to be called ExpectedOut? And similarly perhaps the functions could have a common name (I don't have any concrete suggestions yet)?

125–126

Okay, thanks for the explanation.

393

Mutters about silly std::vector<bool> standard specialization...

614

startLine not adding a new line implicitly is not what I expected!

[Jaysonyan]

Renamed lambda and expected output variables

[Jaysonyan]

llvm/unittests/Support/ScopedPrinterTest.cpp

87

My mistake, I've updated all expect strings to be ExpectedOut (and will update json versions to be JSONExpectedOut) and the function names to be all called PrintFunc which also matches the alias for the function_ref inside the test fixture.

393

Haha I learned about this quirk while working on this change.

[Esme]

Should unit tests be added for to_hexString(), to_string() and enumToString() (from D114840)? Although they are not part of the ScopedPrinter class but just in ScopedPrinter.h.

[jhenderson]

In D114684#3168977, @Esme wrote:

Should unit tests be added for to_hexString(), to_string() and enumToString() (from D114840)? Although they are not part of the ScopedPrinter class but just in ScopedPrinter.h.

Yes, they should be added, but I'd be inclined to say that they should be in a separate patch, allowing us to focus this on the ScopedPrinter class specifically.

@Jaysonyan - I spotted a unit test failure in the pre-merge checks above. You should take a look and address it. I think it's a classic case of a compiler treating a uint8_t/int8_t as char variants, and printing them as such. At a guess, this is a bug in the main code that the test is highlighting, rather than a bug in your change though. Is this bug present with the virtualization patch? In theory, this patch should be standalone, so I think a separate precursor small bug fix would be beneficial, so that this unit test patch can be submitted immediately.

Aside from that, looks good.

[jhenderson]

llvm/unittests/Support/ScopedPrinterTest.cpp

52

Actually, revisiting this, now that I've looked at the other related patches again. Is the only reason we need it because we don't add it within the JSONScopedPrinter constructor? If we added it there, could we omit it from here? See also my comments in D114225.

[Jaysonyan]

Add APSInt test.

[Jaysonyan]

Yes, they should be added, but I'd be inclined to say that they should be in a separate patch, allowing us to focus this on the ScopedPrinter class specifically.

I can add these in a separate patch then.

@Jaysonyan - I spotted a unit test failure in the pre-merge checks above. You should take a look and address it. I think it's a classic case of a compiler treating a uint8_t/int8_t as char variants, and printing them as such. At a guess, this is a bug in the main code that the test is highlighting, rather than a bug in your change though. Is this bug present with the virtualization patch? In theory, this patch should be standalone, so I think a separate precursor small bug fix would be beneficial, so that this unit test patch can be submitted immediately.

This was working locally and I believe that this might because I didn't mention that this diff depends on the virtualization diff. I've added that to the description and hopefully the failing test will fix itself. That being said, I think this indicates that the virtualization patch (D114223) includes a functional change (calling printList with uint_8/int8_t). Although I believe this would be closer to fixing an unrealized bug.

[jhenderson]

In D114684#3170953, @Jaysonyan wrote:

Yes, they should be added, but I'd be inclined to say that they should be in a separate patch, allowing us to focus this on the ScopedPrinter class specifically.

I can add these in a separate patch then.

@Jaysonyan - I spotted a unit test failure in the pre-merge checks above. You should take a look and address it. I think it's a classic case of a compiler treating a uint8_t/int8_t as char variants, and printing them as such. At a guess, this is a bug in the main code that the test is highlighting, rather than a bug in your change though. Is this bug present with the virtualization patch? In theory, this patch should be standalone, so I think a separate precursor small bug fix would be beneficial, so that this unit test patch can be submitted immediately.

This was working locally and I believe that this might because I didn't mention that this diff depends on the virtualization diff. I've added that to the description and hopefully the failing test will fix itself. That being said, I think this indicates that the virtualization patch (D114223) includes a functional change (calling printList with uint_8/int8_t). Although I believe this would be closer to fixing an unrealized bug.

Agreed that this was probably a bug-fix. Might be worth highlighting this in a comment in the patch description.

llvm/unittests/Support/ScopedPrinterTest.cpp

52

Did this comment get missed?

[Jaysonyan]

Update test fixture to hold ScopedPrinter as member.

[Jaysonyan]

llvm/unittests/Support/ScopedPrinterTest.cpp

52

Sorry, meant to wait to arrive at a conclusion on the discussion in D114225. I realized the ctor solution (while useful for D114225) isn't perfect for testing. Since at the time that we check the output the JSONScopedPrinter won't have gone out of scope yet so the ListScope/DictScope it's holding on to won't have outputted the closing }/].

As an alternative solution I've added the DictScope inside verifyJSONScopedPrinter so that the DictScope goes out of scope by the time we check the output and so I've removed the unneeded calls to DictScope inside the lambdas.

[jhenderson]

llvm/unittests/Support/ScopedPrinterTest.cpp

27

I'm liking the simplicity we're heading towards here, with this function and the members. As a next step, how about you add a "verifyAll" function which takes the expected strings (one for each type) and then calls the corresponding verify* function. This has the advantage of removing additional function calls from each test. The tests then just need to define the two strings and call the "verifyAll" function.

You could even go as far as have the fixture store StringRef members (default to empty) for ExpectedScopedPrinter, ExpectedJSON etc, and have the tests set those, rather than pass them into the function, although I'm not sure there's a huge amount of benefit to that.

40

I'm in two minds about this following suggestion, so feel free to take it or leave it.

W.flush() is in every single lambda that I bothered checking. If we moved it to the verify* function(s), we'd avoid the need for it to be repeated here. The downside is of course that both verify functions will need it, but I think that's better than the repetition. What do you think?

52

No worries. I made this comment before seeing your comments elsewhere.

[Jaysonyan]

Add W.flush() to verifyScopedPrinter() method.

llvm/unittests/Support/ScopedPrinterTest.cpp

27

Added verifyAll in D114224! I'll leave the expected output vars as parameters for now since both approaches seem relatively equivalent.

40

That seems reasonable to me! Added.

[jhenderson]

Latest version looks good again.

llvm/unittests/Support/CMakeLists.txt

add_llvm_unittest(SupportTests
   Path.cpp
   ProcessTest.cpp
   ProgramTest.cpp
   RegexTest.cpp
   ReverseIterationTest.cpp
   ReplaceFileTest.cpp
   RISCVAttributeParserTest.cpp
   ScaledNumberTest.cpp
+  ScopedPrinterTest.cpp
   SHA256.cpp
   SourceMgrTest.cpp
   SpecialCaseListTest.cpp
   SuffixTreeTest.cpp
   SwapByteOrderTest.cpp
   SymbolRemappingReaderTest.cpp
   TarWriterTest.cpp
   TargetParserTest.cpp

llvm/unittests/Support/ScopedPrinterTest.cpp

+//===- llvm/unittest/Support/ScopedPrinterTest.cpp - ScopedPrinter tests --===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Support/ScopedPrinter.h"
+#include "llvm/ADT/APSInt.h"
+#include "gtest/gtest.h"
+#include <vector>
+
+using namespace llvm;
+
+class ScopedPrinterTest : public ::testing::Test {
+protected:
+  std::string StreamBuffer;
+  raw_string_ostream OS;
+  ScopedPrinter Writer;
+
+  ScopedPrinterTest() : OS(StreamBuffer), Writer(OS) {}
+
+  using PrintFunc = function_ref<void(ScopedPrinter &)>;
+
+  void verifyScopedPrinter(StringRef Expected, PrintFunc Func) {
+    Func(Writer);
+    Writer.flush();
+    EXPECT_EQ(Expected.str(), OS.str());
+  }
+};
+
+TEST_F(ScopedPrinterTest, Indent) {
+  auto PrintFunc = [](ScopedPrinter &W) {
+    W.printString("|");
+    W.indent();
+    W.printString("|");
+    W.indent(2);
+    W.printString("|");
+  };
+
+  const char *ExpectedOut = R"(|
+  |
+      |
+)";
+  verifyScopedPrinter(ExpectedOut, PrintFunc);
+}
+
+TEST_F(ScopedPrinterTest, Unindent) {
+  auto PrintFunc = [](ScopedPrinter &W) {
+    W.indent(3);
+    W.printString("|");
+    W.unindent(2);
+    W.printString("|");
+    W.unindent();
+    W.printString("|");
+    W.unindent();
+    W.printString("|");
+  };
+
+  const char *ExpectedOut = R"(      |
+  |
+|
+|
+)";
+  verifyScopedPrinter(ExpectedOut, PrintFunc);
+}
+
+TEST_F(ScopedPrinterTest, ResetIndent) {
+  auto PrintFunc = [](ScopedPrinter &W) {
+    W.indent(4);
+    W.printString("|");
+    W.resetIndent();
+    W.printString("|");
+  };
+
+  const char *ExpectedOut = R"(        |
+|
+)";
+  verifyScopedPrinter(ExpectedOut, PrintFunc);
+}
+
+TEST_F(ScopedPrinterTest, PrintIndent) {
+  auto PrintFunc = [](ScopedPrinter &W) {
+    W.printIndent();
+    W.printString("|");
+    W.indent();
+    W.printIndent();
+    W.printString("|");
+  };
+
+  const char *ExpectedOut = R"(|
+    |
+)";
+  verifyScopedPrinter(ExpectedOut, PrintFunc);
+}
+
+TEST_F(ScopedPrinterTest, GetIndentLevel) {
+  EXPECT_EQ(Writer.getIndentLevel(), 0);
+  Writer.indent();
+  EXPECT_EQ(Writer.getIndentLevel(), 1);
+  Writer.indent();
+  EXPECT_EQ(Writer.getIndentLevel(), 2);
+  Writer.unindent();
+  EXPECT_EQ(Writer.getIndentLevel(), 1);
+  Writer.indent();
+  Writer.resetIndent();
+  EXPECT_EQ(Writer.getIndentLevel(), 0);
+  Writer.unindent();
+  EXPECT_EQ(Writer.getIndentLevel(), 0);
+  Writer.indent();
+  EXPECT_EQ(Writer.getIndentLevel(), 1);
+}
+
+TEST_F(ScopedPrinterTest, SetPrefix) {
+  auto PrintFunc = [](ScopedPrinter &W) {
+    W.setPrefix("Prefix1");
+    W.indent();
+    W.printIndent();
+    W.printString("|");
+    W.unindent();
+    W.printIndent();
+    W.printString("|");
+    W.setPrefix("Prefix2");
+    W.printIndent();
+    W.printString("|");
+  };
+
+  const char *ExpectedOut = R"(Prefix1  Prefix1  |
+Prefix1Prefix1|
+Prefix2Prefix2|
+)";
+  verifyScopedPrinter(ExpectedOut, PrintFunc);
+}
+
+TEST_F(ScopedPrinterTest, PrintEnum) {
+  auto PrintFunc = [](ScopedPrinter &W) {
+    const EnumEntry<int> EnumList[] = {{"Name1", "AltName1", 1},
+                                       {"Name2", "AltName2", 2},
+                                       {"Name3", "AltName3", 3},
+                                       {"Name4", "AltName4", 2}};
+    EnumEntry<int> OtherEnum{"Name5", "AltName5", 5};
+    W.printEnum("Exists", EnumList[1].Value, makeArrayRef(EnumList));
+    W.printEnum("DoesNotExist", OtherEnum.Value, makeArrayRef(EnumList));
+  };
+
+  const char *ExpectedOut = R"(Exists: Name2 (0x2)
+DoesNotExist: 0x5
+)";
+  verifyScopedPrinter(ExpectedOut, PrintFunc);
+}
+
+TEST_F(ScopedPrinterTest, PrintFlag) {
+  auto PrintFunc = [](ScopedPrinter &W) {
+    const EnumEntry<uint16_t> SingleBitFlags[] = {
+        {"Name0", "AltName0", 0},
+        {"Name1", "AltName1", 1},
+        {"Name2", "AltName2", 1 << 1},
+        {"Name3", "AltName3", 1 << 2}};
+    const EnumEntry<uint16_t> UnsortedFlags[] = {
+        {"C", "c", 1}, {"B", "b", 1 << 1}, {"A", "a", 1 << 2}};
+    const EnumEntry<uint16_t> EnumFlags[] = {
+        {"FirstByte1", "First1", 0x1u},    {"FirstByte2", "First2", 0x2u},
+        {"FirstByte3", "First3", 0x3u},    {"SecondByte1", "Second1", 0x10u},
+        {"SecondByte2", "Second2", 0x20u}, {"SecondByte3", "Second3", 0x30u},
+        {"ThirdByte1", "Third1", 0x100u},  {"ThirdByte2", "Third2", 0x200u},
+        {"ThirdByte3", "Third3", 0x300u}};
+    W.printFlags("ZeroFlag", 0, makeArrayRef(SingleBitFlags));
+    W.printFlags("NoFlag", 1 << 3, makeArrayRef(SingleBitFlags));
+    W.printFlags("Flag1", SingleBitFlags[1].Value,
+                 makeArrayRef(SingleBitFlags));
+    W.printFlags("Flag1&3", (1 << 2) + 1, makeArrayRef(SingleBitFlags));
+
+    W.printFlags("ZeroFlagRaw", 0);
+    W.printFlags("NoFlagRaw", 1 << 3);
+    W.printFlags("Flag1Raw", SingleBitFlags[1].Value);
+    W.printFlags("Flag1&3Raw", (1 << 2) + 1);
+
+    W.printFlags("FlagSorted", (1 << 2) + (1 << 1) + 1,
+                 makeArrayRef(UnsortedFlags));
+
+    uint16_t NoBitMask = 0;
+    uint16_t FirstByteMask = 0xFu;
+    uint16_t SecondByteMask = 0xF0u;
+    uint16_t ThirdByteMask = 0xF00u;
+    W.printFlags("NoBitMask", 0xFFFu, makeArrayRef(EnumFlags), NoBitMask);
+    W.printFlags("FirstByteMask", 0x3u, makeArrayRef(EnumFlags), FirstByteMask);
+    W.printFlags("SecondByteMask", 0x30u, makeArrayRef(EnumFlags),
+                 SecondByteMask);
+    W.printFlags("ValueOutsideMask", 0x1u, makeArrayRef(EnumFlags),
+                 SecondByteMask);
+    W.printFlags("FirstSecondByteMask", 0xFFu, makeArrayRef(EnumFlags),
+                 FirstByteMask, SecondByteMask);
+    W.printFlags("FirstSecondThirdByteMask", 0x333u, makeArrayRef(EnumFlags),
+                 FirstByteMask, SecondByteMask, ThirdByteMask);
+  };
+
+  const char *ExpectedOut = R"(ZeroFlag [ (0x0)
+]
+NoFlag [ (0x8)
+]
+Flag1 [ (0x1)
+  Name1 (0x1)
+]
+Flag1&3 [ (0x5)
+  Name1 (0x1)
+  Name3 (0x4)
+]
+ZeroFlagRaw [ (0x0)
+]
+NoFlagRaw [ (0x8)
+  0x8
+]
+Flag1Raw [ (0x1)
+  0x1
+]
+Flag1&3Raw [ (0x5)
+  0x1
+  0x4
+]
+FlagSorted [ (0x7)
+  A (0x4)
+  B (0x2)
+  C (0x1)
+]
+NoBitMask [ (0xFFF)
+  FirstByte1 (0x1)
+  FirstByte2 (0x2)
+  FirstByte3 (0x3)
+  SecondByte1 (0x10)
+  SecondByte2 (0x20)
+  SecondByte3 (0x30)
+  ThirdByte1 (0x100)
+  ThirdByte2 (0x200)
+  ThirdByte3 (0x300)
+]
+FirstByteMask [ (0x3)
+  FirstByte3 (0x3)
+]
+SecondByteMask [ (0x30)
+  SecondByte3 (0x30)
+]
+ValueOutsideMask [ (0x1)
+  FirstByte1 (0x1)
+]
+FirstSecondByteMask [ (0xFF)
+]
+FirstSecondThirdByteMask [ (0x333)
+  FirstByte3 (0x3)
+  SecondByte3 (0x30)
+  ThirdByte3 (0x300)
+]
+)";
+  verifyScopedPrinter(ExpectedOut, PrintFunc);
+}
+
+TEST_F(ScopedPrinterTest, PrintNumber) {
+  auto PrintFunc = [](ScopedPrinter &W) {
+    uint64_t Unsigned64Max = std::numeric_limits<uint64_t>::max();
+    uint64_t Unsigned64Min = std::numeric_limits<uint64_t>::min();
+    W.printNumber("uint64_t-max", Unsigned64Max);
+    W.printNumber("uint64_t-min", Unsigned64Min);
+
+    uint32_t Unsigned32Max = std::numeric_limits<uint32_t>::max();
+    uint32_t Unsigned32Min = std::numeric_limits<uint32_t>::min();
+    W.printNumber("uint32_t-max", Unsigned32Max);
+    W.printNumber("uint32_t-min", Unsigned32Min);
+
+    uint16_t Unsigned16Max = std::numeric_limits<uint16_t>::max();
+    uint16_t Unsigned16Min = std::numeric_limits<uint16_t>::min();
+    W.printNumber("uint16_t-max", Unsigned16Max);
+    W.printNumber("uint16_t-min", Unsigned16Min);
+
+    uint8_t Unsigned8Max = std::numeric_limits<uint8_t>::max();
+    uint8_t Unsigned8Min = std::numeric_limits<uint8_t>::min();
+    W.printNumber("uint8_t-max", Unsigned8Max);
+    W.printNumber("uint8_t-min", Unsigned8Min);
+
+    int64_t Signed64Max = std::numeric_limits<int64_t>::max();
+    int64_t Signed64Min = std::numeric_limits<int64_t>::min();
+    W.printNumber("int64_t-max", Signed64Max);
+    W.printNumber("int64_t-min", Signed64Min);
+
+    int32_t Signed32Max = std::numeric_limits<int32_t>::max();
+    int32_t Signed32Min = std::numeric_limits<int32_t>::min();
+    W.printNumber("int32_t-max", Signed32Max);
+    W.printNumber("int32_t-min", Signed32Min);
+
+    int16_t Signed16Max = std::numeric_limits<int16_t>::max();
+    int16_t Signed16Min = std::numeric_limits<int16_t>::min();
+    W.printNumber("int16_t-max", Signed16Max);
+    W.printNumber("int16_t-min", Signed16Min);
+
+    int8_t Signed8Max = std::numeric_limits<int8_t>::max();
+    int8_t Signed8Min = std::numeric_limits<int8_t>::min();
+    W.printNumber("int8_t-max", Signed8Max);
+    W.printNumber("int8_t-min", Signed8Min);
+
+    APSInt LargeNum("9999999999999999999999");
+    W.printNumber("apsint", LargeNum);
+
+    W.printNumber("label", "value", 0);
+  };
+
+  const char *ExpectedOut = R"(uint64_t-max: 18446744073709551615
+uint64_t-min: 0
+uint32_t-max: 4294967295
+uint32_t-min: 0
+uint16_t-max: 65535
+uint16_t-min: 0
+uint8_t-max: 255
+uint8_t-min: 0
+int64_t-max: 9223372036854775807
+int64_t-min: -9223372036854775808
+int32_t-max: 2147483647
+int32_t-min: -2147483648
+int16_t-max: 32767
+int16_t-min: -32768
+int8_t-max: 127
+int8_t-min: -128
+apsint: 9999999999999999999999
+label: value (0)
+)";
+  verifyScopedPrinter(ExpectedOut, PrintFunc);
+}
+
+TEST_F(ScopedPrinterTest, PrintBoolean) {
+  auto PrintFunc = [](ScopedPrinter &W) {
+    W.printBoolean("True", true);
+    W.printBoolean("False", false);
+  };
+
+  const char *ExpectedOut = R"(True: Yes
+False: No
+)";
+  verifyScopedPrinter(ExpectedOut, PrintFunc);
+}
+
+TEST_F(ScopedPrinterTest, PrintVersion) {
+  auto PrintFunc = [](ScopedPrinter &W) {
+    W.printVersion("Version", "123", "456", "789");
+  };
+  const char *ExpectedOut = R"(Version: 123.456.789
+)";
+  verifyScopedPrinter(ExpectedOut, PrintFunc);
+}
+
+TEST_F(ScopedPrinterTest, PrintList) {
+  auto PrintFunc = [](ScopedPrinter &W) {
+    const std::vector<uint64_t> EmptyList;
+    const std::vector<std::string> StringList = {"foo", "bar", "baz"};
+    const bool BoolList[] = {true, false};
+    const std::vector<uint64_t> Unsigned64List = {
+        std::numeric_limits<uint64_t>::max(),
+        std::numeric_limits<uint64_t>::min()};
+    const std::vector<uint32_t> Unsigned32List = {
+        std::numeric_limits<uint32_t>::max(),
+        std::numeric_limits<uint32_t>::min()};
+    const std::vector<uint16_t> Unsigned16List = {
+        std::numeric_limits<uint16_t>::max(),
+        std::numeric_limits<uint16_t>::min()};
+    const std::vector<uint8_t> Unsigned8List = {
+        std::numeric_limits<uint8_t>::max(),
+        std::numeric_limits<uint8_t>::min()};
+    const std::vector<int64_t> Signed64List = {
+        std::numeric_limits<int64_t>::max(),
+        std::numeric_limits<int64_t>::min()};
+    const std::vector<int32_t> Signed32List = {
+        std::numeric_limits<int32_t>::max(),
+        std::numeric_limits<int32_t>::min()};
+    const std::vector<int16_t> Signed16List = {
+        std::numeric_limits<int16_t>::max(),
+        std::numeric_limits<int16_t>::min()};
+    const std::vector<int8_t> Signed8List = {
+        std::numeric_limits<int8_t>::max(), std::numeric_limits<int8_t>::min()};
+    const std::vector<APSInt> APSIntList = {APSInt("9999999999999999999999"),
+                                            APSInt("-9999999999999999999999")};
+    W.printList("EmptyList", EmptyList);
+    W.printList("StringList", StringList);
+    W.printList("BoolList", makeArrayRef(BoolList));
+    W.printList("uint64List", Unsigned64List);
+    W.printList("uint32List", Unsigned32List);
+    W.printList("uint16List", Unsigned16List);
+    W.printList("uint8List", Unsigned8List);
+    W.printList("int64List", Signed64List);
+    W.printList("int32List", Signed32List);
+    W.printList("int16List", Signed16List);
+    W.printList("int8List", Signed8List);
+    W.printList("APSIntList", APSIntList);
+  };
+
+  const char *ExpectedOut = R"(EmptyList: []
+StringList: [foo, bar, baz]
+BoolList: [1, 0]
+uint64List: [18446744073709551615, 0]
+uint32List: [4294967295, 0]
+uint16List: [65535, 0]
+uint8List: [255, 0]
+int64List: [9223372036854775807, -9223372036854775808]
+int32List: [2147483647, -2147483648]
+int16List: [32767, -32768]
+int8List: [127, -128]
+APSIntList: [9999999999999999999999, -9999999999999999999999]
+)";
+  verifyScopedPrinter(ExpectedOut, PrintFunc);
+}
+
+TEST_F(ScopedPrinterTest, PrintListPrinter) {
+  auto PrintFunc = [](ScopedPrinter &W) {
+    const std::string StringList[] = {"a", "ab", "abc"};
+    W.printList("StringSizeList", StringList,
+                [](raw_ostream &OS, StringRef Item) { OS << Item.size(); });
+  };
+
+  const char *ExpectedOut = R"(StringSizeList: [1, 2, 3]
+)";
+  verifyScopedPrinter(ExpectedOut, PrintFunc);
+}
+
+TEST_F(ScopedPrinterTest, PrintHex) {
+  auto PrintFunc = [](ScopedPrinter &W) {
+    W.printHex("HexNumber", 0x10);
+    W.printHex("HexLabel", "Name", 0x10);
+  };
+
+  const char *ExpectedOut = R"(HexNumber: 0x10
+HexLabel: Name (0x10)
+)";
+  verifyScopedPrinter(ExpectedOut, PrintFunc);
+}
+
+TEST_F(ScopedPrinterTest, PrintHexList) {
+  auto PrintFunc = [](ScopedPrinter &W) {
+    const uint64_t HexList[] = {0x1, 0x10, 0x100};
+    W.printHexList("HexList", HexList);
+  };
+  const char *ExpectedOut = R"(HexList: [0x1, 0x10, 0x100]
+)";
+  verifyScopedPrinter(ExpectedOut, PrintFunc);
+}
+
+TEST_F(ScopedPrinterTest, PrintSymbolOffset) {
+  auto PrintFunc = [](ScopedPrinter &W) {
+    W.printSymbolOffset("SymbolOffset", "SymbolName", 0x10);
+    W.printSymbolOffset("NoSymbolOffset", "SymbolName", 0);
+  };
+  const char *ExpectedOut = R"(SymbolOffset: SymbolName+0x10
+NoSymbolOffset: SymbolName+0x0
+)";
+  verifyScopedPrinter(ExpectedOut, PrintFunc);
+}
+
+TEST_F(ScopedPrinterTest, PrintString) {
+  auto PrintFunc = [](ScopedPrinter &W) {
+    const StringRef StringRefValue("Value");
+    const std::string StringValue = "Value";
+    const char *CharArrayValue = "Value";
+    W.printString("StringRef", StringRefValue);
+    W.printString("String", StringValue);
+    W.printString("CharArray", CharArrayValue);
+    ListScope L(W, "StringList");
+    W.printString(StringRefValue);
+  };
+
+  const char *ExpectedOut = R"(StringRef: Value
+String: Value
+CharArray: Value
+StringList [
+  Value
+]
+)";
+  verifyScopedPrinter(ExpectedOut, PrintFunc);
+}
+
+TEST_F(ScopedPrinterTest, PrintBinary) {
+  auto PrintFunc = [](ScopedPrinter &W) {
+    std::vector<uint8_t> IntArray = {70, 111, 111, 66, 97, 114};
+    std::vector<char> CharArray = {'F', 'o', 'o', 'B', 'a', 'r'};
+    std::vector<uint8_t> InvalidChars = {255, 255};
+    W.printBinary("Binary1", "FooBar", IntArray);
+    W.printBinary("Binary2", "FooBar", CharArray);
+    W.printBinary("Binary3", IntArray);
+    W.printBinary("Binary4", CharArray);
+    W.printBinary("Binary5", StringRef("FooBar"));
+    W.printBinary("Binary6", StringRef("Multiple Line FooBar"));
+    W.printBinaryBlock("Binary7", IntArray, 20);
+    W.printBinaryBlock("Binary8", IntArray);
+    W.printBinaryBlock("Binary9", "FooBar");
+    W.printBinaryBlock("Binary10", "Multiple Line FooBar");
+    W.printBinaryBlock("Binary11", InvalidChars);
+  };
+
+  const char *ExpectedOut = R"(Binary1: FooBar (46 6F 6F 42 61 72)
+Binary2: FooBar (46 6F 6F 42 61 72)
+Binary3: (46 6F 6F 42 61 72)
+Binary4: (46 6F 6F 42 61 72)
+Binary5: (46 6F 6F 42 61 72)
+Binary6 (
+  0000: 4D756C74 69706C65 204C696E 6520466F  |Multiple Line Fo|
+  0010: 6F426172                             |oBar|
+)
+Binary7 (
+  0014: 466F6F42 6172                        |FooBar|
+)
+Binary8 (
+  0000: 466F6F42 6172                        |FooBar|
+)
+Binary9 (
+  0000: 466F6F42 6172                        |FooBar|
+)
+Binary10 (
+  0000: 4D756C74 69706C65 204C696E 6520466F  |Multiple Line Fo|
+  0010: 6F426172                             |oBar|
+)
+Binary11 (
+  0000: FFFF                                 |..|
+)
+)";
+  verifyScopedPrinter(ExpectedOut, PrintFunc);
+}
+
+TEST_F(ScopedPrinterTest, PrintObject) {
+  auto PrintFunc = [](ScopedPrinter &W) { W.printObject("Object", "Value"); };
+
+  const char *ExpectedOut = R"(Object: Value
+)";
+  verifyScopedPrinter(ExpectedOut, PrintFunc);
+}
+
+TEST_F(ScopedPrinterTest, StartLine) {
+  auto PrintFunc = [](ScopedPrinter &W) {
+    W.startLine() << "|";
+    W.indent(2);
+    W.startLine() << "|";
+    W.unindent();
+    W.startLine() << "|";
+  };
+
+  const char *ExpectedOut = "|    |  |";
+  verifyScopedPrinter(ExpectedOut, PrintFunc);
+}
+
+TEST_F(ScopedPrinterTest, GetOStream) {
+  auto PrintFunc = [](ScopedPrinter &W) { W.getOStream() << "Test"; };
+
+  const char *ExpectedOut = "Test";
+  verifyScopedPrinter(ExpectedOut, PrintFunc);
+}
+
+TEST_F(ScopedPrinterTest, PrintScope) {
+  auto PrintFunc = [](ScopedPrinter &W) {
+    {
+      DictScope O(W, "Object");
+      { DictScope OO(W, "ObjectInObject"); }
+      { ListScope LO(W, "ListInObject"); }
+    }
+    {
+      ListScope L(W, "List");
+      { DictScope OL(W, "ObjectInList"); }
+      { ListScope LL(W, "ListInList"); }
+    }
+  };
+
+  const char *ExpectedOut = R"(Object {
+  ObjectInObject {
+  }
+  ListInObject [
+  ]
+}
+List [
+  ObjectInList {
+  }
+  ListInList [
+  ]
+]
+)";
+  verifyScopedPrinter(ExpectedOut, PrintFunc);
+}