1 //===- TwineTest.cpp - Twine unit 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/Twine.h"
10 #include "llvm/ADT/SmallString.h"
11 #include "llvm/Support/FormatAdapters.h"
12 #include "llvm/Support/FormatVariadic.h"
13 #include "llvm/Support/raw_ostream.h"
14 #include "gtest/gtest.h"
15 using namespace llvm;
16
17 namespace {
18
repr(const Twine & Value)19 std::string repr(const Twine &Value) {
20 std::string res;
21 llvm::raw_string_ostream OS(res);
22 Value.printRepr(OS);
23 return OS.str();
24 }
25
TEST(TwineTest,Construction)26 TEST(TwineTest, Construction) {
27 EXPECT_EQ("", Twine().str());
28 EXPECT_EQ("hi", Twine("hi").str());
29 EXPECT_EQ("hi", Twine(std::string("hi")).str());
30 EXPECT_EQ("hi", Twine(StringRef("hi")).str());
31 EXPECT_EQ("hi", Twine(StringRef(std::string("hi"))).str());
32 EXPECT_EQ("hi", Twine(StringRef("hithere", 2)).str());
33 EXPECT_EQ("hi", Twine(StringLiteral("hi")).str());
34 EXPECT_EQ("hi", Twine(SmallString<4>("hi")).str());
35 EXPECT_EQ("hi", Twine(formatv("{0}", "hi")).str());
36 EXPECT_EQ("hi", Twine(std::string_view("hi")).str());
37 }
38
TEST(TwineTest,Numbers)39 TEST(TwineTest, Numbers) {
40 EXPECT_EQ("123", Twine(123U).str());
41 EXPECT_EQ("123", Twine(123).str());
42 EXPECT_EQ("-123", Twine(-123).str());
43 EXPECT_EQ("123", Twine(123).str());
44 EXPECT_EQ("-123", Twine(-123).str());
45
46 EXPECT_EQ("7b", Twine::utohexstr(123).str());
47 }
48
TEST(TwineTest,Characters)49 TEST(TwineTest, Characters) {
50 EXPECT_EQ("x", Twine('x').str());
51 EXPECT_EQ("x", Twine(static_cast<unsigned char>('x')).str());
52 EXPECT_EQ("x", Twine(static_cast<signed char>('x')).str());
53 }
54
TEST(TwineTest,Concat)55 TEST(TwineTest, Concat) {
56 // Check verse repr, since we care about the actual representation not just
57 // the result.
58
59 // Concat with null.
60 EXPECT_EQ("(Twine null empty)",
61 repr(Twine("hi").concat(Twine::createNull())));
62 EXPECT_EQ("(Twine null empty)",
63 repr(Twine::createNull().concat(Twine("hi"))));
64
65 // Concat with empty.
66 EXPECT_EQ("(Twine cstring:\"hi\" empty)",
67 repr(Twine("hi").concat(Twine())));
68 EXPECT_EQ("(Twine cstring:\"hi\" empty)",
69 repr(Twine().concat(Twine("hi"))));
70 EXPECT_EQ("(Twine ptrAndLength:\"hi\" empty)",
71 repr(Twine().concat(Twine(SmallString<5>("hi")))));
72 EXPECT_EQ("(Twine formatv:\"howdy\" empty)",
73 repr(Twine(formatv("howdy")).concat(Twine())));
74 EXPECT_EQ("(Twine formatv:\"howdy\" empty)",
75 repr(Twine().concat(Twine(formatv("howdy")))));
76 EXPECT_EQ("(Twine ptrAndLength:\"hey\" cstring:\"there\")",
77 repr(Twine(SmallString<7>("hey")).concat(Twine("there"))));
78 EXPECT_EQ("(Twine ptrAndLength:\"hey\" cstring:\"there\")",
79 repr(Twine(std::string_view("hey")).concat(Twine("there"))));
80
81 // Concatenation of unary ropes.
82 EXPECT_EQ("(Twine cstring:\"a\" cstring:\"b\")",
83 repr(Twine("a").concat(Twine("b"))));
84
85 // Concatenation of other ropes.
86 EXPECT_EQ("(Twine rope:(Twine cstring:\"a\" cstring:\"b\") cstring:\"c\")",
87 repr(Twine("a").concat(Twine("b")).concat(Twine("c"))));
88 EXPECT_EQ("(Twine cstring:\"a\" rope:(Twine cstring:\"b\" cstring:\"c\"))",
89 repr(Twine("a").concat(Twine("b").concat(Twine("c")))));
90 EXPECT_EQ(
91 "(Twine cstring:\"a\" rope:(Twine ptrAndLength:\"b\" cstring:\"c\"))",
92 repr(Twine("a").concat(Twine(SmallString<3>("b")).concat(Twine("c")))));
93 }
94
TEST(TwineTest,toNullTerminatedStringRef)95 TEST(TwineTest, toNullTerminatedStringRef) {
96 SmallString<8> storage;
97 EXPECT_EQ(0, *Twine("hello").toNullTerminatedStringRef(storage).end());
98 EXPECT_EQ(0,
99 *Twine(StringRef("hello")).toNullTerminatedStringRef(storage).end());
100 EXPECT_EQ(
101 0,
102 *Twine(StringLiteral("hello")).toNullTerminatedStringRef(storage).end());
103 EXPECT_EQ(0, *Twine(SmallString<11>("hello"))
104 .toNullTerminatedStringRef(storage)
105 .end());
106 EXPECT_EQ(0, *Twine(formatv("{0}{1}", "how", "dy"))
107 .toNullTerminatedStringRef(storage)
108 .end());
109 }
110
TEST(TwineTest,isSingleStringLiteral)111 TEST(TwineTest, isSingleStringLiteral) {
112 EXPECT_TRUE(Twine(StringLiteral("hi")).isSingleStringLiteral());
113 EXPECT_FALSE(Twine("hi").isSingleStringLiteral());
114 EXPECT_FALSE(Twine(StringRef("hi")).isSingleStringLiteral());
115 }
116
TEST(TwineTest,LazyEvaluation)117 TEST(TwineTest, LazyEvaluation) {
118 struct formatter : FormatAdapter<int> {
119 explicit formatter(int &Count) : FormatAdapter(0), Count(Count) {}
120 int &Count;
121
122 void format(raw_ostream &OS, StringRef Style) override { ++Count; }
123 };
124
125 int Count = 0;
126 formatter Formatter(Count);
127 (void)Twine(formatv("{0}", Formatter));
128 EXPECT_EQ(0, Count);
129 (void)Twine(formatv("{0}", Formatter)).str();
130 EXPECT_EQ(1, Count);
131 }
132
133 // I suppose linking in the entire code generator to add a unit test to check
134 // the code size of the concat operation is overkill... :)
135
136 } // end anonymous namespace
137