lldb/unittests/Utility/ArchSpecTest.cpp

   1 //===-- ArchSpecTest.cpp --------------------------------------------------===//
   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 "gtest/gtest.h"
  10
  11 #include "lldb/Utility/ArchSpec.h"
  12 #include "llvm/BinaryFormat/ELF.h"
  13 #include "llvm/BinaryFormat/MachO.h"
  14 #include "llvm/Support/YAMLParser.h"
  15
  16 using namespace lldb;
  17 using namespace lldb_private;
  18
  19 TEST(ArchSpecTest, TestParseMachCPUDashSubtypeTripleSimple) {
  20
  21   // Success conditions.  Valid cpu/subtype combinations using both - and .
  22   ArchSpec AS;
  23   EXPECT_TRUE(ParseMachCPUDashSubtypeTriple("12-10", AS));
  24   EXPECT_EQ(12u, AS.GetMachOCPUType());
  25   EXPECT_EQ(10u, AS.GetMachOCPUSubType());
  26
  27   AS = ArchSpec();
  28   EXPECT_TRUE(ParseMachCPUDashSubtypeTriple("12-15", AS));
  29   EXPECT_EQ(12u, AS.GetMachOCPUType());
  30   EXPECT_EQ(15u, AS.GetMachOCPUSubType());
  31
  32   AS = ArchSpec();
  33   EXPECT_TRUE(ParseMachCPUDashSubtypeTriple("12.15", AS));
  34   EXPECT_EQ(12u, AS.GetMachOCPUType());
  35   EXPECT_EQ(15u, AS.GetMachOCPUSubType());
  36
  37   // Failure conditions.
  38
  39   // Valid string, unknown cpu/subtype.
  40   AS = ArchSpec();
  41   EXPECT_TRUE(ParseMachCPUDashSubtypeTriple("13.11", AS));
  42   EXPECT_EQ(0u, AS.GetMachOCPUType());
  43   EXPECT_EQ(0u, AS.GetMachOCPUSubType());
  44
  45   // Missing / invalid cpu or subtype
  46   AS = ArchSpec();
  47   EXPECT_FALSE(ParseMachCPUDashSubtypeTriple("13", AS));
  48
  49   AS = ArchSpec();
  50   EXPECT_FALSE(ParseMachCPUDashSubtypeTriple("13.A", AS));
  51
  52   AS = ArchSpec();
  53   EXPECT_FALSE(ParseMachCPUDashSubtypeTriple("A.13", AS));
  54
  55   // Empty string.
  56   AS = ArchSpec();
  57   EXPECT_FALSE(ParseMachCPUDashSubtypeTriple("", AS));
  58 }
  59
  60 TEST(ArchSpecTest, TestParseMachCPUDashSubtypeTripleExtra) {
  61   ArchSpec AS;
  62   EXPECT_TRUE(ParseMachCPUDashSubtypeTriple("12-15-vendor-os", AS));
  63   EXPECT_EQ(12u, AS.GetMachOCPUType());
  64   EXPECT_EQ(15u, AS.GetMachOCPUSubType());
  65   EXPECT_EQ("vendor", AS.GetTriple().getVendorName());
  66   EXPECT_EQ("os", AS.GetTriple().getOSName());
  67
  68   AS = ArchSpec();
  69   EXPECT_TRUE(ParseMachCPUDashSubtypeTriple("12-10-vendor-os-name", AS));
  70   EXPECT_EQ(12u, AS.GetMachOCPUType());
  71   EXPECT_EQ(10u, AS.GetMachOCPUSubType());
  72   EXPECT_EQ("vendor", AS.GetTriple().getVendorName());
  73   EXPECT_EQ("os", AS.GetTriple().getOSName());
  74
  75   AS = ArchSpec();
  76   EXPECT_TRUE(ParseMachCPUDashSubtypeTriple("12-15-vendor.os-name", AS));
  77   EXPECT_EQ(12u, AS.GetMachOCPUType());
  78   EXPECT_EQ(15u, AS.GetMachOCPUSubType());
  79   EXPECT_EQ("vendor.os", AS.GetTriple().getVendorName());
  80   EXPECT_EQ("name", AS.GetTriple().getOSName());
  81
  82   // These there should parse correctly, but the vendor / OS should be defaulted
  83   // since they are unrecognized.
  84   AS = ArchSpec();
  85   EXPECT_TRUE(ParseMachCPUDashSubtypeTriple("12-10-vendor", AS));
  86   EXPECT_EQ(12u, AS.GetMachOCPUType());
  87   EXPECT_EQ(10u, AS.GetMachOCPUSubType());
  88   EXPECT_EQ("apple", AS.GetTriple().getVendorName());
  89   EXPECT_EQ("", AS.GetTriple().getOSName());
  90
  91   AS = ArchSpec();
  92   EXPECT_FALSE(ParseMachCPUDashSubtypeTriple("12.10.10", AS));
  93
  94   AS = ArchSpec();
  95   EXPECT_FALSE(ParseMachCPUDashSubtypeTriple("12-10.10", AS));
  96 }
  97
  98 TEST(ArchSpecTest, TestSetTriple) {
  99   ArchSpec AS;
 100
 101   // Various flavors of valid triples.
 102   EXPECT_TRUE(AS.SetTriple("12-10-apple-darwin"));
 103   EXPECT_EQ(uint32_t(llvm::MachO::CPU_TYPE_ARM), AS.GetMachOCPUType());
 104   EXPECT_EQ(10u, AS.GetMachOCPUSubType());
 105   EXPECT_TRUE(llvm::StringRef(AS.GetTriple().str())
 106                   .consume_front("armv7f-apple-darwin"));
 107   EXPECT_EQ(ArchSpec::eCore_arm_armv7f, AS.GetCore());
 108
 109   AS = ArchSpec();
 110   EXPECT_TRUE(AS.SetTriple("18.100-apple-darwin"));
 111   EXPECT_EQ(uint32_t(llvm::MachO::CPU_TYPE_POWERPC), AS.GetMachOCPUType());
 112   EXPECT_EQ(100u, AS.GetMachOCPUSubType());
 113   EXPECT_TRUE(llvm::StringRef(AS.GetTriple().str())
 114                   .consume_front("powerpc-apple-darwin"));
 115   EXPECT_EQ(ArchSpec::eCore_ppc_ppc970, AS.GetCore());
 116
 117   AS = ArchSpec();
 118   EXPECT_TRUE(AS.SetTriple("i686-pc-windows"));
 119   EXPECT_EQ(llvm::Triple::x86, AS.GetTriple().getArch());
 120   EXPECT_EQ(llvm::Triple::PC, AS.GetTriple().getVendor());
 121   EXPECT_EQ(llvm::Triple::Win32, AS.GetTriple().getOS());
 122   EXPECT_TRUE(
 123       llvm::StringRef(AS.GetTriple().str()).consume_front("i686-pc-windows"));
 124   EXPECT_STREQ("i686", AS.GetArchitectureName());
 125   EXPECT_EQ(ArchSpec::eCore_x86_32_i686, AS.GetCore());
 126
 127   // Various flavors of invalid triples.
 128   AS = ArchSpec();
 129   EXPECT_FALSE(AS.SetTriple("unknown-unknown-unknown"));
 130
 131   AS = ArchSpec();
 132   EXPECT_FALSE(AS.SetTriple("unknown"));
 133
 134   AS = ArchSpec();
 135   EXPECT_FALSE(AS.SetTriple(""));
 136 }
 137
 138 TEST(ArchSpecTest, MergeFrom) {
 139   {
 140     ArchSpec A;
 141     ArchSpec B("x86_64-pc-linux");
 142
 143     EXPECT_FALSE(A.IsValid());
 144     ASSERT_TRUE(B.IsValid());
 145     EXPECT_EQ(llvm::Triple::ArchType::x86_64, B.GetTriple().getArch());
 146     EXPECT_EQ(llvm::Triple::VendorType::PC, B.GetTriple().getVendor());
 147     EXPECT_EQ(llvm::Triple::OSType::Linux, B.GetTriple().getOS());
 148     EXPECT_EQ(ArchSpec::eCore_x86_64_x86_64, B.GetCore());
 149
 150     A.MergeFrom(B);
 151     ASSERT_TRUE(A.IsValid());
 152     EXPECT_EQ(llvm::Triple::ArchType::x86_64, A.GetTriple().getArch());
 153     EXPECT_EQ(llvm::Triple::VendorType::PC, A.GetTriple().getVendor());
 154     EXPECT_EQ(llvm::Triple::OSType::Linux, A.GetTriple().getOS());
 155     EXPECT_EQ(ArchSpec::eCore_x86_64_x86_64, A.GetCore());
 156   }
 157   {
 158     ArchSpec A("aarch64");
 159     ArchSpec B("aarch64--linux-android");
 160
 161     ArchSpec C("arm64_32");
 162     ArchSpec D("arm64_32--watchos");
 163
 164     EXPECT_TRUE(A.IsValid());
 165     EXPECT_TRUE(B.IsValid());
 166     EXPECT_TRUE(C.IsValid());
 167     EXPECT_TRUE(D.IsValid());
 168
 169     EXPECT_EQ(llvm::Triple::ArchType::aarch64, B.GetTriple().getArch());
 170     EXPECT_EQ(llvm::Triple::VendorType::UnknownVendor,
 171               B.GetTriple().getVendor());
 172     EXPECT_EQ(llvm::Triple::OSType::Linux, B.GetTriple().getOS());
 173     EXPECT_EQ(llvm::Triple::EnvironmentType::Android,
 174               B.GetTriple().getEnvironment());
 175
 176     A.MergeFrom(B);
 177     EXPECT_EQ(llvm::Triple::ArchType::aarch64, A.GetTriple().getArch());
 178     EXPECT_EQ(llvm::Triple::VendorType::UnknownVendor,
 179               A.GetTriple().getVendor());
 180     EXPECT_EQ(llvm::Triple::OSType::Linux, A.GetTriple().getOS());
 181     EXPECT_EQ(llvm::Triple::EnvironmentType::Android,
 182               A.GetTriple().getEnvironment());
 183
 184     EXPECT_EQ(llvm::Triple::ArchType::aarch64_32, D.GetTriple().getArch());
 185     EXPECT_EQ(llvm::Triple::VendorType::UnknownVendor,
 186               D.GetTriple().getVendor());
 187     EXPECT_EQ(llvm::Triple::OSType::WatchOS, D.GetTriple().getOS());
 188
 189     C.MergeFrom(D);
 190     EXPECT_EQ(llvm::Triple::ArchType::aarch64_32, C.GetTriple().getArch());
 191     EXPECT_EQ(llvm::Triple::VendorType::UnknownVendor,
 192               C.GetTriple().getVendor());
 193     EXPECT_EQ(llvm::Triple::OSType::WatchOS, C.GetTriple().getOS());
 194   }
 195   {
 196     ArchSpec A, B;
 197     A.SetArchitecture(eArchTypeELF, llvm::ELF::EM_ARM,
 198                       LLDB_INVALID_CPUTYPE, llvm::ELF::ELFOSABI_NONE);
 199     B.SetArchitecture(eArchTypeELF, llvm::ELF::EM_ARM,
 200                       LLDB_INVALID_CPUTYPE, llvm::ELF::ELFOSABI_LINUX);
 201
 202     EXPECT_TRUE(A.IsValid());
 203     EXPECT_TRUE(B.IsValid());
 204
 205     EXPECT_EQ(llvm::Triple::ArchType::arm, B.GetTriple().getArch());
 206     EXPECT_EQ(llvm::Triple::VendorType::UnknownVendor,
 207               B.GetTriple().getVendor());
 208     EXPECT_EQ(llvm::Triple::OSType::Linux, B.GetTriple().getOS());
 209     EXPECT_EQ(llvm::Triple::EnvironmentType::UnknownEnvironment,
 210               B.GetTriple().getEnvironment());
 211
 212     A.MergeFrom(B);
 213     EXPECT_EQ(llvm::Triple::ArchType::arm, A.GetTriple().getArch());
 214     EXPECT_EQ(llvm::Triple::VendorType::UnknownVendor,
 215               A.GetTriple().getVendor());
 216     EXPECT_EQ(llvm::Triple::OSType::Linux, A.GetTriple().getOS());
 217     EXPECT_EQ(llvm::Triple::EnvironmentType::UnknownEnvironment,
 218               A.GetTriple().getEnvironment());
 219   }
 220   {
 221     ArchSpec A("arm--linux-eabihf");
 222     ArchSpec B("armv8l--linux-gnueabihf");
 223
 224     EXPECT_TRUE(A.IsValid());
 225     EXPECT_TRUE(B.IsValid());
 226
 227     EXPECT_EQ(llvm::Triple::ArchType::arm, A.GetTriple().getArch());
 228     EXPECT_EQ(llvm::Triple::ArchType::arm, B.GetTriple().getArch());
 229
 230     EXPECT_EQ(ArchSpec::eCore_arm_generic, A.GetCore());
 231     EXPECT_EQ(ArchSpec::eCore_arm_armv8l, B.GetCore());
 232
 233     EXPECT_EQ(llvm::Triple::VendorType::UnknownVendor,
 234               A.GetTriple().getVendor());
 235     EXPECT_EQ(llvm::Triple::VendorType::UnknownVendor,
 236               B.GetTriple().getVendor());
 237
 238     EXPECT_EQ(llvm::Triple::OSType::Linux, A.GetTriple().getOS());
 239     EXPECT_EQ(llvm::Triple::OSType::Linux, B.GetTriple().getOS());
 240
 241     EXPECT_EQ(llvm::Triple::EnvironmentType::EABIHF,
 242               A.GetTriple().getEnvironment());
 243     EXPECT_EQ(llvm::Triple::EnvironmentType::GNUEABIHF,
 244               B.GetTriple().getEnvironment());
 245
 246     A.MergeFrom(B);
 247     EXPECT_EQ(llvm::Triple::ArchType::arm, A.GetTriple().getArch());
 248     EXPECT_EQ(ArchSpec::eCore_arm_armv8l, A.GetCore());
 249     EXPECT_EQ(llvm::Triple::VendorType::UnknownVendor,
 250               A.GetTriple().getVendor());
 251     EXPECT_EQ(llvm::Triple::OSType::Linux, A.GetTriple().getOS());
 252     EXPECT_EQ(llvm::Triple::EnvironmentType::EABIHF,
 253               A.GetTriple().getEnvironment());
 254   }
 255 }
 256
 257 TEST(ArchSpecTest, MergeFromMachOUnknown) {
 258   class MyArchSpec : public ArchSpec {
 259   public:
 260     MyArchSpec() {
 261       this->SetTriple("unknown-mach-64");
 262       this->m_core = ArchSpec::eCore_uknownMach64;
 263       this->m_byte_order = eByteOrderLittle;
 264       this->m_flags = 0;
 265     }
 266   };
 267
 268   MyArchSpec A;
 269   ASSERT_TRUE(A.IsValid());
 270   MyArchSpec B;
 271   ASSERT_TRUE(B.IsValid());
 272   A.MergeFrom(B);
 273   ASSERT_EQ(A.GetCore(), ArchSpec::eCore_uknownMach64);
 274 }
 275
 276 TEST(ArchSpecTest, Compatibility) {
 277   {
 278     ArchSpec A("x86_64-apple-macosx10.12");
 279     ArchSpec B("x86_64-apple-macosx10.12");
 280     ASSERT_TRUE(A.IsExactMatch(B));
 281     ASSERT_TRUE(A.IsCompatibleMatch(B));
 282   }
 283   {
 284     // The version information is auxiliary to support availability but
 285     // doesn't affect compatibility.
 286     ArchSpec A("x86_64-apple-macosx10.11");
 287     ArchSpec B("x86_64-apple-macosx10.12");
 288     ASSERT_TRUE(A.IsExactMatch(B));
 289     ASSERT_TRUE(A.IsCompatibleMatch(B));
 290   }
 291   {
 292     ArchSpec A("x86_64-apple-macosx10.13");
 293     ArchSpec B("x86_64h-apple-macosx10.13");
 294     ASSERT_FALSE(A.IsExactMatch(B));
 295     ASSERT_TRUE(A.IsCompatibleMatch(B));
 296   }
 297   {
 298     ArchSpec A("x86_64-apple-macosx");
 299     ArchSpec B("x86_64-apple-ios-simulator");
 300     ASSERT_FALSE(A.IsExactMatch(B));
 301     ASSERT_FALSE(A.IsCompatibleMatch(B));
 302   }
 303   {
 304     ArchSpec A("x86_64-*-*");
 305     ArchSpec B("x86_64-apple-ios-simulator");
 306     ASSERT_FALSE(A.IsExactMatch(B));
 307     ASSERT_FALSE(A.IsCompatibleMatch(B));
 308     ASSERT_FALSE(B.IsExactMatch(A));
 309     ASSERT_FALSE(B.IsCompatibleMatch(A));
 310   }
 311   {
 312     ArchSpec A("x86_64-apple-ios");
 313     ArchSpec B("x86_64-apple-ios-simulator");
 314     ASSERT_FALSE(A.IsExactMatch(B));
 315     ASSERT_FALSE(A.IsCompatibleMatch(B));
 316     ASSERT_FALSE(B.IsExactMatch(A));
 317     ASSERT_FALSE(B.IsCompatibleMatch(A));
 318   }
 319   {
 320     // FIXME: This is surprisingly not equivalent to "x86_64-*-*".
 321     ArchSpec A("x86_64");
 322     ArchSpec B("x86_64-apple-ios-simulator");
 323     ASSERT_FALSE(A.IsExactMatch(B));
 324     ASSERT_TRUE(A.IsCompatibleMatch(B));
 325     ASSERT_FALSE(B.IsExactMatch(A));
 326     ASSERT_TRUE(B.IsCompatibleMatch(A));
 327   }
 328   {
 329     ArchSpec A("arm64-apple-ios");
 330     ArchSpec B("arm64-apple-ios-simulator");
 331     ASSERT_FALSE(A.IsExactMatch(B));
 332     ASSERT_FALSE(A.IsCompatibleMatch(B));
 333     ASSERT_FALSE(B.IsCompatibleMatch(A));
 334     ASSERT_FALSE(B.IsCompatibleMatch(A));
 335   }
 336   {
 337     ArchSpec A("arm64-*-*");
 338     ArchSpec B("arm64-apple-ios");
 339     ASSERT_FALSE(A.IsExactMatch(B));
 340     // FIXME: This looks unintuitive and we should investigate whether
 341     // this is the desired behavior.
 342     ASSERT_FALSE(A.IsCompatibleMatch(B));
 343   }
 344   {
 345     ArchSpec A("x86_64-*-*");
 346     ArchSpec B("x86_64-apple-ios-simulator");
 347     ASSERT_FALSE(A.IsExactMatch(B));
 348     // FIXME: See above, though the extra environment complicates things.
 349     ASSERT_FALSE(A.IsCompatibleMatch(B));
 350   }
 351   {
 352     ArchSpec A("x86_64");
 353     ArchSpec B("x86_64-apple-macosx10.14");
 354     // FIXME: The exact match also looks unintuitive.
 355     ASSERT_TRUE(A.IsExactMatch(B));
 356     ASSERT_TRUE(A.IsCompatibleMatch(B));
 357   }
 358   {
 359     ArchSpec A("x86_64");
 360     ArchSpec B("x86_64-apple-ios12.0.0-macabi");
 361     // FIXME: The exact match also looks unintuitive.
 362     ASSERT_TRUE(A.IsExactMatch(B));
 363     ASSERT_TRUE(A.IsCompatibleMatch(B));
 364   }
 365   {
 366     ArchSpec A("x86_64-apple-ios12.0.0");
 367     ArchSpec B("x86_64-apple-ios12.0.0-macabi");
 368     ASSERT_FALSE(A.IsExactMatch(B));
 369     ASSERT_FALSE(A.IsCompatibleMatch(B));
 370   }
 371   {
 372     ArchSpec A("x86_64-apple-macosx10.14.2");
 373     ArchSpec B("x86_64-apple-ios12.0.0-macabi");
 374     ASSERT_FALSE(A.IsExactMatch(B));
 375     ASSERT_TRUE(A.IsCompatibleMatch(B));
 376   }
 377   {
 378     ArchSpec A("x86_64-apple-macosx10.14.2");
 379     ArchSpec B("x86_64-apple-ios12.0.0-macabi");
 380     // ios-macabi wins.
 381     A.MergeFrom(B);
 382     ASSERT_TRUE(A.IsExactMatch(B));
 383   }
 384   {
 385     ArchSpec A("x86_64-apple-macosx10.14.2");
 386     ArchSpec B("x86_64-apple-ios12.0.0-macabi");
 387     ArchSpec C(B);
 388     // ios-macabi wins.
 389     B.MergeFrom(A);
 390     ASSERT_TRUE(B.IsExactMatch(C));
 391   }
 392 }
 393
 394 TEST(ArchSpecTest, OperatorBool) {
 395   EXPECT_FALSE(ArchSpec());
 396   EXPECT_TRUE(ArchSpec("x86_64-pc-linux"));
 397 }
 398
 399 TEST(ArchSpecTest, TripleComponentsWereSpecified) {
 400   {
 401     ArchSpec A("");
 402     ArchSpec B("-");
 403     ArchSpec C("--");
 404     ArchSpec D("---");
 405
 406     ASSERT_FALSE(A.TripleVendorWasSpecified());
 407     ASSERT_FALSE(A.TripleOSWasSpecified());
 408     ASSERT_FALSE(A.TripleEnvironmentWasSpecified());
 409
 410     ASSERT_FALSE(B.TripleVendorWasSpecified());
 411     ASSERT_FALSE(B.TripleOSWasSpecified());
 412     ASSERT_FALSE(B.TripleEnvironmentWasSpecified());
 413
 414     ASSERT_FALSE(C.TripleVendorWasSpecified());
 415     ASSERT_FALSE(C.TripleOSWasSpecified());
 416     ASSERT_FALSE(C.TripleEnvironmentWasSpecified());
 417
 418     ASSERT_FALSE(D.TripleVendorWasSpecified());
 419     ASSERT_FALSE(D.TripleOSWasSpecified());
 420     ASSERT_FALSE(D.TripleEnvironmentWasSpecified());
 421   }
 422   {
 423     // TODO: llvm::Triple::normalize treats the missing components from these
 424     // triples as specified unknown components instead of unspecified
 425     // components. We need to either change the behavior in llvm or work around
 426     // this in lldb.
 427     ArchSpec A("armv7");
 428     ArchSpec B("armv7-");
 429     ArchSpec C("armv7--");
 430     ArchSpec D("armv7---");
 431
 432     ASSERT_FALSE(A.TripleVendorWasSpecified());
 433     ASSERT_FALSE(A.TripleOSWasSpecified());
 434     ASSERT_FALSE(A.TripleEnvironmentWasSpecified());
 435
 436     ASSERT_TRUE(B.TripleVendorWasSpecified());
 437     ASSERT_FALSE(B.TripleOSWasSpecified());
 438     ASSERT_FALSE(B.TripleEnvironmentWasSpecified());
 439
 440     ASSERT_TRUE(C.TripleVendorWasSpecified());
 441     ASSERT_TRUE(C.TripleOSWasSpecified());
 442     ASSERT_FALSE(C.TripleEnvironmentWasSpecified());
 443
 444     ASSERT_TRUE(D.TripleVendorWasSpecified());
 445     ASSERT_TRUE(D.TripleOSWasSpecified());
 446     ASSERT_TRUE(D.TripleEnvironmentWasSpecified());
 447   }
 448   {
 449     ArchSpec A("x86_64-unknown");
 450     ArchSpec B("powerpc-unknown-linux");
 451     ArchSpec C("i386-pc-windows-msvc");
 452     ArchSpec D("aarch64-unknown-linux-android");
 453
 454     ASSERT_TRUE(A.TripleVendorWasSpecified());
 455     ASSERT_FALSE(A.TripleOSWasSpecified());
 456     ASSERT_FALSE(A.TripleEnvironmentWasSpecified());
 457
 458     ASSERT_TRUE(B.TripleVendorWasSpecified());
 459     ASSERT_TRUE(B.TripleOSWasSpecified());
 460     ASSERT_FALSE(B.TripleEnvironmentWasSpecified());
 461
 462     ASSERT_TRUE(C.TripleVendorWasSpecified());
 463     ASSERT_TRUE(C.TripleOSWasSpecified());
 464     ASSERT_TRUE(C.TripleEnvironmentWasSpecified());
 465
 466     ASSERT_TRUE(D.TripleVendorWasSpecified());
 467     ASSERT_TRUE(D.TripleOSWasSpecified());
 468     ASSERT_TRUE(D.TripleEnvironmentWasSpecified());
 469   }
 470 }
 471
 472 TEST(ArchSpecTest, YAML) {
 473   std::string buffer;
 474   llvm::raw_string_ostream os(buffer);
 475
 476   // Serialize.
 477   llvm::yaml::Output yout(os);
 478   std::vector<ArchSpec> archs = {ArchSpec("x86_64-pc-linux"),
 479                                  ArchSpec("x86_64-apple-macosx10.12"),
 480                                  ArchSpec("i686-pc-windows")};
 481   yout << archs;
 482   os.flush();
 483
 484   // Deserialize.
 485   std::vector<ArchSpec> deserialized;
 486   llvm::yaml::Input yin(buffer);
 487   yin >> deserialized;
 488
 489   EXPECT_EQ(archs, deserialized);
 490 }