gpu/config/gpu_control_list_entry_unittest.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/json/json_reader.h"
   6 #include "gpu/config/gpu_control_list.h"
   7 #include "gpu/config/gpu_info.h"
   8 #include "testing/gtest/include/gtest/gtest.h"
   9
  10 #define LONG_STRING_CONST(...) #__VA_ARGS__
  11
  12 namespace gpu {
  13
  14 enum TestFeatureType {
  15   TEST_FEATURE_0 = 0,
  16   TEST_FEATURE_1,
  17   TEST_FEATURE_2
  18 };
  19
  20 class GpuControlListEntryTest : public testing::Test {
  21  public:
  22   GpuControlListEntryTest() { }
  23   virtual ~GpuControlListEntryTest() { }
  24
  25   const GPUInfo& gpu_info() const {
  26     return gpu_info_;
  27   }
  28
  29   typedef GpuControlList::ScopedGpuControlListEntry ScopedEntry;
  30
  31   static ScopedEntry GetEntryFromString(
  32       const std::string& json, bool supports_feature_type_all) {
  33     scoped_ptr<base::Value> root;
  34     root.reset(base::JSONReader::Read(json));
  35     DictionaryValue* value = NULL;
  36     if (root.get() == NULL || !root->GetAsDictionary(&value))
  37       return NULL;
  38
  39     GpuControlList::FeatureMap feature_map;
  40     feature_map["test_feature_0"] = TEST_FEATURE_0;
  41     feature_map["test_feature_1"] = TEST_FEATURE_1;
  42     feature_map["test_feature_2"] = TEST_FEATURE_2;
  43
  44     return GpuControlList::GpuControlListEntry::GetEntryFromValue(
  45         value, true, feature_map, supports_feature_type_all);
  46   }
  47
  48   static ScopedEntry GetEntryFromString(const std::string& json) {
  49     return GetEntryFromString(json, false);
  50   }
  51
  52   virtual void SetUp() {
  53     gpu_info_.gpu.vendor_id = 0x10de;
  54     gpu_info_.gpu.device_id = 0x0640;
  55     gpu_info_.driver_vendor = "NVIDIA";
  56     gpu_info_.driver_version = "1.6.18";
  57     gpu_info_.driver_date = "7-14-2009";
  58     gpu_info_.machine_model = "MacBookPro 7.1";
  59     gpu_info_.gl_vendor = "NVIDIA Corporation";
  60     gpu_info_.gl_renderer = "NVIDIA GeForce GT 120 OpenGL Engine";
  61     gpu_info_.performance_stats.graphics = 5.0;
  62     gpu_info_.performance_stats.gaming = 5.0;
  63     gpu_info_.performance_stats.overall = 5.0;
  64   }
  65
  66  private:
  67   GPUInfo gpu_info_;
  68 };
  69
  70 TEST_F(GpuControlListEntryTest, DetailedEntry) {
  71   const std::string json = LONG_STRING_CONST(
  72       {
  73         "id": 5,
  74         "description": "test entry",
  75         "cr_bugs": [1024, 678],
  76         "webkit_bugs": [1950],
  77         "os": {
  78           "type": "macosx",
  79           "version": {
  80             "op": "=",
  81             "number": "10.6.4"
  82           }
  83         },
  84         "vendor_id": "0x10de",
  85         "device_id": ["0x0640"],
  86         "driver_version": {
  87           "op": "=",
  88           "number": "1.6.18"
  89         },
  90         "features": [
  91           "test_feature_0"
  92         ]
  93       }
  94   );
  95
  96   ScopedEntry entry(GetEntryFromString(json));
  97   EXPECT_TRUE(entry.get() != NULL);
  98   EXPECT_EQ(GpuControlList::kOsMacosx, entry->GetOsType());
  99   EXPECT_FALSE(entry->disabled());
 100   EXPECT_EQ(5u, entry->id());
 101   EXPECT_STREQ("test entry", entry->description().c_str());
 102   EXPECT_EQ(2u, entry->cr_bugs().size());
 103   EXPECT_EQ(1024, entry->cr_bugs()[0]);
 104   EXPECT_EQ(678, entry->cr_bugs()[1]);
 105   EXPECT_EQ(1u, entry->webkit_bugs().size());
 106   EXPECT_EQ(1950, entry->webkit_bugs()[0]);
 107   EXPECT_EQ(1u, entry->features().size());
 108   EXPECT_EQ(1u, entry->features().count(TEST_FEATURE_0));
 109   EXPECT_FALSE(entry->contains_unknown_fields());
 110   EXPECT_FALSE(entry->contains_unknown_features());
 111   EXPECT_FALSE(entry->NeedsMoreInfo(gpu_info()));
 112   EXPECT_TRUE(entry->Contains(
 113       GpuControlList::kOsMacosx, "10.6.4", gpu_info()));
 114 }
 115
 116 TEST_F(GpuControlListEntryTest, VendorOnAllOsEntry) {
 117   const std::string json = LONG_STRING_CONST(
 118       {
 119         "id": 1,
 120         "vendor_id": "0x10de",
 121         "features": [
 122           "test_feature_0"
 123         ]
 124       }
 125   );
 126   ScopedEntry entry(GetEntryFromString(json));
 127   EXPECT_TRUE(entry.get() != NULL);
 128   EXPECT_EQ(GpuControlList::kOsAny, entry->GetOsType());
 129
 130   const GpuControlList::OsType os_type[] = {
 131     GpuControlList::kOsMacosx,
 132     GpuControlList::kOsWin,
 133     GpuControlList::kOsLinux,
 134     GpuControlList::kOsChromeOS,
 135     GpuControlList::kOsAndroid
 136   };
 137   for (size_t i = 0; i < arraysize(os_type); ++i)
 138     EXPECT_TRUE(entry->Contains(os_type[i], "10.6", gpu_info()));
 139 }
 140
 141 TEST_F(GpuControlListEntryTest, VendorOnLinuxEntry) {
 142   const std::string json = LONG_STRING_CONST(
 143       {
 144         "id": 1,
 145         "os": {
 146           "type": "linux"
 147         },
 148         "vendor_id": "0x10de",
 149         "features": [
 150           "test_feature_0"
 151         ]
 152       }
 153   );
 154   ScopedEntry entry(GetEntryFromString(json));
 155   EXPECT_TRUE(entry.get() != NULL);
 156   EXPECT_EQ(GpuControlList::kOsLinux, entry->GetOsType());
 157
 158   const GpuControlList::OsType os_type[] = {
 159     GpuControlList::kOsMacosx,
 160     GpuControlList::kOsWin,
 161     GpuControlList::kOsChromeOS,
 162     GpuControlList::kOsAndroid
 163   };
 164   for (size_t i = 0; i < arraysize(os_type); ++i)
 165     EXPECT_FALSE(entry->Contains(os_type[i], "10.6", gpu_info()));
 166   EXPECT_TRUE(entry->Contains(
 167       GpuControlList::kOsLinux, "10.6", gpu_info()));
 168 }
 169
 170 TEST_F(GpuControlListEntryTest, AllExceptNVidiaOnLinuxEntry) {
 171   const std::string json = LONG_STRING_CONST(
 172       {
 173         "id": 1,
 174         "os": {
 175           "type": "linux"
 176         },
 177         "exceptions": [
 178           {
 179             "vendor_id": "0x10de"
 180           }
 181         ],
 182         "features": [
 183           "test_feature_0"
 184         ]
 185       }
 186   );
 187   ScopedEntry entry(GetEntryFromString(json));
 188   EXPECT_TRUE(entry.get() != NULL);
 189   EXPECT_EQ(GpuControlList::kOsLinux, entry->GetOsType());
 190
 191   const GpuControlList::OsType os_type[] = {
 192     GpuControlList::kOsMacosx,
 193     GpuControlList::kOsWin,
 194     GpuControlList::kOsLinux,
 195     GpuControlList::kOsChromeOS,
 196     GpuControlList::kOsAndroid
 197   };
 198   for (size_t i = 0; i < arraysize(os_type); ++i)
 199     EXPECT_FALSE(entry->Contains(os_type[i], "10.6", gpu_info()));
 200 }
 201
 202 TEST_F(GpuControlListEntryTest, AllExceptIntelOnLinuxEntry) {
 203   const std::string json = LONG_STRING_CONST(
 204       {
 205         "id": 1,
 206         "os": {
 207           "type": "linux"
 208         },
 209         "exceptions": [
 210           {
 211             "vendor_id": "0x8086"
 212           }
 213         ],
 214         "features": [
 215           "test_feature_0"
 216         ]
 217       }
 218   );
 219   ScopedEntry entry(GetEntryFromString(json));
 220   EXPECT_TRUE(entry.get() != NULL);
 221   EXPECT_EQ(GpuControlList::kOsLinux, entry->GetOsType());
 222
 223   const GpuControlList::OsType os_type[] = {
 224     GpuControlList::kOsMacosx,
 225     GpuControlList::kOsWin,
 226     GpuControlList::kOsChromeOS,
 227     GpuControlList::kOsAndroid
 228   };
 229   for (size_t i = 0; i < arraysize(os_type); ++i)
 230     EXPECT_FALSE(entry->Contains(os_type[i], "10.6", gpu_info()));
 231   EXPECT_TRUE(entry->Contains(
 232       GpuControlList::kOsLinux, "10.6", gpu_info()));
 233 }
 234
 235 TEST_F(GpuControlListEntryTest, DateOnWindowsEntry) {
 236   const std::string json = LONG_STRING_CONST(
 237       {
 238         "id": 1,
 239         "os": {
 240           "type": "win"
 241         },
 242         "driver_date": {
 243           "op": "<",
 244           "number": "2010.5.8"
 245         },
 246         "features": [
 247           "test_feature_0"
 248         ]
 249       }
 250   );
 251   ScopedEntry entry(GetEntryFromString(json));
 252   EXPECT_TRUE(entry.get() != NULL);
 253   EXPECT_EQ(GpuControlList::kOsWin, entry->GetOsType());
 254
 255   GPUInfo gpu_info;
 256   gpu_info.driver_date = "4-12-2010";
 257   EXPECT_TRUE(entry->Contains(
 258       GpuControlList::kOsWin, "10.6", gpu_info));
 259   gpu_info.driver_date = "5-8-2010";
 260   EXPECT_FALSE(entry->Contains(
 261       GpuControlList::kOsWin, "10.6", gpu_info));
 262   gpu_info.driver_date = "5-9-2010";
 263   EXPECT_FALSE(entry->Contains(
 264       GpuControlList::kOsWin, "10.6", gpu_info));
 265 }
 266
 267 TEST_F(GpuControlListEntryTest, MultipleDevicesEntry) {
 268   const std::string json = LONG_STRING_CONST(
 269       {
 270         "id": 1,
 271         "vendor_id": "0x10de",
 272         "device_id": ["0x1023", "0x0640"],
 273         "features": [
 274           "test_feature_0"
 275         ]
 276       }
 277   );
 278   ScopedEntry entry(GetEntryFromString(json));
 279   EXPECT_TRUE(entry.get() != NULL);
 280   EXPECT_EQ(GpuControlList::kOsAny, entry->GetOsType());
 281
 282   const GpuControlList::OsType os_type[] = {
 283     GpuControlList::kOsMacosx,
 284     GpuControlList::kOsWin,
 285     GpuControlList::kOsLinux,
 286     GpuControlList::kOsChromeOS,
 287     GpuControlList::kOsAndroid
 288   };
 289   for (size_t i = 0; i < arraysize(os_type); ++i)
 290     EXPECT_TRUE(entry->Contains(os_type[i], "10.6", gpu_info()));
 291 }
 292
 293 TEST_F(GpuControlListEntryTest, ChromeOSEntry) {
 294   const std::string json = LONG_STRING_CONST(
 295       {
 296         "id": 1,
 297         "os": {
 298           "type": "chromeos"
 299         },
 300         "features": [
 301           "test_feature_0"
 302         ]
 303       }
 304   );
 305   ScopedEntry entry(GetEntryFromString(json));
 306   EXPECT_TRUE(entry.get() != NULL);
 307   EXPECT_EQ(GpuControlList::kOsChromeOS, entry->GetOsType());
 308
 309   const GpuControlList::OsType os_type[] = {
 310     GpuControlList::kOsMacosx,
 311     GpuControlList::kOsWin,
 312     GpuControlList::kOsLinux,
 313     GpuControlList::kOsAndroid
 314   };
 315   for (size_t i = 0; i < arraysize(os_type); ++i)
 316     EXPECT_FALSE(entry->Contains(os_type[i], "10.6", gpu_info()));
 317   EXPECT_TRUE(entry->Contains(
 318       GpuControlList::kOsChromeOS, "10.6", gpu_info()));
 319 }
 320
 321 TEST_F(GpuControlListEntryTest, MalformedVendor) {
 322   const std::string json = LONG_STRING_CONST(
 323       {
 324         "id": 1,
 325         "vendor_id": "[0x10de]",
 326         "features": [
 327           "test_feature_0"
 328         ]
 329       }
 330   );
 331   ScopedEntry entry(GetEntryFromString(json));
 332   EXPECT_TRUE(entry.get() == NULL);
 333 }
 334
 335 TEST_F(GpuControlListEntryTest, UnknownFieldEntry) {
 336   const std::string json = LONG_STRING_CONST(
 337       {
 338         "id": 1,
 339         "unknown_field": 0,
 340         "features": [
 341           "test_feature_0"
 342         ]
 343       }
 344   );
 345   ScopedEntry entry(GetEntryFromString(json));
 346   EXPECT_TRUE(entry.get() != NULL);
 347   EXPECT_TRUE(entry->contains_unknown_fields());
 348   EXPECT_FALSE(entry->contains_unknown_features());
 349 }
 350
 351 TEST_F(GpuControlListEntryTest, UnknownExceptionFieldEntry) {
 352   const std::string json = LONG_STRING_CONST(
 353       {
 354         "id": 2,
 355         "exceptions": [
 356           {
 357             "unknown_field": 0
 358           }
 359         ],
 360         "features": [
 361           "test_feature_0"
 362         ]
 363       }
 364   );
 365   ScopedEntry entry(GetEntryFromString(json));
 366   EXPECT_TRUE(entry.get() != NULL);
 367   EXPECT_TRUE(entry->contains_unknown_fields());
 368   EXPECT_FALSE(entry->contains_unknown_features());
 369 }
 370
 371 TEST_F(GpuControlListEntryTest, UnknownFeatureEntry) {
 372   const std::string json = LONG_STRING_CONST(
 373       {
 374         "id": 1,
 375         "features": [
 376           "some_unknown_feature",
 377           "test_feature_0"
 378         ]
 379       }
 380   );
 381   ScopedEntry entry(GetEntryFromString(json));
 382   EXPECT_TRUE(entry.get() != NULL);
 383   EXPECT_FALSE(entry->contains_unknown_fields());
 384   EXPECT_TRUE(entry->contains_unknown_features());
 385   EXPECT_EQ(1u, entry->features().size());
 386   EXPECT_EQ(1u, entry->features().count(TEST_FEATURE_0));
 387
 388   const GpuControlList::OsType os_type[] = {
 389     GpuControlList::kOsMacosx,
 390     GpuControlList::kOsWin,
 391     GpuControlList::kOsLinux,
 392     GpuControlList::kOsChromeOS,
 393     GpuControlList::kOsAndroid
 394   };
 395   for (size_t i = 0; i < arraysize(os_type); ++i)
 396     EXPECT_TRUE(entry->Contains(os_type[i], "10.6", gpu_info()));
 397 }
 398
 399 TEST_F(GpuControlListEntryTest, GlVendorEntry) {
 400   const std::string json = LONG_STRING_CONST(
 401       {
 402         "id": 1,
 403         "gl_vendor": {
 404           "op": "beginwith",
 405           "value": "NVIDIA"
 406         },
 407         "features": [
 408           "test_feature_0"
 409         ]
 410       }
 411   );
 412   ScopedEntry entry(GetEntryFromString(json));
 413   EXPECT_TRUE(entry.get() != NULL);
 414
 415   const GpuControlList::OsType os_type[] = {
 416     GpuControlList::kOsMacosx,
 417     GpuControlList::kOsWin,
 418     GpuControlList::kOsLinux,
 419     GpuControlList::kOsChromeOS,
 420     GpuControlList::kOsAndroid
 421   };
 422   for (size_t i = 0; i < arraysize(os_type); ++i)
 423     EXPECT_TRUE(entry->Contains(os_type[i], "10.6", gpu_info()));
 424 }
 425
 426 TEST_F(GpuControlListEntryTest, GlRendererEntry) {
 427   const std::string json = LONG_STRING_CONST(
 428       {
 429         "id": 1,
 430         "gl_renderer": {
 431           "op": "contains",
 432           "value": "GeForce"
 433         },
 434         "features": [
 435           "test_feature_0"
 436         ]
 437       }
 438   );
 439   ScopedEntry entry(GetEntryFromString(json));
 440   EXPECT_TRUE(entry.get() != NULL);
 441
 442   const GpuControlList::OsType os_type[] = {
 443     GpuControlList::kOsMacosx,
 444     GpuControlList::kOsWin,
 445     GpuControlList::kOsLinux,
 446     GpuControlList::kOsChromeOS,
 447     GpuControlList::kOsAndroid
 448   };
 449   for (size_t i = 0; i < arraysize(os_type); ++i)
 450     EXPECT_TRUE(entry->Contains(os_type[i], "10.6", gpu_info()));
 451 }
 452
 453 TEST_F(GpuControlListEntryTest, PerfGraphicsEntry) {
 454   const std::string json = LONG_STRING_CONST(
 455       {
 456         "id": 1,
 457         "perf_graphics": {
 458           "op": "<",
 459           "value": "6.0"
 460         },
 461         "features": [
 462           "test_feature_0"
 463         ]
 464       }
 465   );
 466   ScopedEntry entry(GetEntryFromString(json));
 467   EXPECT_TRUE(entry.get() != NULL);
 468   EXPECT_TRUE(entry->Contains(GpuControlList::kOsWin, "10.6", gpu_info()));
 469 }
 470
 471 TEST_F(GpuControlListEntryTest, PerfGamingEntry) {
 472   const std::string json = LONG_STRING_CONST(
 473       {
 474         "id": 1,
 475         "perf_graphics": {
 476           "op": "<=",
 477           "value": "4.0"
 478         },
 479         "features": [
 480           "test_feature_0"
 481         ]
 482       }
 483   );
 484   ScopedEntry entry(GetEntryFromString(json));
 485   EXPECT_TRUE(entry.get() != NULL);
 486   EXPECT_FALSE(entry->Contains(GpuControlList::kOsWin, "10.6", gpu_info()));
 487 }
 488
 489 TEST_F(GpuControlListEntryTest, PerfOverallEntry) {
 490   const std::string json = LONG_STRING_CONST(
 491       {
 492         "id": 1,
 493         "perf_overall": {
 494           "op": "between",
 495           "value": "1.0",
 496           "value2": "9.0"
 497         },
 498         "features": [
 499           "test_feature_0"
 500         ]
 501       }
 502   );
 503   ScopedEntry entry(GetEntryFromString(json));
 504   EXPECT_TRUE(entry.get() != NULL);
 505   EXPECT_TRUE(entry->Contains(GpuControlList::kOsWin, "10.6", gpu_info()));
 506 }
 507
 508 TEST_F(GpuControlListEntryTest, DisabledEntry) {
 509   const std::string json = LONG_STRING_CONST(
 510       {
 511         "id": 1,
 512         "disabled": true,
 513         "features": [
 514           "test_feature_0"
 515         ]
 516       }
 517   );
 518   ScopedEntry entry(GetEntryFromString(json));
 519   EXPECT_TRUE(entry.get() != NULL);
 520   EXPECT_TRUE(entry->disabled());
 521 }
 522
 523 TEST_F(GpuControlListEntryTest, OptimusEntry) {
 524   const std::string json = LONG_STRING_CONST(
 525       {
 526         "id": 1,
 527         "os": {
 528           "type": "linux"
 529         },
 530         "multi_gpu_style": "optimus",
 531         "features": [
 532           "test_feature_0"
 533         ]
 534       }
 535   );
 536   GPUInfo gpu_info;
 537   gpu_info.optimus = true;
 538
 539   ScopedEntry entry(GetEntryFromString(json));
 540   EXPECT_TRUE(entry.get() != NULL);
 541   EXPECT_EQ(GpuControlList::kOsLinux, entry->GetOsType());
 542   EXPECT_TRUE(entry->Contains(
 543       GpuControlList::kOsLinux, "10.6", gpu_info));
 544 }
 545
 546 TEST_F(GpuControlListEntryTest, AMDSwitchableEntry) {
 547   const std::string json = LONG_STRING_CONST(
 548       {
 549         "id": 1,
 550         "os": {
 551           "type": "macosx"
 552         },
 553         "multi_gpu_style": "amd_switchable",
 554         "features": [
 555           "test_feature_0"
 556         ]
 557       }
 558   );
 559   GPUInfo gpu_info;
 560   gpu_info.amd_switchable = true;
 561
 562   ScopedEntry entry(GetEntryFromString(json));
 563   EXPECT_TRUE(entry.get() != NULL);
 564   EXPECT_EQ(GpuControlList::kOsMacosx, entry->GetOsType());
 565   EXPECT_TRUE(entry->Contains(
 566       GpuControlList::kOsMacosx, "10.6", gpu_info));
 567 }
 568
 569 TEST_F(GpuControlListEntryTest, LexicalDriverVersionEntry) {
 570   const std::string json = LONG_STRING_CONST(
 571       {
 572         "id": 1,
 573         "os": {
 574           "type": "linux"
 575         },
 576         "vendor_id": "0x1002",
 577         "driver_version": {
 578           "op": "=",
 579           "style": "lexical",
 580           "number": "8.76"
 581         },
 582         "features": [
 583           "test_feature_0"
 584         ]
 585       }
 586   );
 587   GPUInfo gpu_info;
 588   gpu_info.gpu.vendor_id = 0x1002;
 589
 590   ScopedEntry entry(GetEntryFromString(json));
 591   EXPECT_TRUE(entry.get() != NULL);
 592   EXPECT_EQ(GpuControlList::kOsLinux, entry->GetOsType());
 593
 594   gpu_info.driver_version = "8.76";
 595   EXPECT_TRUE(entry->Contains(
 596       GpuControlList::kOsLinux, "10.6", gpu_info));
 597
 598   gpu_info.driver_version = "8.768";
 599   EXPECT_TRUE(entry->Contains(
 600       GpuControlList::kOsLinux, "10.6", gpu_info));
 601
 602   gpu_info.driver_version = "8.76.8";
 603   EXPECT_TRUE(entry->Contains(
 604       GpuControlList::kOsLinux, "10.6", gpu_info));
 605 }
 606
 607 TEST_F(GpuControlListEntryTest, MultipleGPUsAnyEntry) {
 608   const std::string json = LONG_STRING_CONST(
 609       {
 610         "id": 1,
 611         "os": {
 612           "type": "macosx"
 613         },
 614         "vendor_id": "0x8086",
 615         "device_id": ["0x0166"],
 616         "multi_gpu_category": "any",
 617         "features": [
 618           "test_feature_0"
 619         ]
 620       }
 621   );
 622   ScopedEntry entry(GetEntryFromString(json));
 623   EXPECT_TRUE(entry.get() != NULL);
 624   EXPECT_EQ(GpuControlList::kOsMacosx, entry->GetOsType());
 625
 626   GPUInfo gpu_info;
 627   gpu_info.gpu.vendor_id = 0x10de;
 628   gpu_info.gpu.device_id = 0x1976;
 629   EXPECT_FALSE(entry->Contains(
 630       GpuControlList::kOsMacosx, "10.6", gpu_info));
 631
 632   GPUInfo::GPUDevice gpu_device;
 633   gpu_device.vendor_id = 0x8086;
 634   gpu_device.device_id = 0x0166;
 635   gpu_info.secondary_gpus.push_back(gpu_device);
 636   EXPECT_TRUE(entry->Contains(
 637       GpuControlList::kOsMacosx, "10.6", gpu_info));
 638 }
 639
 640 TEST_F(GpuControlListEntryTest, MultipleGPUsSecondaryEntry) {
 641   const std::string json = LONG_STRING_CONST(
 642       {
 643         "id": 1,
 644         "os": {
 645           "type": "macosx"
 646         },
 647         "vendor_id": "0x8086",
 648         "device_id": ["0x0166"],
 649         "multi_gpu_category": "secondary",
 650         "features": [
 651           "test_feature_0"
 652         ]
 653       }
 654   );
 655   ScopedEntry entry(GetEntryFromString(json));
 656   EXPECT_TRUE(entry.get() != NULL);
 657   EXPECT_EQ(GpuControlList::kOsMacosx, entry->GetOsType());
 658
 659   GPUInfo gpu_info;
 660   gpu_info.gpu.vendor_id = 0x10de;
 661   gpu_info.gpu.device_id = 0x1976;
 662   EXPECT_FALSE(entry->Contains(
 663       GpuControlList::kOsMacosx, "10.6", gpu_info));
 664
 665   GPUInfo::GPUDevice gpu_device;
 666   gpu_device.vendor_id = 0x8086;
 667   gpu_device.device_id = 0x0166;
 668   gpu_info.secondary_gpus.push_back(gpu_device);
 669   EXPECT_TRUE(entry->Contains(
 670       GpuControlList::kOsMacosx, "10.6", gpu_info));
 671 }
 672
 673 TEST_F(GpuControlListEntryTest, NeedsMoreInfoEntry) {
 674   const std::string json = LONG_STRING_CONST(
 675       {
 676         "id": 1,
 677         "vendor_id": "0x8086",
 678         "driver_version": {
 679           "op": "<",
 680           "number": "10.7"
 681         },
 682         "features": [
 683           "test_feature_1"
 684         ]
 685       }
 686   );
 687   ScopedEntry entry(GetEntryFromString(json));
 688   EXPECT_TRUE(entry.get() != NULL);
 689
 690   GPUInfo gpu_info;
 691   gpu_info.gpu.vendor_id = 0x8086;
 692   EXPECT_TRUE(entry->NeedsMoreInfo(gpu_info));
 693
 694   gpu_info.driver_version = "10.6";
 695   EXPECT_FALSE(entry->NeedsMoreInfo(gpu_info));
 696 }
 697
 698 TEST_F(GpuControlListEntryTest, NeedsMoreInfoForExceptionsEntry) {
 699   const std::string json = LONG_STRING_CONST(
 700       {
 701         "id": 1,
 702         "vendor_id": "0x8086",
 703         "exceptions": [
 704           {
 705             "gl_renderer": {
 706               "op": "contains",
 707               "value": "mesa"
 708             }
 709           }
 710         ],
 711         "features": [
 712           "test_feature_1"
 713         ]
 714       }
 715   );
 716   ScopedEntry entry(GetEntryFromString(json));
 717   EXPECT_TRUE(entry.get() != NULL);
 718
 719   GPUInfo gpu_info;
 720   gpu_info.gpu.vendor_id = 0x8086;
 721   EXPECT_TRUE(entry->NeedsMoreInfo(gpu_info));
 722
 723   gpu_info.gl_renderer = "mesa";
 724   EXPECT_FALSE(entry->NeedsMoreInfo(gpu_info));
 725 }
 726
 727 TEST_F(GpuControlListEntryTest, FeatureTypeAllEntry) {
 728   const std::string json = LONG_STRING_CONST(
 729       {
 730         "id": 1,
 731         "features": [
 732           "all"
 733         ]
 734       }
 735   );
 736   ScopedEntry entry(GetEntryFromString(json, true));
 737   EXPECT_TRUE(entry.get() != NULL);
 738   EXPECT_EQ(3u, entry->features().size());
 739   EXPECT_EQ(1u, entry->features().count(TEST_FEATURE_0));
 740   EXPECT_EQ(1u, entry->features().count(TEST_FEATURE_1));
 741   EXPECT_EQ(1u, entry->features().count(TEST_FEATURE_2));
 742 }
 743
 744 }  // namespace gpu
 745