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("0", 0)
18         .Case("1", 1)
19         .Case("2", 2)
20         .Case("3", 3)
21         .Case("4", 4)
22         .Case("5", 5)
23         .Case("6", 6)
24         .Case("7", 7)
25         .Case("8", 8)
26         .Case("9", 9)
27         .Case("A", 10)
28         .Case("B", 11)
29         .Case("C", 12)
30         .Case("D", 13)
31         .Case("E", 14)
32         .Case("F", 15)
33         .Default(-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("0", 0)
47         .Case("1", 1)
48         .Case("2", 2)
49         .Case("3", 3)
50         .Case("4", 4)
51         .Case("5", 5)
52         .Case("6", 6)
53         .Case("7", 7)
54         .Case("8", 8)
55         .Case("9", 9)
56         .CaseLower("A", 10)
57         .CaseLower("B", 11)
58         .CaseLower("C", 12)
59         .CaseLower("D", 13)
60         .CaseLower("E", 14)
61         .CaseLower("F", 15)
62         .Default(-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("add", [](int X, int Y) { return X + Y; })
77         .StartsWith("sub", [](int X, int Y) { return X - Y; })
78         .StartsWith("mul", [](int X, int Y) { return X * Y; })
79         .StartsWith("div", [](int X, int Y) { return X / Y; })
80         .Default([](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("add", [](int X, int Y) { return X + Y; })
96         .StartsWithLower("sub", [](int X, int Y) { return X - Y; })
97         .StartsWithLower("mul", [](int X, int Y) { return X * Y; })
98         .StartsWithLower("div", [](int X, int Y) { return X / Y; })
99         .Default([](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("able", Suffix::Possible)
121         .EndsWith("ed", Suffix::PastTense)
122         .EndsWith("ation", Suffix::Process)
123         .EndsWith("ing", Suffix::InProgressAction)
124         .Default(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("able", Suffix::Possible)
141         .EndsWithLower("ed", Suffix::PastTense)
142         .EndsWithLower("ation", Suffix::Process)
143         .EndsWithLower("ing", Suffix::InProgressAction)
144         .Default(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(StringLiteral::withInnerNUL("wind\0ws"), "win32", "winnt",
161                OSType::Windows)
162         .Cases("linux", "unix", "*nix", "posix", OSType::Linux)
163         .Default(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(StringLiteral::withInnerNUL("wind\0ws"), "win32", "winnt",
188                     OSType::Windows)
189         .CasesLower("linux", "unix", "*nix", "posix", OSType::Linux)
190         .Default(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