| 1 |
//===- StringExtrasTest.cpp - Unit tests for String extras ----------------===// |
| 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/StringExtras.h" |
| 10 |
#include "llvm/Support/raw_ostream.h" |
| 11 |
#include "gmock/gmock.h" |
| 12 |
#include "gtest/gtest.h" |
| 13 |
|
| 14 |
using namespace llvm; |
| 15 |
|
| 16 |
TEST(StringExtrasTest, isPrint) { |
| 17 |
EXPECT_FALSE(isPrint('\0')); |
| 18 |
EXPECT_FALSE(isPrint('\t')); |
| 19 |
EXPECT_TRUE(isPrint('0')); |
| 20 |
EXPECT_TRUE(isPrint('a')); |
| 21 |
EXPECT_TRUE(isPrint('A')); |
| 22 |
EXPECT_TRUE(isPrint(' ')); |
| 23 |
EXPECT_TRUE(isPrint('~')); |
| 24 |
EXPECT_TRUE(isPrint('?')); |
| 25 |
} |
| 26 |
|
| 27 |
TEST(StringExtrasTest, isSpace) { |
| 28 |
EXPECT_TRUE(isSpace(' ')); |
| 29 |
EXPECT_TRUE(isSpace('\t')); |
| 30 |
EXPECT_TRUE(isSpace('\n')); |
| 31 |
EXPECT_TRUE(isSpace('\v')); |
| 32 |
EXPECT_TRUE(isSpace('\f')); |
| 33 |
EXPECT_TRUE(isSpace('\v')); |
| 34 |
EXPECT_FALSE(isSpace('\0')); |
| 35 |
EXPECT_FALSE(isSpace('_')); |
| 36 |
} |
| 37 |
|
| 38 |
TEST(StringExtrasTest, Join) { |
| 39 |
std::vector<std::string> Items; |
| 40 |
EXPECT_EQ("", join(Items.begin(), Items.end(), " <sep> ")); |
| 41 |
|
| 42 |
Items = {"foo"}; |
| 43 |
EXPECT_EQ("foo", join(Items.begin(), Items.end(), " <sep> ")); |
| 44 |
|
| 45 |
Items = {"foo", "bar"}; |
| 46 |
EXPECT_EQ("foo <sep> bar", join(Items.begin(), Items.end(), " <sep> ")); |
| 47 |
|
| 48 |
Items = {"foo", "bar", "baz"}; |
| 49 |
EXPECT_EQ("foo <sep> bar <sep> baz", |
| 50 |
join(Items.begin(), Items.end(), " <sep> ")); |
| 51 |
} |
| 52 |
|
| 53 |
TEST(StringExtrasTest, JoinItems) { |
| 54 |
const char *Foo = "foo"; |
| 55 |
std::string Bar = "bar"; |
| 56 |
llvm::StringRef Baz = "baz"; |
| 57 |
char X = 'x'; |
| 58 |
|
| 59 |
EXPECT_EQ("", join_items(" <sep> ")); |
| 60 |
EXPECT_EQ("", join_items('/')); |
| 61 |
|
| 62 |
EXPECT_EQ("foo", join_items(" <sep> ", Foo)); |
| 63 |
EXPECT_EQ("foo", join_items('/', Foo)); |
| 64 |
|
| 65 |
EXPECT_EQ("foo <sep> bar", join_items(" <sep> ", Foo, Bar)); |
| 66 |
EXPECT_EQ("foo/bar", join_items('/', Foo, Bar)); |
| 67 |
|
| 68 |
EXPECT_EQ("foo <sep> bar <sep> baz", join_items(" <sep> ", Foo, Bar, Baz)); |
| 69 |
EXPECT_EQ("foo/bar/baz", join_items('/', Foo, Bar, Baz)); |
| 70 |
|
| 71 |
EXPECT_EQ("foo <sep> bar <sep> baz <sep> x", |
| 72 |
join_items(" <sep> ", Foo, Bar, Baz, X)); |
| 73 |
|
| 74 |
EXPECT_EQ("foo/bar/baz/x", join_items('/', Foo, Bar, Baz, X)); |
| 75 |
} |
| 76 |
|
| 77 |
TEST(StringExtrasTest, ToAndFromHex) { |
| 78 |
std::vector<uint8_t> OddBytes = {0x5, 0xBD, 0x0D, 0x3E, 0xCD}; |
| 79 |
std::string OddStr = "05BD0D3ECD"; |
| 80 |
StringRef OddData(reinterpret_cast<const char *>(OddBytes.data()), |
| 81 |
OddBytes.size()); |
| 82 |
EXPECT_EQ(OddStr, toHex(OddData)); |
| 83 |
EXPECT_EQ(OddData, fromHex(StringRef(OddStr).drop_front())); |
| 84 |
EXPECT_EQ(StringRef(OddStr).lower(), toHex(OddData, true)); |
| 85 |
|
| 86 |
std::vector<uint8_t> EvenBytes = {0xA5, 0xBD, 0x0D, 0x3E, 0xCD}; |
| 87 |
std::string EvenStr = "A5BD0D3ECD"; |
| 88 |
StringRef EvenData(reinterpret_cast<const char *>(EvenBytes.data()), |
| 89 |
EvenBytes.size()); |
| 90 |
EXPECT_EQ(EvenStr, toHex(EvenData)); |
| 91 |
EXPECT_EQ(EvenData, fromHex(EvenStr)); |
| 92 |
EXPECT_EQ(StringRef(EvenStr).lower(), toHex(EvenData, true)); |
| 93 |
|
| 94 |
std::string InvalidStr = "A50\xFF"; |
| 95 |
std::string IgnoredOutput; |
| 96 |
EXPECT_FALSE(tryGetFromHex(InvalidStr, IgnoredOutput)); |
| 97 |
} |
| 98 |
|
| 99 |
TEST(StringExtrasTest, UINT64ToHex) { |
| 100 |
EXPECT_EQ(utohexstr(0xA0u), "A0"); |
| 101 |
EXPECT_EQ(utohexstr(0xA0u, false, 4), "00A0"); |
| 102 |
EXPECT_EQ(utohexstr(0xA0u, false, 8), "000000A0"); |
| 103 |
} |
| 104 |
|
| 105 |
TEST(StringExtrasTest, to_float) { |
| 106 |
float F; |
| 107 |
EXPECT_TRUE(to_float("4.7", F)); |
| 108 |
EXPECT_FLOAT_EQ(4.7f, F); |
| 109 |
|
| 110 |
double D; |
| 111 |
EXPECT_TRUE(to_float("4.7", D)); |
| 112 |
EXPECT_DOUBLE_EQ(4.7, D); |
| 113 |
|
| 114 |
long double LD; |
| 115 |
EXPECT_TRUE(to_float("4.7", LD)); |
| 116 |
EXPECT_DOUBLE_EQ(4.7, LD); |
| 117 |
|
| 118 |
EXPECT_FALSE(to_float("foo", F)); |
| 119 |
EXPECT_FALSE(to_float("7.4 foo", F)); |
| 120 |
EXPECT_FLOAT_EQ(4.7f, F); // F should be unchanged |
| 121 |
} |
| 122 |
|
| 123 |
TEST(StringExtrasTest, printLowerCase) { |
| 124 |
std::string str; |
| 125 |
raw_string_ostream OS(str); |
| 126 |
printLowerCase("ABCdefg01234.,&!~`'}\"", OS); |
| 127 |
EXPECT_EQ("abcdefg01234.,&!~`'}\"", OS.str()); |
| 128 |
} |
| 129 |
|
| 130 |
TEST(StringExtrasTest, printEscapedString) { |
| 131 |
std::string str; |
| 132 |
raw_string_ostream OS(str); |
| 133 |
printEscapedString("ABCdef123&<>\\\"'\t", OS); |
| 134 |
EXPECT_EQ("ABCdef123&<>\\\\\\22'\\09", OS.str()); |
| 135 |
} |
| 136 |
|
| 137 |
TEST(StringExtrasTest, printHTMLEscaped) { |
| 138 |
std::string str; |
| 139 |
raw_string_ostream OS(str); |
| 140 |
printHTMLEscaped("ABCdef123&<>\"'", OS); |
| 141 |
EXPECT_EQ("ABCdef123&<>"'", OS.str()); |
| 142 |
} |
| 143 |
|
| 144 |
TEST(StringExtrasTest, ConvertToSnakeFromCamelCase) { |
| 145 |
auto testConvertToSnakeCase = [](llvm::StringRef input, |
| 146 |
llvm::StringRef expected) { |
| 147 |
EXPECT_EQ(convertToSnakeFromCamelCase(input), expected.str()); |
| 148 |
}; |
| 149 |
|
| 150 |
testConvertToSnakeCase("OpName", "op_name"); |
| 151 |
testConvertToSnakeCase("opName", "op_name"); |
| 152 |
testConvertToSnakeCase("_OpName", "_op_name"); |
| 153 |
testConvertToSnakeCase("Op_Name", "op_name"); |
| 154 |
testConvertToSnakeCase("", ""); |
| 155 |
testConvertToSnakeCase("A", "a"); |
| 156 |
testConvertToSnakeCase("_", "_"); |
| 157 |
testConvertToSnakeCase("a", "a"); |
| 158 |
testConvertToSnakeCase("op_name", "op_name"); |
| 159 |
testConvertToSnakeCase("_op_name", "_op_name"); |
| 160 |
testConvertToSnakeCase("__op_name", "__op_name"); |
| 161 |
testConvertToSnakeCase("op__name", "op__name"); |
| 162 |
} |
| 163 |
|
| 164 |
TEST(StringExtrasTest, ConvertToCamelFromSnakeCase) { |
| 165 |
auto testConvertToCamelCase = [](bool capitalizeFirst, llvm::StringRef input, |
| 166 |
llvm::StringRef expected) { |
| 167 |
EXPECT_EQ(convertToCamelFromSnakeCase(input, capitalizeFirst), |
| 168 |
expected.str()); |
| 169 |
}; |
| 170 |
|
| 171 |
testConvertToCamelCase(false, "op_name", "opName"); |
| 172 |
testConvertToCamelCase(false, "_op_name", "_opName"); |
| 173 |
testConvertToCamelCase(false, "__op_name", "_OpName"); |
| 174 |
testConvertToCamelCase(false, "op__name", "op_Name"); |
| 175 |
testConvertToCamelCase(false, "", ""); |
| 176 |
testConvertToCamelCase(false, "A", "A"); |
| 177 |
testConvertToCamelCase(false, "_", "_"); |
| 178 |
testConvertToCamelCase(false, "a", "a"); |
| 179 |
testConvertToCamelCase(false, "OpName", "OpName"); |
| 180 |
testConvertToCamelCase(false, "opName", "opName"); |
| 181 |
testConvertToCamelCase(false, "_OpName", "_OpName"); |
| 182 |
testConvertToCamelCase(false, "Op_Name", "Op_Name"); |
| 183 |
testConvertToCamelCase(true, "op_name", "OpName"); |
| 184 |
testConvertToCamelCase(true, "_op_name", "_opName"); |
| 185 |
testConvertToCamelCase(true, "__op_name", "_OpName"); |
| 186 |
testConvertToCamelCase(true, "op__name", "Op_Name"); |
| 187 |
testConvertToCamelCase(true, "", ""); |
| 188 |
testConvertToCamelCase(true, "A", "A"); |
| 189 |
testConvertToCamelCase(true, "_", "_"); |
| 190 |
testConvertToCamelCase(true, "a", "A"); |
| 191 |
testConvertToCamelCase(true, "OpName", "OpName"); |
| 192 |
testConvertToCamelCase(true, "_OpName", "_OpName"); |
| 193 |
testConvertToCamelCase(true, "Op_Name", "Op_Name"); |
| 194 |
testConvertToCamelCase(true, "opName", "OpName"); |
| 195 |
} |
| 196 |
|
| 197 |
constexpr uint64_t MaxUint64 = std::numeric_limits<uint64_t>::max(); |
| 198 |
constexpr int64_t MaxInt64 = std::numeric_limits<int64_t>::max(); |
| 199 |
constexpr int64_t MinInt64 = std::numeric_limits<int64_t>::min(); |
| 200 |
|
| 201 |
TEST(StringExtrasTest, UToStr) { |
| 202 |
EXPECT_EQ("0", utostr(0)); |
| 203 |
EXPECT_EQ("0", utostr(0, /*isNeg=*/false)); |
| 204 |
EXPECT_EQ("1", utostr(1)); |
| 205 |
EXPECT_EQ("1", utostr(1, /*isNeg=*/false)); |
| 206 |
EXPECT_EQ(std::to_string(MaxUint64), utostr(MaxUint64)); |
| 207 |
EXPECT_EQ(std::to_string(MaxUint64), utostr(MaxUint64, /*isNeg=*/false)); |
| 208 |
|
| 209 |
EXPECT_EQ("-0", utostr(0, /*isNeg=*/true)); |
| 210 |
EXPECT_EQ("-1", utostr(1, /*isNeg=*/true)); |
| 211 |
EXPECT_EQ("-" + std::to_string(MaxInt64), utostr(MaxInt64, /*isNeg=*/true)); |
| 212 |
constexpr uint64_t MinusMinInt64 = -static_cast<uint64_t>(MinInt64); |
| 213 |
EXPECT_EQ("-" + std::to_string(MinusMinInt64), |
| 214 |
utostr(MinusMinInt64, /*isNeg=*/true)); |
| 215 |
EXPECT_EQ("-" + std::to_string(MaxUint64), utostr(MaxUint64, /*isNeg=*/true)); |
| 216 |
} |
| 217 |
|
| 218 |
TEST(StringExtrasTest, IToStr) { |
| 219 |
EXPECT_EQ("0", itostr(0)); |
| 220 |
EXPECT_EQ("1", itostr(1)); |
| 221 |
EXPECT_EQ("-1", itostr(-1)); |
| 222 |
EXPECT_EQ(std::to_string(MinInt64), itostr(MinInt64)); |
| 223 |
EXPECT_EQ(std::to_string(MaxInt64), itostr(MaxInt64)); |
| 224 |
} |
| 225 |
|
| 226 |
TEST(StringExtrasTest, ListSeparator) { |
| 227 |
ListSeparator LS; |
| 228 |
StringRef S = LS; |
| 229 |
EXPECT_EQ(S, ""); |
| 230 |
S = LS; |
| 231 |
EXPECT_EQ(S, ", "); |
| 232 |
|
| 233 |
ListSeparator LS2(" "); |
| 234 |
S = LS2; |
| 235 |
EXPECT_EQ(S, ""); |
| 236 |
S = LS2; |
| 237 |
EXPECT_EQ(S, " "); |
| 238 |
} |
| 239 |
|
| 240 |
TEST(StringExtrasTest, toStringAPInt) { |
| 241 |
bool isSigned; |
| 242 |
|
| 243 |
EXPECT_EQ(toString(APInt(8, 0), 2, true, true), "0b0"); |
| 244 |
EXPECT_EQ(toString(APInt(8, 0), 8, true, true), "00"); |
| 245 |
EXPECT_EQ(toString(APInt(8, 0), 10, true, true), "0"); |
| 246 |
EXPECT_EQ(toString(APInt(8, 0), 16, true, true), "0x0"); |
| 247 |
EXPECT_EQ(toString(APInt(8, 0), 36, true, false), "0"); |
| 248 |
|
| 249 |
isSigned = false; |
| 250 |
EXPECT_EQ(toString(APInt(8, 255, isSigned), 2, isSigned, true), "0b11111111"); |
| 251 |
EXPECT_EQ(toString(APInt(8, 255, isSigned), 8, isSigned, true), "0377"); |
| 252 |
EXPECT_EQ(toString(APInt(8, 255, isSigned), 10, isSigned, true), "255"); |
| 253 |
EXPECT_EQ(toString(APInt(8, 255, isSigned), 16, isSigned, true), "0xFF"); |
| 254 |
EXPECT_EQ(toString(APInt(8, 255, isSigned), 36, isSigned, false), "73"); |
| 255 |
|
| 256 |
isSigned = true; |
| 257 |
EXPECT_EQ(toString(APInt(8, 255, isSigned), 2, isSigned, true), "-0b1"); |
| 258 |
EXPECT_EQ(toString(APInt(8, 255, isSigned), 8, isSigned, true), "-01"); |
| 259 |
EXPECT_EQ(toString(APInt(8, 255, isSigned), 10, isSigned, true), "-1"); |
| 260 |
EXPECT_EQ(toString(APInt(8, 255, isSigned), 16, isSigned, true), "-0x1"); |
| 261 |
EXPECT_EQ(toString(APInt(8, 255, isSigned), 36, isSigned, false), "-1"); |
| 262 |
} |
| 263 |
|
| 264 |
TEST(StringExtrasTest, toStringAPSInt) { |
| 265 |
bool isUnsigned; |
| 266 |
|
| 267 |
EXPECT_EQ(toString(APSInt(APInt(8, 0), false), 2), "0"); |
| 268 |
EXPECT_EQ(toString(APSInt(APInt(8, 0), false), 8), "0"); |
| 269 |
EXPECT_EQ(toString(APSInt(APInt(8, 0), false), 10), "0"); |
| 270 |
EXPECT_EQ(toString(APSInt(APInt(8, 0), false), 16), "0"); |
| 271 |
|
| 272 |
isUnsigned = true; |
| 273 |
EXPECT_EQ(toString(APSInt(APInt(8, 255), isUnsigned), 2), "11111111"); |
| 274 |
EXPECT_EQ(toString(APSInt(APInt(8, 255), isUnsigned), 8), "377"); |
| 275 |
EXPECT_EQ(toString(APSInt(APInt(8, 255), isUnsigned), 10), "255"); |
| 276 |
EXPECT_EQ(toString(APSInt(APInt(8, 255), isUnsigned), 16), "FF"); |
| 277 |
|
| 278 |
isUnsigned = false; |
| 279 |
EXPECT_EQ(toString(APSInt(APInt(8, 255), isUnsigned), 2), "-1"); |
| 280 |
EXPECT_EQ(toString(APSInt(APInt(8, 255), isUnsigned), 8), "-1"); |
| 281 |
EXPECT_EQ(toString(APSInt(APInt(8, 255), isUnsigned), 10), "-1"); |
| 282 |
EXPECT_EQ(toString(APSInt(APInt(8, 255), isUnsigned), 16), "-1"); |
| 283 |
} |
| 284 |
|
| 285 |
TEST(StringExtrasTest, splitStringRef) { |
| 286 |
auto Spl = split("foo<=>bar<=><=>baz", "<=>"); |
| 287 |
auto It = Spl.begin(); |
| 288 |
auto End = Spl.end(); |
| 289 |
|
| 290 |
ASSERT_NE(It, End); |
| 291 |
EXPECT_EQ(*It, StringRef("foo")); |
| 292 |
ASSERT_NE(++It, End); |
| 293 |
EXPECT_EQ(*It, StringRef("bar")); |
| 294 |
ASSERT_NE(++It, End); |
| 295 |
EXPECT_EQ(*It, StringRef("")); |
| 296 |
ASSERT_NE(++It, End); |
| 297 |
EXPECT_EQ(*It, StringRef("baz")); |
| 298 |
ASSERT_EQ(++It, End); |
| 299 |
} |
| 300 |
|
| 301 |
TEST(StringExtrasTest, splitStringRefForLoop) { |
| 302 |
llvm::SmallVector<StringRef, 4> Result; |
| 303 |
for (StringRef x : split("foo<=>bar<=><=>baz", "<=>")) |
| 304 |
Result.push_back(x); |
| 305 |
EXPECT_THAT(Result, testing::ElementsAre("foo", "bar", "", "baz")); |
| 306 |
} |
| 307 |
|
| 308 |
TEST(StringExtrasTest, splitChar) { |
| 309 |
auto Spl = split("foo,bar,,baz", ','); |
| 310 |
auto It = Spl.begin(); |
| 311 |
auto End = Spl.end(); |
| 312 |
|
| 313 |
ASSERT_NE(It, End); |
| 314 |
EXPECT_EQ(*It, StringRef("foo")); |
| 315 |
ASSERT_NE(++It, End); |
| 316 |
EXPECT_EQ(*It, StringRef("bar")); |
| 317 |
ASSERT_NE(++It, End); |
| 318 |
EXPECT_EQ(*It, StringRef("")); |
| 319 |
ASSERT_NE(++It, End); |
| 320 |
EXPECT_EQ(*It, StringRef("baz")); |
| 321 |
ASSERT_EQ(++It, End); |
| 322 |
} |
| 323 |
|
| 324 |
TEST(StringExtrasTest, splitCharForLoop) { |
| 325 |
llvm::SmallVector<StringRef, 4> Result; |
| 326 |
for (StringRef x : split("foo,bar,,baz", ',')) |
| 327 |
Result.push_back(x); |
| 328 |
EXPECT_THAT(Result, testing::ElementsAre("foo", "bar", "", "baz")); |
| 329 |
} |