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 | |
12 | using namespace llvm; |
13 | |
14 | TEST(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 | |
43 | TEST(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 | |
73 | TEST(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 | |
92 | TEST(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 | |
115 | TEST(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 | |
135 | TEST(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 | |
155 | TEST(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 | |
182 | TEST(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 | |