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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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(Fmt: "{0}" , Vals&: Formatter)); |
128 | EXPECT_EQ(0, Count); |
129 | (void)Twine(formatv(Fmt: "{0}" , Vals&: 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 | |