unittests/Driver/MultilibTest.cpp - clang - Git at Google

 //===- unittests/Driver/MultilibTest.cpp --- Multilib tests ---------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Unit tests for Multilib and MultilibSet
 //
 //===----------------------------------------------------------------------===//

 #include "clang/Driver/Multilib.h"
 #include "clang/Basic/LLVM.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "gtest/gtest.h"

 using namespace clang::driver;
 using namespace clang;

 TEST(MultilibTest, MultilibValidity) {

   ASSERT_TRUE(Multilib().isValid()) << "Empty multilib is not valid";

   ASSERT_TRUE(Multilib().flag("+foo").isValid())
       << "Single indicative flag is not valid";

   ASSERT_TRUE(Multilib().flag("-foo").isValid())
       << "Single contraindicative flag is not valid";

   ASSERT_FALSE(Multilib().flag("+foo").flag("-foo").isValid())
       << "Conflicting flags should invalidate the Multilib";

   ASSERT_TRUE(Multilib().flag("+foo").flag("+foo").isValid())
       << "Multilib should be valid even if it has the same flag twice";

   ASSERT_TRUE(Multilib().flag("+foo").flag("-foobar").isValid())
       << "Seemingly conflicting prefixes shouldn't actually conflict";
 }

 TEST(MultilibTest, OpEqReflexivity1) {
   Multilib M;
   ASSERT_TRUE(M == M) << "Multilib::operator==() is not reflexive";
 }

 TEST(MultilibTest, OpEqReflexivity2) {
   ASSERT_TRUE(Multilib() == Multilib())
       << "Separately constructed default multilibs are not equal";
 }

 TEST(MultilibTest, OpEqReflexivity3) {
   Multilib M1, M2;
   M1.flag("+foo");
   M2.flag("+foo");
   ASSERT_TRUE(M1 == M2) << "Multilibs with the same flag should be the same";
 }

 TEST(MultilibTest, OpEqInequivalence1) {
   Multilib M1, M2;
   M1.flag("+foo");
   M2.flag("-foo");
   ASSERT_FALSE(M1 == M2) << "Multilibs with conflicting flags are not the same";
   ASSERT_FALSE(M2 == M1)
       << "Multilibs with conflicting flags are not the same (commuted)";
 }

 TEST(MultilibTest, OpEqInequivalence2) {
   Multilib M1, M2;
   M2.flag("+foo");
   ASSERT_FALSE(M1 == M2) << "Flags make Multilibs different";
 }

 TEST(MultilibTest, OpEqEquivalence1) {
   Multilib M1, M2;
   M1.flag("+foo");
   M2.flag("+foo").flag("+foo");
   ASSERT_TRUE(M1 == M2) << "Flag duplication shouldn't affect equivalence";
   ASSERT_TRUE(M2 == M1)
       << "Flag duplication shouldn't affect equivalence (commuted)";
 }

 TEST(MultilibTest, OpEqEquivalence2) {
   Multilib M1("64");
   Multilib M2;
   M2.gccSuffix("/64");
   ASSERT_TRUE(M1 == M2)
       << "Constructor argument must match Multilib::gccSuffix()";
   ASSERT_TRUE(M2 == M1)
       << "Constructor argument must match Multilib::gccSuffix() (commuted)";
 }

 TEST(MultilibTest, OpEqEquivalence3) {
   Multilib M1("", "32");
   Multilib M2;
   M2.osSuffix("/32");
   ASSERT_TRUE(M1 == M2)
       << "Constructor argument must match Multilib::osSuffix()";
   ASSERT_TRUE(M2 == M1)
       << "Constructor argument must match Multilib::osSuffix() (commuted)";
 }

 TEST(MultilibTest, OpEqEquivalence4) {
   Multilib M1("", "", "16");
   Multilib M2;
   M2.includeSuffix("/16");
   ASSERT_TRUE(M1 == M2)
       << "Constructor argument must match Multilib::includeSuffix()";
   ASSERT_TRUE(M2 == M1)
       << "Constructor argument must match Multilib::includeSuffix() (commuted)";
 }

 TEST(MultilibTest, OpEqInequivalence3) {
   Multilib M1("foo");
   Multilib M2("bar");
   ASSERT_FALSE(M1 == M2) << "Differing gccSuffixes should be different";
   ASSERT_FALSE(M2 == M1)
       << "Differing gccSuffixes should be different (commuted)";
 }

 TEST(MultilibTest, OpEqInequivalence4) {
   Multilib M1("", "foo");
   Multilib M2("", "bar");
   ASSERT_FALSE(M1 == M2) << "Differing osSuffixes should be different";
   ASSERT_FALSE(M2 == M1)
       << "Differing osSuffixes should be different (commuted)";
 }

 TEST(MultilibTest, OpEqInequivalence5) {
   Multilib M1("", "", "foo");
   Multilib M2("", "", "bar");
   ASSERT_FALSE(M1 == M2) << "Differing includeSuffixes should be different";
   ASSERT_FALSE(M2 == M1)
       << "Differing includeSuffixes should be different (commuted)";
 }

 TEST(MultilibTest, Construction1) {
   Multilib M("gcc64", "os64", "inc64");
   ASSERT_TRUE(M.gccSuffix() == "/gcc64");
   ASSERT_TRUE(M.osSuffix() == "/os64");
   ASSERT_TRUE(M.includeSuffix() == "/inc64");
 }

 TEST(MultilibTest, Construction2) {
   Multilib M1;
   Multilib M2("");
   Multilib M3("", "");
   Multilib M4("", "", "");
   ASSERT_TRUE(M1 == M2)
       << "Default arguments to Multilib constructor broken (first argument)";
   ASSERT_TRUE(M1 == M3)
       << "Default arguments to Multilib constructor broken (second argument)";
   ASSERT_TRUE(M1 == M4)
       << "Default arguments to Multilib constructor broken (third argument)";
 }

 TEST(MultilibTest, Construction3) {
   Multilib M = Multilib().flag("+f1").flag("+f2").flag("-f3");
   for (Multilib::flags_list::const_iterator I = M.flags().begin(),
                                             E = M.flags().end();
        I != E; ++I) {
     ASSERT_TRUE(llvm::StringSwitch<bool>(*I)
                     .Cases("+f1", "+f2", "-f3", true)
                     .Default(false));
   }
 }

 static bool hasFlag(const Multilib &M, StringRef Flag) {
   for (Multilib::flags_list::const_iterator I = M.flags().begin(),
                                             E = M.flags().end();
        I != E; ++I) {
     if (*I == Flag)
       return true;
     else if (StringRef(*I).substr(1) == Flag.substr(1))
       return false;
   }
   return false;
 }

 TEST(MultilibTest, SetConstruction1) {
   // Single maybe
   MultilibSet MS;
   ASSERT_TRUE(MS.size() == 0);
   MS.Maybe(Multilib("64").flag("+m64"));
   ASSERT_TRUE(MS.size() == 2);
   for (MultilibSet::const_iterator I = MS.begin(), E = MS.end(); I != E; ++I) {
     if (I->gccSuffix() == "/64")
       ASSERT_TRUE(I->flags()[0] == "+m64");
     else if (I->gccSuffix() == "")
       ASSERT_TRUE(I->flags()[0] == "-m64");
     else
       FAIL() << "Unrecognized gccSufix: " << I->gccSuffix();
   }
 }

 TEST(MultilibTest, SetConstruction2) {
   // Double maybe
   MultilibSet MS;
   MS.Maybe(Multilib("sof").flag("+sof"));
   MS.Maybe(Multilib("el").flag("+EL"));
   ASSERT_TRUE(MS.size() == 4);
   for (MultilibSet::const_iterator I = MS.begin(), E = MS.end(); I != E; ++I) {
     ASSERT_TRUE(I->isValid()) << "Multilb " << *I << " should be valid";
     ASSERT_TRUE(llvm::StringSwitch<bool>(I->gccSuffix())
                     .Cases("", "/sof", "/el", "/sof/el", true)
                     .Default(false))
         << "Multilib " << *I << " wasn't expected";
     ASSERT_TRUE(llvm::StringSwitch<bool>(I->gccSuffix())
                     .Case("", hasFlag(*I, "-sof"))
                     .Case("/sof", hasFlag(*I, "+sof"))
                     .Case("/el", hasFlag(*I, "-sof"))
                     .Case("/sof/el", hasFlag(*I, "+sof"))
                     .Default(false))
         << "Multilib " << *I << " didn't have the appropriate {+,-}sof flag";
     ASSERT_TRUE(llvm::StringSwitch<bool>(I->gccSuffix())
                     .Case("", hasFlag(*I, "-EL"))
                     .Case("/sof", hasFlag(*I, "-EL"))
                     .Case("/el", hasFlag(*I, "+EL"))
                     .Case("/sof/el", hasFlag(*I, "+EL"))
                     .Default(false))
         << "Multilib " << *I << " didn't have the appropriate {+,-}EL flag";
   }
 }

 TEST(MultilibTest, SetPushback) {
   MultilibSet MS;
   MS.push_back(Multilib("one"));
   MS.push_back(Multilib("two"));
   ASSERT_TRUE(MS.size() == 2);
   for (MultilibSet::const_iterator I = MS.begin(), E = MS.end(); I != E; ++I) {
     ASSERT_TRUE(llvm::StringSwitch<bool>(I->gccSuffix())
                     .Cases("/one", "/two", true)
                     .Default(false));
   }
   MS.clear();
   ASSERT_TRUE(MS.size() == 0);
 }

 TEST(MultilibTest, SetRegexFilter) {
   MultilibSet MS;
   MS.Maybe(Multilib("one"));
   MS.Maybe(Multilib("two"));
   MS.Maybe(Multilib("three"));
   ASSERT_EQ(MS.size(), (unsigned)2 * 2 * 2)
       << "Size before filter was incorrect. Contents:\n" << MS;
   MS.FilterOut("/one/two/three");
   ASSERT_EQ(MS.size(), (unsigned)2 * 2 * 2 - 1)
       << "Size after filter was incorrect. Contents:\n" << MS;
   for (MultilibSet::const_iterator I = MS.begin(), E = MS.end(); I != E; ++I) {
     ASSERT_TRUE(I->gccSuffix() != "/one/two/three")
         << "The filter should have removed " << *I;
   }
 }

 TEST(MultilibTest, SetFilterObject) {
   MultilibSet MS;
   MS.Maybe(Multilib("orange"));
   MS.Maybe(Multilib("pear"));
   MS.Maybe(Multilib("plum"));
   ASSERT_EQ((int)MS.size(), 1 /* Default */ +
                             1 /* pear */ +
                             1 /* plum */ +
                             1 /* pear/plum */ +
                             1 /* orange */ +
                             1 /* orange/pear */ +
                             1 /* orange/plum */ +
                             1 /* orange/pear/plum */ )
       << "Size before filter was incorrect. Contents:\n" << MS;
   MS.FilterOut([](const Multilib &M) {
     return StringRef(M.gccSuffix()).startswith("/p");
   });
   ASSERT_EQ((int)MS.size(), 1 /* Default */ +
                             1 /* orange */ +
                             1 /* orange/pear */ +
                             1 /* orange/plum */ +
                             1 /* orange/pear/plum */ )
       << "Size after filter was incorrect. Contents:\n" << MS;
   for (MultilibSet::const_iterator I = MS.begin(), E = MS.end(); I != E; ++I) {
     ASSERT_FALSE(StringRef(I->gccSuffix()).startswith("/p"))
         << "The filter should have removed " << *I;
   }
 }

 TEST(MultilibTest, SetSelection1) {
   MultilibSet MS1 = MultilibSet()
     .Maybe(Multilib("64").flag("+m64"));

   Multilib::flags_list FlagM64;
   FlagM64.push_back("+m64");
   Multilib SelectionM64;
   ASSERT_TRUE(MS1.select(FlagM64, SelectionM64))
       << "Flag set was {\"+m64\"}, but selection not found";
   ASSERT_TRUE(SelectionM64.gccSuffix() == "/64")
       << "Selection picked " << SelectionM64 << " which was not expected";

   Multilib::flags_list FlagNoM64;
   FlagNoM64.push_back("-m64");
   Multilib SelectionNoM64;
   ASSERT_TRUE(MS1.select(FlagNoM64, SelectionNoM64))
       << "Flag set was {\"-m64\"}, but selection not found";
   ASSERT_TRUE(SelectionNoM64.gccSuffix() == "")
       << "Selection picked " << SelectionNoM64 << " which was not expected";
 }

 TEST(MultilibTest, SetSelection2) {
   MultilibSet MS2 = MultilibSet()
     .Maybe(Multilib("el").flag("+EL"))
     .Maybe(Multilib("sf").flag("+SF"));

   for (unsigned I = 0; I < 4; ++I) {
     bool IsEL = I & 0x1;
     bool IsSF = I & 0x2;
     Multilib::flags_list Flags;
     if (IsEL)
       Flags.push_back("+EL");
     else
       Flags.push_back("-EL");

     if (IsSF)
       Flags.push_back("+SF");
     else
       Flags.push_back("-SF");

     Multilib Selection;
     ASSERT_TRUE(MS2.select(Flags, Selection)) << "Selection failed for "
                                               << (IsEL ? "+EL" : "-EL") << " "
                                               << (IsSF ? "+SF" : "-SF");

     std::string Suffix;
     if (IsEL)
       Suffix += "/el";
     if (IsSF)
       Suffix += "/sf";

     ASSERT_EQ(Selection.gccSuffix(), Suffix) << "Selection picked " << Selection
                                              << " which was not expected ";
   }
 }

 TEST(MultilibTest, SetCombineWith) {
   MultilibSet Coffee;
   Coffee.push_back(Multilib("coffee"));
   MultilibSet Milk;
   Milk.push_back(Multilib("milk"));
   MultilibSet Latte;
   ASSERT_EQ(Latte.size(), (unsigned)0);
   Latte.combineWith(Coffee);
   ASSERT_EQ(Latte.size(), (unsigned)1);
   Latte.combineWith(Milk);
   ASSERT_EQ(Latte.size(), (unsigned)2);
 }

 TEST(MultilibTest, SetPriority) {
   MultilibSet MS;
   MS.push_back(Multilib("foo", {}, {}, 1).flag("+foo"));
   MS.push_back(Multilib("bar", {}, {}, 2).flag("+bar"));

   Multilib::flags_list Flags1;
   Flags1.push_back("+foo");
   Flags1.push_back("-bar");
   Multilib Selection1;
   ASSERT_TRUE(MS.select(Flags1, Selection1))
       << "Flag set was {\"+foo\"}, but selection not found";
   ASSERT_TRUE(Selection1.gccSuffix() == "/foo")
       << "Selection picked " << Selection1 << " which was not expected";

   Multilib::flags_list Flags2;
   Flags2.push_back("+foo");
   Flags2.push_back("+bar");
   Multilib Selection2;
   ASSERT_TRUE(MS.select(Flags2, Selection2))
       << "Flag set was {\"+bar\"}, but selection not found";
   ASSERT_TRUE(Selection2.gccSuffix() == "/bar")
       << "Selection picked " << Selection2 << " which was not expected";
 }
	//===- unittests/Driver/MultilibTest.cpp --- Multilib tests ---------------===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//
	//
	// Unit tests for Multilib and MultilibSet
	//
	//===----------------------------------------------------------------------===//

	#include "clang/Driver/Multilib.h"
	#include "clang/Basic/LLVM.h"
	#include "llvm/ADT/StringRef.h"
	#include "llvm/ADT/StringSwitch.h"
	#include "gtest/gtest.h"

	using namespace clang::driver;
	using namespace clang;

	TEST(MultilibTest, MultilibValidity) {

	ASSERT_TRUE(Multilib().isValid()) << "Empty multilib is not valid";

	ASSERT_TRUE(Multilib().flag("+foo").isValid())
	<< "Single indicative flag is not valid";

	ASSERT_TRUE(Multilib().flag("-foo").isValid())
	<< "Single contraindicative flag is not valid";

	ASSERT_FALSE(Multilib().flag("+foo").flag("-foo").isValid())
	<< "Conflicting flags should invalidate the Multilib";

	ASSERT_TRUE(Multilib().flag("+foo").flag("+foo").isValid())
	<< "Multilib should be valid even if it has the same flag twice";

	ASSERT_TRUE(Multilib().flag("+foo").flag("-foobar").isValid())
	<< "Seemingly conflicting prefixes shouldn't actually conflict";
	}

	TEST(MultilibTest, OpEqReflexivity1) {
	Multilib M;
	ASSERT_TRUE(M == M) << "Multilib::operator==() is not reflexive";
	}

	TEST(MultilibTest, OpEqReflexivity2) {
	ASSERT_TRUE(Multilib() == Multilib())
	<< "Separately constructed default multilibs are not equal";
	}

	TEST(MultilibTest, OpEqReflexivity3) {
	Multilib M1, M2;
	M1.flag("+foo");
	M2.flag("+foo");
	ASSERT_TRUE(M1 == M2) << "Multilibs with the same flag should be the same";
	}

	TEST(MultilibTest, OpEqInequivalence1) {
	Multilib M1, M2;
	M1.flag("+foo");
	M2.flag("-foo");
	ASSERT_FALSE(M1 == M2) << "Multilibs with conflicting flags are not the same";
	ASSERT_FALSE(M2 == M1)
	<< "Multilibs with conflicting flags are not the same (commuted)";
	}

	TEST(MultilibTest, OpEqInequivalence2) {
	Multilib M1, M2;
	M2.flag("+foo");
	ASSERT_FALSE(M1 == M2) << "Flags make Multilibs different";
	}

	TEST(MultilibTest, OpEqEquivalence1) {
	Multilib M1, M2;
	M1.flag("+foo");
	M2.flag("+foo").flag("+foo");
	ASSERT_TRUE(M1 == M2) << "Flag duplication shouldn't affect equivalence";
	ASSERT_TRUE(M2 == M1)
	<< "Flag duplication shouldn't affect equivalence (commuted)";
	}

	TEST(MultilibTest, OpEqEquivalence2) {
	Multilib M1("64");
	Multilib M2;
	M2.gccSuffix("/64");
	ASSERT_TRUE(M1 == M2)
	<< "Constructor argument must match Multilib::gccSuffix()";
	ASSERT_TRUE(M2 == M1)
	<< "Constructor argument must match Multilib::gccSuffix() (commuted)";
	}

	TEST(MultilibTest, OpEqEquivalence3) {
	Multilib M1("", "32");
	Multilib M2;
	M2.osSuffix("/32");
	ASSERT_TRUE(M1 == M2)
	<< "Constructor argument must match Multilib::osSuffix()";
	ASSERT_TRUE(M2 == M1)
	<< "Constructor argument must match Multilib::osSuffix() (commuted)";
	}

	TEST(MultilibTest, OpEqEquivalence4) {
	Multilib M1("", "", "16");
	Multilib M2;
	M2.includeSuffix("/16");
	ASSERT_TRUE(M1 == M2)
	<< "Constructor argument must match Multilib::includeSuffix()";
	ASSERT_TRUE(M2 == M1)
	<< "Constructor argument must match Multilib::includeSuffix() (commuted)";
	}

	TEST(MultilibTest, OpEqInequivalence3) {
	Multilib M1("foo");
	Multilib M2("bar");
	ASSERT_FALSE(M1 == M2) << "Differing gccSuffixes should be different";
	ASSERT_FALSE(M2 == M1)
	<< "Differing gccSuffixes should be different (commuted)";
	}

	TEST(MultilibTest, OpEqInequivalence4) {
	Multilib M1("", "foo");
	Multilib M2("", "bar");
	ASSERT_FALSE(M1 == M2) << "Differing osSuffixes should be different";
	ASSERT_FALSE(M2 == M1)
	<< "Differing osSuffixes should be different (commuted)";
	}

	TEST(MultilibTest, OpEqInequivalence5) {
	Multilib M1("", "", "foo");
	Multilib M2("", "", "bar");
	ASSERT_FALSE(M1 == M2) << "Differing includeSuffixes should be different";
	ASSERT_FALSE(M2 == M1)
	<< "Differing includeSuffixes should be different (commuted)";
	}

	TEST(MultilibTest, Construction1) {
	Multilib M("gcc64", "os64", "inc64");
	ASSERT_TRUE(M.gccSuffix() == "/gcc64");
	ASSERT_TRUE(M.osSuffix() == "/os64");
	ASSERT_TRUE(M.includeSuffix() == "/inc64");
	}

	TEST(MultilibTest, Construction2) {
	Multilib M1;
	Multilib M2("");
	Multilib M3("", "");
	Multilib M4("", "", "");
	ASSERT_TRUE(M1 == M2)
	<< "Default arguments to Multilib constructor broken (first argument)";
	ASSERT_TRUE(M1 == M3)
	<< "Default arguments to Multilib constructor broken (second argument)";
	ASSERT_TRUE(M1 == M4)
	<< "Default arguments to Multilib constructor broken (third argument)";
	}

	TEST(MultilibTest, Construction3) {
	Multilib M = Multilib().flag("+f1").flag("+f2").flag("-f3");
	for (Multilib::flags_list::const_iterator I = M.flags().begin(),
	E = M.flags().end();
	I != E; ++I) {
	ASSERT_TRUE(llvm::StringSwitch<bool>(*I)
	.Cases("+f1", "+f2", "-f3", true)
	.Default(false));
	}
	}

	static bool hasFlag(const Multilib &M, StringRef Flag) {
	for (Multilib::flags_list::const_iterator I = M.flags().begin(),
	E = M.flags().end();
	I != E; ++I) {
	if (*I == Flag)
	return true;
	else if (StringRef(*I).substr(1) == Flag.substr(1))
	return false;
	}
	return false;
	}

	TEST(MultilibTest, SetConstruction1) {
	// Single maybe
	MultilibSet MS;
	ASSERT_TRUE(MS.size() == 0);
	MS.Maybe(Multilib("64").flag("+m64"));
	ASSERT_TRUE(MS.size() == 2);
	for (MultilibSet::const_iterator I = MS.begin(), E = MS.end(); I != E; ++I) {
	if (I->gccSuffix() == "/64")
	ASSERT_TRUE(I->flags()[0] == "+m64");
	else if (I->gccSuffix() == "")
	ASSERT_TRUE(I->flags()[0] == "-m64");
	else
	FAIL() << "Unrecognized gccSufix: " << I->gccSuffix();
	}
	}

	TEST(MultilibTest, SetConstruction2) {
	// Double maybe
	MultilibSet MS;
	MS.Maybe(Multilib("sof").flag("+sof"));
	MS.Maybe(Multilib("el").flag("+EL"));
	ASSERT_TRUE(MS.size() == 4);
	for (MultilibSet::const_iterator I = MS.begin(), E = MS.end(); I != E; ++I) {
	ASSERT_TRUE(I->isValid()) << "Multilb " << *I << " should be valid";
	ASSERT_TRUE(llvm::StringSwitch<bool>(I->gccSuffix())
	.Cases("", "/sof", "/el", "/sof/el", true)
	.Default(false))
	<< "Multilib " << *I << " wasn't expected";
	ASSERT_TRUE(llvm::StringSwitch<bool>(I->gccSuffix())
	.Case("", hasFlag(*I, "-sof"))
	.Case("/sof", hasFlag(*I, "+sof"))
	.Case("/el", hasFlag(*I, "-sof"))
	.Case("/sof/el", hasFlag(*I, "+sof"))
	.Default(false))
	<< "Multilib " << *I << " didn't have the appropriate {+,-}sof flag";
	ASSERT_TRUE(llvm::StringSwitch<bool>(I->gccSuffix())
	.Case("", hasFlag(*I, "-EL"))
	.Case("/sof", hasFlag(*I, "-EL"))
	.Case("/el", hasFlag(*I, "+EL"))
	.Case("/sof/el", hasFlag(*I, "+EL"))
	.Default(false))
	<< "Multilib " << *I << " didn't have the appropriate {+,-}EL flag";
	}
	}

	TEST(MultilibTest, SetPushback) {
	MultilibSet MS;
	MS.push_back(Multilib("one"));
	MS.push_back(Multilib("two"));
	ASSERT_TRUE(MS.size() == 2);
	for (MultilibSet::const_iterator I = MS.begin(), E = MS.end(); I != E; ++I) {
	ASSERT_TRUE(llvm::StringSwitch<bool>(I->gccSuffix())
	.Cases("/one", "/two", true)
	.Default(false));
	}
	MS.clear();
	ASSERT_TRUE(MS.size() == 0);
	}

	TEST(MultilibTest, SetRegexFilter) {
	MultilibSet MS;
	MS.Maybe(Multilib("one"));
	MS.Maybe(Multilib("two"));
	MS.Maybe(Multilib("three"));
	ASSERT_EQ(MS.size(), (unsigned)2 * 2 * 2)
	<< "Size before filter was incorrect. Contents:\n" << MS;
	MS.FilterOut("/one/two/three");
	ASSERT_EQ(MS.size(), (unsigned)2 * 2 * 2 - 1)
	<< "Size after filter was incorrect. Contents:\n" << MS;
	for (MultilibSet::const_iterator I = MS.begin(), E = MS.end(); I != E; ++I) {
	ASSERT_TRUE(I->gccSuffix() != "/one/two/three")
	<< "The filter should have removed " << *I;
	}
	}

	TEST(MultilibTest, SetFilterObject) {
	MultilibSet MS;
	MS.Maybe(Multilib("orange"));
	MS.Maybe(Multilib("pear"));
	MS.Maybe(Multilib("plum"));
	ASSERT_EQ((int)MS.size(), 1 /* Default */ +
	1 /* pear */ +
	1 /* plum */ +
	1 /* pear/plum */ +
	1 /* orange */ +
	1 /* orange/pear */ +
	1 /* orange/plum */ +
	1 /* orange/pear/plum */ )
	<< "Size before filter was incorrect. Contents:\n" << MS;
	MS.FilterOut([](const Multilib &M) {
	return StringRef(M.gccSuffix()).startswith("/p");
	});
	ASSERT_EQ((int)MS.size(), 1 /* Default */ +
	1 /* orange */ +
	1 /* orange/pear */ +
	1 /* orange/plum */ +
	1 /* orange/pear/plum */ )
	<< "Size after filter was incorrect. Contents:\n" << MS;
	for (MultilibSet::const_iterator I = MS.begin(), E = MS.end(); I != E; ++I) {
	ASSERT_FALSE(StringRef(I->gccSuffix()).startswith("/p"))
	<< "The filter should have removed " << *I;
	}
	}

	TEST(MultilibTest, SetSelection1) {
	MultilibSet MS1 = MultilibSet()
	.Maybe(Multilib("64").flag("+m64"));

	Multilib::flags_list FlagM64;
	FlagM64.push_back("+m64");
	Multilib SelectionM64;
	ASSERT_TRUE(MS1.select(FlagM64, SelectionM64))
	<< "Flag set was {\"+m64\"}, but selection not found";
	ASSERT_TRUE(SelectionM64.gccSuffix() == "/64")
	<< "Selection picked " << SelectionM64 << " which was not expected";

	Multilib::flags_list FlagNoM64;
	FlagNoM64.push_back("-m64");
	Multilib SelectionNoM64;
	ASSERT_TRUE(MS1.select(FlagNoM64, SelectionNoM64))
	<< "Flag set was {\"-m64\"}, but selection not found";
	ASSERT_TRUE(SelectionNoM64.gccSuffix() == "")
	<< "Selection picked " << SelectionNoM64 << " which was not expected";
	}

	TEST(MultilibTest, SetSelection2) {
	MultilibSet MS2 = MultilibSet()
	.Maybe(Multilib("el").flag("+EL"))
	.Maybe(Multilib("sf").flag("+SF"));

	for (unsigned I = 0; I < 4; ++I) {
	bool IsEL = I & 0x1;
	bool IsSF = I & 0x2;
	Multilib::flags_list Flags;
	if (IsEL)
	Flags.push_back("+EL");
	else
	Flags.push_back("-EL");

	if (IsSF)
	Flags.push_back("+SF");
	else
	Flags.push_back("-SF");

	Multilib Selection;
	ASSERT_TRUE(MS2.select(Flags, Selection)) << "Selection failed for "
	<< (IsEL ? "+EL" : "-EL") << " "
	<< (IsSF ? "+SF" : "-SF");

	std::string Suffix;
	if (IsEL)
	Suffix += "/el";
	if (IsSF)
	Suffix += "/sf";

	ASSERT_EQ(Selection.gccSuffix(), Suffix) << "Selection picked " << Selection
	<< " which was not expected ";
	}
	}

	TEST(MultilibTest, SetCombineWith) {
	MultilibSet Coffee;
	Coffee.push_back(Multilib("coffee"));
	MultilibSet Milk;
	Milk.push_back(Multilib("milk"));
	MultilibSet Latte;
	ASSERT_EQ(Latte.size(), (unsigned)0);
	Latte.combineWith(Coffee);
	ASSERT_EQ(Latte.size(), (unsigned)1);
	Latte.combineWith(Milk);
	ASSERT_EQ(Latte.size(), (unsigned)2);
	}

	TEST(MultilibTest, SetPriority) {
	MultilibSet MS;
	MS.push_back(Multilib("foo", {}, {}, 1).flag("+foo"));
	MS.push_back(Multilib("bar", {}, {}, 2).flag("+bar"));

	Multilib::flags_list Flags1;
	Flags1.push_back("+foo");
	Flags1.push_back("-bar");
	Multilib Selection1;
	ASSERT_TRUE(MS.select(Flags1, Selection1))
	<< "Flag set was {\"+foo\"}, but selection not found";
	ASSERT_TRUE(Selection1.gccSuffix() == "/foo")
	<< "Selection picked " << Selection1 << " which was not expected";

	Multilib::flags_list Flags2;
	Flags2.push_back("+foo");
	Flags2.push_back("+bar");
	Multilib Selection2;
	ASSERT_TRUE(MS.select(Flags2, Selection2))
	<< "Flag set was {\"+bar\"}, but selection not found";
	ASSERT_TRUE(Selection2.gccSuffix() == "/bar")
	<< "Selection picked " << Selection2 << " which was not expected";
	}