StringRefTest.cpp revision 7e54d5b1562f085c898bf8fcc4ac939ec893444c 
1//===- llvm/unittest/ADT/StringRefTest.cpp - StringRef unit tests ---------===//
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 "gtest/gtest.h"
11#include "llvm/ADT/StringRef.h"
12#include "llvm/ADT/SmallVector.h"
13#include "llvm/Support/raw_ostream.h"
14using namespace llvm;
15
16namespace llvm {
17
18std::ostream &operator<<(std::ostream &OS, const StringRef &S) {
19  OS << S;
20  return OS;
21}
22
23std::ostream &operator<<(std::ostream &OS,
24                         const std::pair<StringRef, StringRef> &P) {
25  OS << "(" << P.first << ", " << P.second << ")";
26  return OS;
27}
28
29}
30
31namespace {
32TEST(StringRefTest, Construction) {
33  EXPECT_EQ("", StringRef());
34  EXPECT_EQ("hello", StringRef("hello"));
35  EXPECT_EQ("hello", StringRef("hello world", 5));
36  EXPECT_EQ("hello", StringRef(std::string("hello")));
37}
38
39TEST(StringRefTest, Iteration) {
40  StringRef S("hello");
41  const char *p = "hello";
42  for (const char *it = S.begin(), *ie = S.end(); it != ie; ++it, ++p)
43    EXPECT_EQ(*it, *p);
44}
45
46TEST(StringRefTest, StringOps) {
47  const char *p = "hello";
48  EXPECT_EQ(p, StringRef(p, 0).data());
49  EXPECT_TRUE(StringRef().empty());
50  EXPECT_EQ((size_t) 5, StringRef("hello").size());
51  EXPECT_EQ(-1, StringRef("aab").compare("aad"));
52  EXPECT_EQ( 0, StringRef("aab").compare("aab"));
53  EXPECT_EQ( 1, StringRef("aab").compare("aaa"));
54  EXPECT_EQ(-1, StringRef("aab").compare("aabb"));
55  EXPECT_EQ( 1, StringRef("aab").compare("aa"));
56}
57
58TEST(StringRefTest, Operators) {
59  EXPECT_EQ("", StringRef());
60  EXPECT_TRUE(StringRef("aab") < StringRef("aad"));
61  EXPECT_FALSE(StringRef("aab") < StringRef("aab"));
62  EXPECT_TRUE(StringRef("aab") <= StringRef("aab"));
63  EXPECT_FALSE(StringRef("aab") <= StringRef("aaa"));
64  EXPECT_TRUE(StringRef("aad") > StringRef("aab"));
65  EXPECT_FALSE(StringRef("aab") > StringRef("aab"));
66  EXPECT_TRUE(StringRef("aab") >= StringRef("aab"));
67  EXPECT_FALSE(StringRef("aaa") >= StringRef("aab"));
68  EXPECT_EQ(StringRef("aab"), StringRef("aab"));
69  EXPECT_FALSE(StringRef("aab") == StringRef("aac"));
70  EXPECT_FALSE(StringRef("aab") != StringRef("aab"));
71  EXPECT_TRUE(StringRef("aab") != StringRef("aac"));
72  EXPECT_EQ('a', StringRef("aab")[1]);
73}
74
75TEST(StringRefTest, Substr) {
76  StringRef Str("hello");
77  EXPECT_EQ("lo", Str.substr(3));
78  EXPECT_EQ("", Str.substr(100));
79  EXPECT_EQ("hello", Str.substr(0, 100));
80  EXPECT_EQ("o", Str.substr(4, 10));
81}
82
83TEST(StringRefTest, Slice) {
84  StringRef Str("hello");
85  EXPECT_EQ("l", Str.slice(2, 3));
86  EXPECT_EQ("ell", Str.slice(1, 4));
87  EXPECT_EQ("llo", Str.slice(2, 100));
88  EXPECT_EQ("", Str.slice(2, 1));
89  EXPECT_EQ("", Str.slice(10, 20));
90}
91
92TEST(StringRefTest, Split) {
93  StringRef Str("hello");
94  EXPECT_EQ(std::make_pair(StringRef("hello"), StringRef("")),
95            Str.split('X'));
96  EXPECT_EQ(std::make_pair(StringRef("h"), StringRef("llo")),
97            Str.split('e'));
98  EXPECT_EQ(std::make_pair(StringRef(""), StringRef("ello")),
99            Str.split('h'));
100  EXPECT_EQ(std::make_pair(StringRef("he"), StringRef("lo")),
101            Str.split('l'));
102  EXPECT_EQ(std::make_pair(StringRef("hell"), StringRef("")),
103            Str.split('o'));
104
105  EXPECT_EQ(std::make_pair(StringRef("hello"), StringRef("")),
106            Str.rsplit('X'));
107  EXPECT_EQ(std::make_pair(StringRef("h"), StringRef("llo")),
108            Str.rsplit('e'));
109  EXPECT_EQ(std::make_pair(StringRef(""), StringRef("ello")),
110            Str.rsplit('h'));
111  EXPECT_EQ(std::make_pair(StringRef("hel"), StringRef("o")),
112            Str.rsplit('l'));
113  EXPECT_EQ(std::make_pair(StringRef("hell"), StringRef("")),
114            Str.rsplit('o'));
115}
116
117TEST(StringRefTest, Split2) {
118  SmallVector<StringRef, 5> parts;
119  SmallVector<StringRef, 5> expected;
120
121  expected.push_back("ab"); expected.push_back("c");
122  StringRef(",ab,,c,").split(parts, ",", -1, false);
123  EXPECT_TRUE(parts == expected);
124
125  expected.clear(); parts.clear();
126  expected.push_back(""); expected.push_back("ab"); expected.push_back("");
127  expected.push_back("c"); expected.push_back("");
128  StringRef(",ab,,c,").split(parts, ",", -1, true);
129  EXPECT_TRUE(parts == expected);
130
131  expected.clear(); parts.clear();
132  expected.push_back("");
133  StringRef("").split(parts, ",", -1, true);
134  EXPECT_TRUE(parts == expected);
135
136  expected.clear(); parts.clear();
137  StringRef("").split(parts, ",", -1, false);
138  EXPECT_TRUE(parts == expected);
139
140  expected.clear(); parts.clear();
141  StringRef(",").split(parts, ",", -1, false);
142  EXPECT_TRUE(parts == expected);
143
144  expected.clear(); parts.clear();
145  expected.push_back(""); expected.push_back("");
146  StringRef(",").split(parts, ",", -1, true);
147  EXPECT_TRUE(parts == expected);
148
149  expected.clear(); parts.clear();
150  expected.push_back("a"); expected.push_back("b");
151  StringRef("a,b").split(parts, ",", -1, true);
152  EXPECT_TRUE(parts == expected);
153
154  // Test MaxSplit
155  expected.clear(); parts.clear();
156  expected.push_back("a,,b,c");
157  StringRef("a,,b,c").split(parts, ",", 0, true);
158  EXPECT_TRUE(parts == expected);
159
160  expected.clear(); parts.clear();
161  expected.push_back("a,,b,c");
162  StringRef("a,,b,c").split(parts, ",", 0, false);
163  EXPECT_TRUE(parts == expected);
164
165  expected.clear(); parts.clear();
166  expected.push_back("a"); expected.push_back(",b,c");
167  StringRef("a,,b,c").split(parts, ",", 1, true);
168  EXPECT_TRUE(parts == expected);
169
170  expected.clear(); parts.clear();
171  expected.push_back("a"); expected.push_back(",b,c");
172  StringRef("a,,b,c").split(parts, ",", 1, false);
173  EXPECT_TRUE(parts == expected);
174
175  expected.clear(); parts.clear();
176  expected.push_back("a"); expected.push_back(""); expected.push_back("b,c");
177  StringRef("a,,b,c").split(parts, ",", 2, true);
178  EXPECT_TRUE(parts == expected);
179
180  expected.clear(); parts.clear();
181  expected.push_back("a"); expected.push_back("b,c");
182  StringRef("a,,b,c").split(parts, ",", 2, false);
183  EXPECT_TRUE(parts == expected);
184
185  expected.clear(); parts.clear();
186  expected.push_back("a"); expected.push_back(""); expected.push_back("b");
187  expected.push_back("c");
188  StringRef("a,,b,c").split(parts, ",", 3, true);
189  EXPECT_TRUE(parts == expected);
190
191  expected.clear(); parts.clear();
192  expected.push_back("a"); expected.push_back("b"); expected.push_back("c");
193  StringRef("a,,b,c").split(parts, ",", 3, false);
194  EXPECT_TRUE(parts == expected);
195}
196
197TEST(StringRefTest, StartsWith) {
198  StringRef Str("hello");
199  EXPECT_TRUE(Str.startswith("he"));
200  EXPECT_FALSE(Str.startswith("helloworld"));
201  EXPECT_FALSE(Str.startswith("hi"));
202}
203
204TEST(StringRefTest, EndsWith) {
205  StringRef Str("hello");
206  EXPECT_TRUE(Str.endswith("lo"));
207  EXPECT_FALSE(Str.endswith("helloworld"));
208  EXPECT_FALSE(Str.endswith("worldhello"));
209  EXPECT_FALSE(Str.endswith("so"));
210}
211
212TEST(StringRefTest, Find) {
213  StringRef Str("hello");
214  EXPECT_EQ(2U, Str.find('l'));
215  EXPECT_EQ(StringRef::npos, Str.find('z'));
216  EXPECT_EQ(StringRef::npos, Str.find("helloworld"));
217  EXPECT_EQ(0U, Str.find("hello"));
218  EXPECT_EQ(1U, Str.find("ello"));
219  EXPECT_EQ(StringRef::npos, Str.find("zz"));
220  EXPECT_EQ(2U, Str.find("ll", 2));
221  EXPECT_EQ(StringRef::npos, Str.find("ll", 3));
222
223  EXPECT_EQ(3U, Str.rfind('l'));
224  EXPECT_EQ(StringRef::npos, Str.rfind('z'));
225  EXPECT_EQ(StringRef::npos, Str.rfind("helloworld"));
226  EXPECT_EQ(0U, Str.rfind("hello"));
227  EXPECT_EQ(1U, Str.rfind("ello"));
228  EXPECT_EQ(StringRef::npos, Str.rfind("zz"));
229
230  EXPECT_EQ(2U, Str.find_first_of('l'));
231  EXPECT_EQ(1U, Str.find_first_of("el"));
232  EXPECT_EQ(StringRef::npos, Str.find_first_of("xyz"));
233
234  EXPECT_EQ(1U, Str.find_first_not_of('h'));
235  EXPECT_EQ(4U, Str.find_first_not_of("hel"));
236  EXPECT_EQ(StringRef::npos, Str.find_first_not_of("hello"));
237}
238
239TEST(StringRefTest, Count) {
240  StringRef Str("hello");
241  EXPECT_EQ(2U, Str.count('l'));
242  EXPECT_EQ(1U, Str.count('o'));
243  EXPECT_EQ(0U, Str.count('z'));
244  EXPECT_EQ(0U, Str.count("helloworld"));
245  EXPECT_EQ(1U, Str.count("hello"));
246  EXPECT_EQ(1U, Str.count("ello"));
247  EXPECT_EQ(0U, Str.count("zz"));
248}
249
250TEST(StringRefTest, EditDistance) {
251  StringRef Str("hello");
252  EXPECT_EQ(2, Str.edit_distance("hill"));
253}
254
255TEST(StringRefTest, Misc) {
256  std::string Storage;
257  raw_string_ostream OS(Storage);
258  OS << StringRef("hello");
259  EXPECT_EQ("hello", OS.str());
260}
261
262} // end anonymous namespace
263