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