1 //===- unittests/Driver/MultilibTest.cpp --- Multilib 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 // Unit tests for Multilib and MultilibSet 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "clang/Driver/Multilib.h" 15 #include "clang/Basic/LLVM.h" 16 #include "llvm/ADT/StringRef.h" 17 #include "llvm/ADT/StringSwitch.h" 18 #include "gtest/gtest.h" 19 20 using namespace clang::driver; 21 using namespace clang; 22 23 TEST(MultilibTest, MultilibValidity) { 24 25 ASSERT_TRUE(Multilib().isValid()) << "Empty multilib is not valid"; 26 27 ASSERT_TRUE(Multilib().flag("+foo").isValid()) 28 << "Single indicative flag is not valid"; 29 30 ASSERT_TRUE(Multilib().flag("-foo").isValid()) 31 << "Single contraindicative flag is not valid"; 32 33 ASSERT_FALSE(Multilib().flag("+foo").flag("-foo").isValid()) 34 << "Conflicting flags should invalidate the Multilib"; 35 36 ASSERT_TRUE(Multilib().flag("+foo").flag("+foo").isValid()) 37 << "Multilib should be valid even if it has the same flag twice"; 38 39 ASSERT_TRUE(Multilib().flag("+foo").flag("-foobar").isValid()) 40 << "Seemingly conflicting prefixes shouldn't actually conflict"; 41 } 42 43 TEST(MultilibTest, OpEqReflexivity1) { 44 Multilib M; 45 ASSERT_TRUE(M == M) << "Multilib::operator==() is not reflexive"; 46 } 47 48 TEST(MultilibTest, OpEqReflexivity2) { 49 ASSERT_TRUE(Multilib() == Multilib()) 50 << "Separately constructed default multilibs are not equal"; 51 } 52 53 TEST(MultilibTest, OpEqReflexivity3) { 54 Multilib M1, M2; 55 M1.flag("+foo"); 56 M2.flag("+foo"); 57 ASSERT_TRUE(M1 == M2) << "Multilibs with the same flag should be the same"; 58 } 59 60 TEST(MultilibTest, OpEqInequivalence1) { 61 Multilib M1, M2; 62 M1.flag("+foo"); 63 M2.flag("-foo"); 64 ASSERT_FALSE(M1 == M2) << "Multilibs with conflicting flags are not the same"; 65 ASSERT_FALSE(M2 == M1) 66 << "Multilibs with conflicting flags are not the same (commuted)"; 67 } 68 69 TEST(MultilibTest, OpEqInequivalence2) { 70 Multilib M1, M2; 71 M2.flag("+foo"); 72 ASSERT_FALSE(M1 == M2) << "Flags make Multilibs different"; 73 } 74 75 TEST(MultilibTest, OpEqEquivalence1) { 76 Multilib M1, M2; 77 M1.flag("+foo"); 78 M2.flag("+foo").flag("+foo"); 79 ASSERT_TRUE(M1 == M2) << "Flag duplication shouldn't affect equivalence"; 80 ASSERT_TRUE(M2 == M1) 81 << "Flag duplication shouldn't affect equivalence (commuted)"; 82 } 83 84 TEST(MultilibTest, OpEqEquivalence2) { 85 Multilib M1("64"); 86 Multilib M2; 87 M2.gccSuffix("/64"); 88 ASSERT_TRUE(M1 == M2) 89 << "Constructor argument must match Multilib::gccSuffix()"; 90 ASSERT_TRUE(M2 == M1) 91 << "Constructor argument must match Multilib::gccSuffix() (commuted)"; 92 } 93 94 TEST(MultilibTest, OpEqEquivalence3) { 95 Multilib M1("", "32"); 96 Multilib M2; 97 M2.osSuffix("/32"); 98 ASSERT_TRUE(M1 == M2) 99 << "Constructor argument must match Multilib::osSuffix()"; 100 ASSERT_TRUE(M2 == M1) 101 << "Constructor argument must match Multilib::osSuffix() (commuted)"; 102 } 103 104 TEST(MultilibTest, OpEqEquivalence4) { 105 Multilib M1("", "", "16"); 106 Multilib M2; 107 M2.includeSuffix("/16"); 108 ASSERT_TRUE(M1 == M2) 109 << "Constructor argument must match Multilib::includeSuffix()"; 110 ASSERT_TRUE(M2 == M1) 111 << "Constructor argument must match Multilib::includeSuffix() (commuted)"; 112 } 113 114 TEST(MultilibTest, OpEqInequivalence3) { 115 Multilib M1("foo"); 116 Multilib M2("bar"); 117 ASSERT_FALSE(M1 == M2) << "Differing gccSuffixes should be different"; 118 ASSERT_FALSE(M2 == M1) 119 << "Differing gccSuffixes should be different (commuted)"; 120 } 121 122 TEST(MultilibTest, OpEqInequivalence4) { 123 Multilib M1("", "foo"); 124 Multilib M2("", "bar"); 125 ASSERT_FALSE(M1 == M2) << "Differing osSuffixes should be different"; 126 ASSERT_FALSE(M2 == M1) 127 << "Differing osSuffixes should be different (commuted)"; 128 } 129 130 TEST(MultilibTest, OpEqInequivalence5) { 131 Multilib M1("", "", "foo"); 132 Multilib M2("", "", "bar"); 133 ASSERT_FALSE(M1 == M2) << "Differing includeSuffixes should be different"; 134 ASSERT_FALSE(M2 == M1) 135 << "Differing includeSuffixes should be different (commuted)"; 136 } 137 138 TEST(MultilibTest, Construction1) { 139 Multilib M("gcc64", "os64", "inc64"); 140 ASSERT_TRUE(M.gccSuffix() == "/gcc64"); 141 ASSERT_TRUE(M.osSuffix() == "/os64"); 142 ASSERT_TRUE(M.includeSuffix() == "/inc64"); 143 } 144 145 TEST(MultilibTest, Construction2) { 146 Multilib M1; 147 Multilib M2(""); 148 Multilib M3("", ""); 149 Multilib M4("", "", ""); 150 ASSERT_TRUE(M1 == M2) 151 << "Default arguments to Multilib constructor broken (first argument)"; 152 ASSERT_TRUE(M1 == M3) 153 << "Default arguments to Multilib constructor broken (second argument)"; 154 ASSERT_TRUE(M1 == M4) 155 << "Default arguments to Multilib constructor broken (third argument)"; 156 } 157 158 TEST(MultilibTest, Construction3) { 159 Multilib M = Multilib().flag("+f1").flag("+f2").flag("-f3"); 160 for (Multilib::flags_list::const_iterator I = M.flags().begin(), 161 E = M.flags().end(); 162 I != E; ++I) { 163 ASSERT_TRUE(llvm::StringSwitch<bool>(*I) 164 .Cases("+f1", "+f2", "-f3", true) 165 .Default(false)); 166 } 167 } 168 169 static bool hasFlag(const Multilib &M, StringRef Flag) { 170 for (Multilib::flags_list::const_iterator I = M.flags().begin(), 171 E = M.flags().end(); 172 I != E; ++I) { 173 if (*I == Flag) 174 return true; 175 else if (StringRef(*I).substr(1) == Flag.substr(1)) 176 return false; 177 } 178 return false; 179 } 180 181 TEST(MultilibTest, SetConstruction1) { 182 // Single maybe 183 MultilibSet MS; 184 ASSERT_TRUE(MS.size() == 0); 185 MS.Maybe(Multilib("64").flag("+m64")); 186 ASSERT_TRUE(MS.size() == 2); 187 for (MultilibSet::const_iterator I = MS.begin(), E = MS.end(); I != E; ++I) { 188 if (I->gccSuffix() == "/64") 189 ASSERT_TRUE(I->flags()[0] == "+m64"); 190 else if (I->gccSuffix() == "") 191 ASSERT_TRUE(I->flags()[0] == "-m64"); 192 else 193 FAIL() << "Unrecognized gccSufix: " << I->gccSuffix(); 194 } 195 } 196 197 TEST(MultilibTest, SetConstruction2) { 198 // Double maybe 199 MultilibSet MS; 200 MS.Maybe(Multilib("sof").flag("+sof")); 201 MS.Maybe(Multilib("el").flag("+EL")); 202 ASSERT_TRUE(MS.size() == 4); 203 for (MultilibSet::const_iterator I = MS.begin(), E = MS.end(); I != E; ++I) { 204 ASSERT_TRUE(I->isValid()) << "Multilb " << *I << " should be valid"; 205 ASSERT_TRUE(llvm::StringSwitch<bool>(I->gccSuffix()) 206 .Cases("", "/sof", "/el", "/sof/el", true) 207 .Default(false)) 208 << "Multilib " << *I << " wasn't expected"; 209 ASSERT_TRUE(llvm::StringSwitch<bool>(I->gccSuffix()) 210 .Case("", hasFlag(*I, "-sof")) 211 .Case("/sof", hasFlag(*I, "+sof")) 212 .Case("/el", hasFlag(*I, "-sof")) 213 .Case("/sof/el", hasFlag(*I, "+sof")) 214 .Default(false)) 215 << "Multilib " << *I << " didn't have the appropriate {+,-}sof flag"; 216 ASSERT_TRUE(llvm::StringSwitch<bool>(I->gccSuffix()) 217 .Case("", hasFlag(*I, "-EL")) 218 .Case("/sof", hasFlag(*I, "-EL")) 219 .Case("/el", hasFlag(*I, "+EL")) 220 .Case("/sof/el", hasFlag(*I, "+EL")) 221 .Default(false)) 222 << "Multilib " << *I << " didn't have the appropriate {+,-}EL flag"; 223 } 224 } 225 226 TEST(MultilibTest, SetPushback) { 227 MultilibSet MS; 228 MS.push_back(Multilib("one")); 229 MS.push_back(Multilib("two")); 230 ASSERT_TRUE(MS.size() == 2); 231 for (MultilibSet::const_iterator I = MS.begin(), E = MS.end(); I != E; ++I) { 232 ASSERT_TRUE(llvm::StringSwitch<bool>(I->gccSuffix()) 233 .Cases("/one", "/two", true) 234 .Default(false)); 235 } 236 MS.clear(); 237 ASSERT_TRUE(MS.size() == 0); 238 } 239 240 TEST(MultilibTest, SetRegexFilter) { 241 MultilibSet MS; 242 MS.Maybe(Multilib("one")); 243 MS.Maybe(Multilib("two")); 244 MS.Maybe(Multilib("three")); 245 ASSERT_EQ(MS.size(), (unsigned)2 * 2 * 2) 246 << "Size before filter was incorrect. Contents:\n" << MS; 247 MS.FilterOut("/one/two/three"); 248 ASSERT_EQ(MS.size(), (unsigned)2 * 2 * 2 - 1) 249 << "Size after filter was incorrect. Contents:\n" << MS; 250 for (MultilibSet::const_iterator I = MS.begin(), E = MS.end(); I != E; ++I) { 251 ASSERT_TRUE(I->gccSuffix() != "/one/two/three") 252 << "The filter should have removed " << *I; 253 } 254 } 255 256 TEST(MultilibTest, SetFilterObject) { 257 // Filter object 258 struct StartsWithP : public MultilibSet::FilterCallback { 259 bool operator()(const Multilib &M) const override { 260 return StringRef(M.gccSuffix()).startswith("/p"); 261 } 262 }; 263 MultilibSet MS; 264 MS.Maybe(Multilib("orange")); 265 MS.Maybe(Multilib("pear")); 266 MS.Maybe(Multilib("plum")); 267 ASSERT_EQ((int)MS.size(), 1 /* Default */ + 268 1 /* pear */ + 269 1 /* plum */ + 270 1 /* pear/plum */ + 271 1 /* orange */ + 272 1 /* orange/pear */ + 273 1 /* orange/plum */ + 274 1 /* orange/pear/plum */ ) 275 << "Size before filter was incorrect. Contents:\n" << MS; 276 MS.FilterOut(StartsWithP()); 277 ASSERT_EQ((int)MS.size(), 1 /* Default */ + 278 1 /* orange */ + 279 1 /* orange/pear */ + 280 1 /* orange/plum */ + 281 1 /* orange/pear/plum */ ) 282 << "Size after filter was incorrect. Contents:\n" << MS; 283 for (MultilibSet::const_iterator I = MS.begin(), E = MS.end(); I != E; ++I) { 284 ASSERT_FALSE(StringRef(I->gccSuffix()).startswith("/p")) 285 << "The filter should have removed " << *I; 286 } 287 } 288 289 TEST(MultilibTest, SetSelection1) { 290 MultilibSet MS1 = MultilibSet() 291 .Maybe(Multilib("64").flag("+m64")); 292 293 Multilib::flags_list FlagM64; 294 FlagM64.push_back("+m64"); 295 Multilib SelectionM64; 296 ASSERT_TRUE(MS1.select(FlagM64, SelectionM64)) 297 << "Flag set was {\"+m64\"}, but selection not found"; 298 ASSERT_TRUE(SelectionM64.gccSuffix() == "/64") 299 << "Selection picked " << SelectionM64 << " which was not expected"; 300 301 Multilib::flags_list FlagNoM64; 302 FlagNoM64.push_back("-m64"); 303 Multilib SelectionNoM64; 304 ASSERT_TRUE(MS1.select(FlagNoM64, SelectionNoM64)) 305 << "Flag set was {\"-m64\"}, but selection not found"; 306 ASSERT_TRUE(SelectionNoM64.gccSuffix() == "") 307 << "Selection picked " << SelectionNoM64 << " which was not expected"; 308 } 309 310 TEST(MultilibTest, SetSelection2) { 311 MultilibSet MS2 = MultilibSet() 312 .Maybe(Multilib("el").flag("+EL")) 313 .Maybe(Multilib("sf").flag("+SF")); 314 315 for (unsigned I = 0; I < 4; ++I) { 316 bool IsEL = I & 0x1; 317 bool IsSF = I & 0x2; 318 Multilib::flags_list Flags; 319 if (IsEL) 320 Flags.push_back("+EL"); 321 else 322 Flags.push_back("-EL"); 323 324 if (IsSF) 325 Flags.push_back("+SF"); 326 else 327 Flags.push_back("-SF"); 328 329 Multilib Selection; 330 ASSERT_TRUE(MS2.select(Flags, Selection)) << "Selection failed for " 331 << (IsEL ? "+EL" : "-EL") << " " 332 << (IsSF ? "+SF" : "-SF"); 333 334 std::string Suffix; 335 if (IsEL) 336 Suffix += "/el"; 337 if (IsSF) 338 Suffix += "/sf"; 339 340 ASSERT_EQ(Selection.gccSuffix(), Suffix) << "Selection picked " << Selection 341 << " which was not expected "; 342 } 343 } 344 345 TEST(MultilibTest, SetCombineWith) { 346 MultilibSet Coffee; 347 Coffee.push_back(Multilib("coffee")); 348 MultilibSet Milk; 349 Milk.push_back(Multilib("milk")); 350 MultilibSet Latte; 351 ASSERT_EQ(Latte.size(), (unsigned)0); 352 Latte.combineWith(Coffee); 353 ASSERT_EQ(Latte.size(), (unsigned)1); 354 Latte.combineWith(Milk); 355 ASSERT_EQ(Latte.size(), (unsigned)2); 356 } 357
