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