1//===- llvm/unittest/ADT/StringSwitchTest.cpp - StringSwitch 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/StringSwitch.h"
10#include "gtest/gtest.h"
11
12using namespace llvm;
13
14TEST(StringSwitchTest, Case) {
15 auto Translate = [](StringRef S) {
16 return llvm::StringSwitch<int>(S)
17 .Case(S: "0", Value: 0)
18 .Case(S: "1", Value: 1)
19 .Case(S: "2", Value: 2)
20 .Case(S: "3", Value: 3)
21 .Case(S: "4", Value: 4)
22 .Case(S: "5", Value: 5)
23 .Case(S: "6", Value: 6)
24 .Case(S: "7", Value: 7)
25 .Case(S: "8", Value: 8)
26 .Case(S: "9", Value: 9)
27 .Case(S: "A", Value: 10)
28 .Case(S: "B", Value: 11)
29 .Case(S: "C", Value: 12)
30 .Case(S: "D", Value: 13)
31 .Case(S: "E", Value: 14)
32 .Case(S: "F", Value: 15)
33 .Default(Value: -1);
34 };
35 EXPECT_EQ(1, Translate("1"));
36 EXPECT_EQ(2, Translate("2"));
37 EXPECT_EQ(11, Translate("B"));
38 EXPECT_EQ(-1, Translate("b"));
39 EXPECT_EQ(-1, Translate(""));
40 EXPECT_EQ(-1, Translate("Test"));
41}
42
43TEST(StringSwitchTest, CaseLower) {
44 auto Translate = [](StringRef S) {
45 return llvm::StringSwitch<int>(S)
46 .Case(S: "0", Value: 0)
47 .Case(S: "1", Value: 1)
48 .Case(S: "2", Value: 2)
49 .Case(S: "3", Value: 3)
50 .Case(S: "4", Value: 4)
51 .Case(S: "5", Value: 5)
52 .Case(S: "6", Value: 6)
53 .Case(S: "7", Value: 7)
54 .Case(S: "8", Value: 8)
55 .Case(S: "9", Value: 9)
56 .CaseLower(S: "A", Value: 10)
57 .CaseLower(S: "B", Value: 11)
58 .CaseLower(S: "C", Value: 12)
59 .CaseLower(S: "D", Value: 13)
60 .CaseLower(S: "E", Value: 14)
61 .CaseLower(S: "F", Value: 15)
62 .Default(Value: -1);
63 };
64 EXPECT_EQ(1, Translate("1"));
65 EXPECT_EQ(2, Translate("2"));
66 EXPECT_EQ(11, Translate("B"));
67 EXPECT_EQ(11, Translate("b"));
68
69 EXPECT_EQ(-1, Translate(""));
70 EXPECT_EQ(-1, Translate("Test"));
71}
72
73TEST(StringSwitchTest, StartsWith) {
74 auto Translate = [](StringRef S) {
75 return llvm::StringSwitch<std::function<int(int, int)>>(S)
76 .StartsWith(S: "add", Value: [](int X, int Y) { return X + Y; })
77 .StartsWith(S: "sub", Value: [](int X, int Y) { return X - Y; })
78 .StartsWith(S: "mul", Value: [](int X, int Y) { return X * Y; })
79 .StartsWith(S: "div", Value: [](int X, int Y) { return X / Y; })
80 .Default(Value: [](int X, int Y) { return 0; });
81 };
82
83 EXPECT_EQ(15, Translate("adder")(10, 5));
84 EXPECT_EQ(5, Translate("subtracter")(10, 5));
85 EXPECT_EQ(50, Translate("multiplier")(10, 5));
86 EXPECT_EQ(2, Translate("divider")(10, 5));
87
88 EXPECT_EQ(0, Translate("nothing")(10, 5));
89 EXPECT_EQ(0, Translate("ADDER")(10, 5));
90}
91
92TEST(StringSwitchTest, StartsWithLower) {
93 auto Translate = [](StringRef S) {
94 return llvm::StringSwitch<std::function<int(int, int)>>(S)
95 .StartsWithLower(S: "add", Value: [](int X, int Y) { return X + Y; })
96 .StartsWithLower(S: "sub", Value: [](int X, int Y) { return X - Y; })
97 .StartsWithLower(S: "mul", Value: [](int X, int Y) { return X * Y; })
98 .StartsWithLower(S: "div", Value: [](int X, int Y) { return X / Y; })
99 .Default(Value: [](int X, int Y) { return 0; });
100 };
101
102 EXPECT_EQ(15, Translate("adder")(10, 5));
103 EXPECT_EQ(5, Translate("subtracter")(10, 5));
104 EXPECT_EQ(50, Translate("multiplier")(10, 5));
105 EXPECT_EQ(2, Translate("divider")(10, 5));
106
107 EXPECT_EQ(15, Translate("AdDeR")(10, 5));
108 EXPECT_EQ(5, Translate("SuBtRaCtEr")(10, 5));
109 EXPECT_EQ(50, Translate("MuLtIpLiEr")(10, 5));
110 EXPECT_EQ(2, Translate("DiViDeR")(10, 5));
111
112 EXPECT_EQ(0, Translate("nothing")(10, 5));
113}
114
115TEST(StringSwitchTest, EndsWith) {
116 enum class Suffix { Possible, PastTense, Process, InProgressAction, Unknown };
117
118 auto Translate = [](StringRef S) {
119 return llvm::StringSwitch<Suffix>(S)
120 .EndsWith(S: "able", Value: Suffix::Possible)
121 .EndsWith(S: "ed", Value: Suffix::PastTense)
122 .EndsWith(S: "ation", Value: Suffix::Process)
123 .EndsWith(S: "ing", Value: Suffix::InProgressAction)
124 .Default(Value: Suffix::Unknown);
125 };
126
127 EXPECT_EQ(Suffix::Possible, Translate("optimizable"));
128 EXPECT_EQ(Suffix::PastTense, Translate("optimized"));
129 EXPECT_EQ(Suffix::Process, Translate("optimization"));
130 EXPECT_EQ(Suffix::InProgressAction, Translate("optimizing"));
131 EXPECT_EQ(Suffix::Unknown, Translate("optimizer"));
132 EXPECT_EQ(Suffix::Unknown, Translate("OPTIMIZABLE"));
133}
134
135TEST(StringSwitchTest, EndsWithLower) {
136 enum class Suffix { Possible, PastTense, Process, InProgressAction, Unknown };
137
138 auto Translate = [](StringRef S) {
139 return llvm::StringSwitch<Suffix>(S)
140 .EndsWithLower(S: "able", Value: Suffix::Possible)
141 .EndsWithLower(S: "ed", Value: Suffix::PastTense)
142 .EndsWithLower(S: "ation", Value: Suffix::Process)
143 .EndsWithLower(S: "ing", Value: Suffix::InProgressAction)
144 .Default(Value: Suffix::Unknown);
145 };
146
147 EXPECT_EQ(Suffix::Possible, Translate("optimizable"));
148 EXPECT_EQ(Suffix::Possible, Translate("OPTIMIZABLE"));
149 EXPECT_EQ(Suffix::PastTense, Translate("optimized"));
150 EXPECT_EQ(Suffix::Process, Translate("optimization"));
151 EXPECT_EQ(Suffix::InProgressAction, Translate("optimizing"));
152 EXPECT_EQ(Suffix::Unknown, Translate("optimizer"));
153}
154
155TEST(StringSwitchTest, Cases) {
156 enum class OSType { Windows, Linux, Unknown };
157
158 auto Translate = [](StringRef S) {
159 return llvm::StringSwitch<OSType>(S)
160 .Cases(S0: StringLiteral::withInnerNUL(Str: "wind\0ws"), S1: "win32", S2: "winnt",
161 Value: OSType::Windows)
162 .Cases(S0: "linux", S1: "unix", S2: "*nix", S3: "posix", Value: OSType::Linux)
163 .Default(Value: OSType::Unknown);
164 };
165
166 EXPECT_EQ(OSType::Windows, Translate(llvm::StringRef("wind\0ws", 7)));
167 EXPECT_EQ(OSType::Windows, Translate("win32"));
168 EXPECT_EQ(OSType::Windows, Translate("winnt"));
169
170 EXPECT_EQ(OSType::Linux, Translate("linux"));
171 EXPECT_EQ(OSType::Linux, Translate("unix"));
172 EXPECT_EQ(OSType::Linux, Translate("*nix"));
173 EXPECT_EQ(OSType::Linux, Translate("posix"));
174
175 // Note that the whole null-terminator embedded string is required for the
176 // case to match.
177 EXPECT_EQ(OSType::Unknown, Translate("wind"));
178 EXPECT_EQ(OSType::Unknown, Translate("Windows"));
179 EXPECT_EQ(OSType::Unknown, Translate(""));
180}
181
182TEST(StringSwitchTest, CasesLower) {
183 enum class OSType { Windows, Linux, Unknown };
184
185 auto Translate = [](StringRef S) {
186 return llvm::StringSwitch<OSType>(S)
187 .CasesLower(S0: StringLiteral::withInnerNUL(Str: "wind\0ws"), S1: "win32", S2: "winnt",
188 Value: OSType::Windows)
189 .CasesLower(S0: "linux", S1: "unix", S2: "*nix", S3: "posix", Value: OSType::Linux)
190 .Default(Value: OSType::Unknown);
191 };
192
193 EXPECT_EQ(OSType::Windows, Translate(llvm::StringRef("WIND\0WS", 7)));
194 EXPECT_EQ(OSType::Windows, Translate("WIN32"));
195 EXPECT_EQ(OSType::Windows, Translate("WINNT"));
196
197 EXPECT_EQ(OSType::Linux, Translate("LINUX"));
198 EXPECT_EQ(OSType::Linux, Translate("UNIX"));
199 EXPECT_EQ(OSType::Linux, Translate("*NIX"));
200 EXPECT_EQ(OSType::Linux, Translate("POSIX"));
201
202 EXPECT_EQ(OSType::Windows, Translate(llvm::StringRef("wind\0ws", 7)));
203 EXPECT_EQ(OSType::Linux, Translate("linux"));
204
205 EXPECT_EQ(OSType::Unknown, Translate("wind"));
206 EXPECT_EQ(OSType::Unknown, Translate(""));
207}
208

source code of llvm/unittests/ADT/StringSwitchTest.cpp