1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
|
//===- llvm/unittest/ADT/StringSwitchTest.cpp - StringSwitch unit tests ---===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "llvm/ADT/StringSwitch.h"
#include "gtest/gtest.h"
using namespace llvm;
TEST(StringSwitchTest, Case) {
auto Translate = [](StringRef S) {
return llvm::StringSwitch<int>(S)
.Case("0", 0)
.Case("1", 1)
.Case("2", 2)
.Case("3", 3)
.Case("4", 4)
.Case("5", 5)
.Case("6", 6)
.Case("7", 7)
.Case("8", 8)
.Case("9", 9)
.Case("A", 10)
.Case("B", 11)
.Case("C", 12)
.Case("D", 13)
.Case("E", 14)
.Case("F", 15)
.Default(-1);
};
EXPECT_EQ(1, Translate("1"));
EXPECT_EQ(2, Translate("2"));
EXPECT_EQ(11, Translate("B"));
EXPECT_EQ(-1, Translate("b"));
EXPECT_EQ(-1, Translate(""));
EXPECT_EQ(-1, Translate("Test"));
}
TEST(StringSwitchTest, StartsWith) {
auto Translate = [](StringRef S) {
return llvm::StringSwitch<std::function<int(int, int)>>(S)
.StartsWith("add", [](int X, int Y) { return X + Y; })
.StartsWith("sub", [](int X, int Y) { return X - Y; })
.StartsWith("mul", [](int X, int Y) { return X * Y; })
.StartsWith("div", [](int X, int Y) { return X / Y; })
.Default([](int X, int Y) { return 0; });
};
EXPECT_EQ(15, Translate("adder")(10, 5));
EXPECT_EQ(5, Translate("subtracter")(10, 5));
EXPECT_EQ(50, Translate("multiplier")(10, 5));
EXPECT_EQ(2, Translate("divider")(10, 5));
EXPECT_EQ(0, Translate("nothing")(10, 5));
EXPECT_EQ(0, Translate("ADDER")(10, 5));
}
TEST(StringSwitchTest, EndsWith) {
enum class Suffix { Possible, PastTense, Process, InProgressAction, Unknown };
auto Translate = [](StringRef S) {
return llvm::StringSwitch<Suffix>(S)
.EndsWith("able", Suffix::Possible)
.EndsWith("ed", Suffix::PastTense)
.EndsWith("ation", Suffix::Process)
.EndsWith("ing", Suffix::InProgressAction)
.Default(Suffix::Unknown);
};
EXPECT_EQ(Suffix::Possible, Translate("optimizable"));
EXPECT_EQ(Suffix::PastTense, Translate("optimized"));
EXPECT_EQ(Suffix::Process, Translate("optimization"));
EXPECT_EQ(Suffix::InProgressAction, Translate("optimizing"));
EXPECT_EQ(Suffix::Unknown, Translate("optimizer"));
EXPECT_EQ(Suffix::Unknown, Translate("OPTIMIZABLE"));
}
TEST(StringSwitchTest, Cases) {
enum class OSType { Windows, Linux, Unknown };
auto Translate = [](StringRef S) {
return llvm::StringSwitch<OSType>(S)
.Cases("wind\0ws", "win32", "winnt", OSType::Windows)
.Cases("linux", "unix", "*nix", "posix", OSType::Linux)
.Default(OSType::Unknown);
};
EXPECT_EQ(OSType::Windows, Translate(llvm::StringRef("wind\0ws", 7)));
EXPECT_EQ(OSType::Windows, Translate("win32"));
EXPECT_EQ(OSType::Windows, Translate("winnt"));
EXPECT_EQ(OSType::Linux, Translate("linux"));
EXPECT_EQ(OSType::Linux, Translate("unix"));
EXPECT_EQ(OSType::Linux, Translate("*nix"));
EXPECT_EQ(OSType::Linux, Translate("posix"));
// Note that the whole null-terminator embedded string is required for the
// case to match.
EXPECT_EQ(OSType::Unknown, Translate("wind"));
EXPECT_EQ(OSType::Unknown, Translate("Windows"));
EXPECT_EQ(OSType::Unknown, Translate(""));
}
|
