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   ~GpuControlListEntryTest() override {}
  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 = base::JSONReader::Read(json);
  34     base::DictionaryValue* value = NULL;
  35     if (!root || !root->GetAsDictionary(&value))
  36       return NULL;
  37
  38     GpuControlList::FeatureMap feature_map;
  39     feature_map["test_feature_0"] = TEST_FEATURE_0;
  40     feature_map["test_feature_1"] = TEST_FEATURE_1;
  41     feature_map["test_feature_2"] = TEST_FEATURE_2;
  42
  43     return GpuControlList::GpuControlListEntry::GetEntryFromValue(
  44         value, true, feature_map, supports_feature_type_all);
  45   }
  46
  47   static ScopedEntry GetEntryFromString(const std::string& json) {
  48     return GetEntryFromString(json, false);
  49   }
  50
  51   void SetUp() override {
  52     gpu_info_.gpu.vendor_id = 0x10de;
  53     gpu_info_.gpu.device_id = 0x0640;
  54     gpu_info_.gpu.active = true;
  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_.gl_version = "2.1 NVIDIA-8.24.11 310.90.9b01";
  59     gpu_info_.gl_vendor = "NVIDIA Corporation";
  60     gpu_info_.gl_renderer = "NVIDIA GeForce GT 120 OpenGL Engine";
  61   }
  62
  63  protected:
  64   GPUInfo gpu_info_;
  65 };
  66
  67 TEST_F(GpuControlListEntryTest, DetailedEntry) {
  68   const std::string json = LONG_STRING_CONST(
  69       {
  70         "id": 5,
  71         "description": "test entry",
  72         "cr_bugs": [1024, 678],
  73         "webkit_bugs": [1950],
  74         "os": {
  75           "type": "macosx",
  76           "version": {
  77             "op": "=",
  78             "value": "10.6.4"
  79           }
  80         },
  81         "vendor_id": "0x10de",
  82         "device_id": ["0x0640"],
  83         "driver_version": {
  84           "op": "=",
  85           "value": "1.6.18"
  86         },
  87         "features": [
  88           "test_feature_0"
  89         ],
  90         "disabled_extensions": [
  91           "test_extension1",
  92           "test_extension2"
  93         ]
  94       }
  95   );
  96
  97   ScopedEntry entry(GetEntryFromString(json));
  98   EXPECT_TRUE(entry.get() != NULL);
  99   EXPECT_EQ(GpuControlList::kOsMacosx, entry->GetOsType());
 100   EXPECT_FALSE(entry->disabled());
 101   EXPECT_EQ(5u, entry->id());
 102   EXPECT_STREQ("test entry", entry->description().c_str());
 103   EXPECT_EQ(2u, entry->cr_bugs().size());
 104   EXPECT_EQ(1024, entry->cr_bugs()[0]);
 105   EXPECT_EQ(678, entry->cr_bugs()[1]);
 106   EXPECT_EQ(1u, entry->webkit_bugs().size());
 107   EXPECT_EQ(1950, entry->webkit_bugs()[0]);
 108   EXPECT_EQ(1u, entry->features().size());
 109   EXPECT_EQ(1u, entry->features().count(TEST_FEATURE_0));
 110   EXPECT_FALSE(entry->NeedsMoreInfo(gpu_info(), true));
 111   EXPECT_TRUE(entry->Contains(
 112       GpuControlList::kOsMacosx, "10.6.4", gpu_info()));
 113   EXPECT_STREQ("test_extension1", entry->disabled_extensions()[0].c_str());
 114   EXPECT_STREQ("test_extension2", entry->disabled_extensions()[1].c_str());
 115 }
 116
 117 TEST_F(GpuControlListEntryTest, VendorOnAllOsEntry) {
 118   const std::string json = LONG_STRING_CONST(
 119       {
 120         "id": 1,
 121         "vendor_id": "0x10de",
 122         "features": [
 123           "test_feature_0"
 124         ]
 125       }
 126   );
 127   ScopedEntry entry(GetEntryFromString(json));
 128   EXPECT_TRUE(entry.get() != NULL);
 129   EXPECT_EQ(GpuControlList::kOsAny, entry->GetOsType());
 130
 131   const GpuControlList::OsType os_type[] = {
 132     GpuControlList::kOsMacosx,
 133     GpuControlList::kOsWin,
 134     GpuControlList::kOsLinux,
 135     GpuControlList::kOsChromeOS,
 136     GpuControlList::kOsAndroid
 137   };
 138   for (size_t i = 0; i < arraysize(os_type); ++i)
 139     EXPECT_TRUE(entry->Contains(os_type[i], "10.6", gpu_info()));
 140 }
 141
 142 TEST_F(GpuControlListEntryTest, VendorOnLinuxEntry) {
 143   const std::string json = LONG_STRING_CONST(
 144       {
 145         "id": 1,
 146         "os": {
 147           "type": "linux"
 148         },
 149         "vendor_id": "0x10de",
 150         "features": [
 151           "test_feature_0"
 152         ]
 153       }
 154   );
 155   ScopedEntry entry(GetEntryFromString(json));
 156   EXPECT_TRUE(entry.get() != NULL);
 157   EXPECT_EQ(GpuControlList::kOsLinux, entry->GetOsType());
 158
 159   const GpuControlList::OsType os_type[] = {
 160     GpuControlList::kOsMacosx,
 161     GpuControlList::kOsWin,
 162     GpuControlList::kOsChromeOS,
 163     GpuControlList::kOsAndroid
 164   };
 165   for (size_t i = 0; i < arraysize(os_type); ++i)
 166     EXPECT_FALSE(entry->Contains(os_type[i], "10.6", gpu_info()));
 167   EXPECT_TRUE(entry->Contains(
 168       GpuControlList::kOsLinux, "10.6", gpu_info()));
 169 }
 170
 171 TEST_F(GpuControlListEntryTest, AllExceptNVidiaOnLinuxEntry) {
 172   const std::string json = LONG_STRING_CONST(
 173       {
 174         "id": 1,
 175         "os": {
 176           "type": "linux"
 177         },
 178         "exceptions": [
 179           {
 180             "vendor_id": "0x10de"
 181           }
 182         ],
 183         "features": [
 184           "test_feature_0"
 185         ]
 186       }
 187   );
 188   ScopedEntry entry(GetEntryFromString(json));
 189   EXPECT_TRUE(entry.get() != NULL);
 190   EXPECT_EQ(GpuControlList::kOsLinux, entry->GetOsType());
 191
 192   const GpuControlList::OsType os_type[] = {
 193     GpuControlList::kOsMacosx,
 194     GpuControlList::kOsWin,
 195     GpuControlList::kOsLinux,
 196     GpuControlList::kOsChromeOS,
 197     GpuControlList::kOsAndroid
 198   };
 199   for (size_t i = 0; i < arraysize(os_type); ++i)
 200     EXPECT_FALSE(entry->Contains(os_type[i], "10.6", gpu_info()));
 201 }
 202
 203 TEST_F(GpuControlListEntryTest, AllExceptIntelOnLinuxEntry) {
 204   const std::string json = LONG_STRING_CONST(
 205       {
 206         "id": 1,
 207         "os": {
 208           "type": "linux"
 209         },
 210         "exceptions": [
 211           {
 212             "vendor_id": "0x8086"
 213           }
 214         ],
 215         "features": [
 216           "test_feature_0"
 217         ]
 218       }
 219   );
 220   ScopedEntry entry(GetEntryFromString(json));
 221   EXPECT_TRUE(entry.get() != NULL);
 222   EXPECT_EQ(GpuControlList::kOsLinux, entry->GetOsType());
 223
 224   const GpuControlList::OsType os_type[] = {
 225     GpuControlList::kOsMacosx,
 226     GpuControlList::kOsWin,
 227     GpuControlList::kOsChromeOS,
 228     GpuControlList::kOsAndroid
 229   };
 230   for (size_t i = 0; i < arraysize(os_type); ++i)
 231     EXPECT_FALSE(entry->Contains(os_type[i], "10.6", gpu_info()));
 232   EXPECT_TRUE(entry->Contains(
 233       GpuControlList::kOsLinux, "10.6", gpu_info()));
 234 }
 235
 236 TEST_F(GpuControlListEntryTest, DateOnWindowsEntry) {
 237   const std::string json = LONG_STRING_CONST(
 238       {
 239         "id": 1,
 240         "os": {
 241           "type": "win"
 242         },
 243         "driver_date": {
 244           "op": "<",
 245           "value": "2010.5.8"
 246         },
 247         "features": [
 248           "test_feature_0"
 249         ]
 250       }
 251   );
 252   ScopedEntry entry(GetEntryFromString(json));
 253   EXPECT_TRUE(entry.get() != NULL);
 254   EXPECT_EQ(GpuControlList::kOsWin, entry->GetOsType());
 255
 256   GPUInfo gpu_info;
 257   gpu_info.driver_date = "4-12-2010";
 258   EXPECT_TRUE(entry->Contains(
 259       GpuControlList::kOsWin, "10.6", gpu_info));
 260   gpu_info.driver_date = "5-8-2010";
 261   EXPECT_FALSE(entry->Contains(
 262       GpuControlList::kOsWin, "10.6", gpu_info));
 263   gpu_info.driver_date = "5-9-2010";
 264   EXPECT_FALSE(entry->Contains(
 265       GpuControlList::kOsWin, "10.6", gpu_info));
 266 }
 267
 268 TEST_F(GpuControlListEntryTest, MultipleDevicesEntry) {
 269   const std::string json = LONG_STRING_CONST(
 270       {
 271         "id": 1,
 272         "vendor_id": "0x10de",
 273         "device_id": ["0x1023", "0x0640"],
 274         "features": [
 275           "test_feature_0"
 276         ]
 277       }
 278   );
 279   ScopedEntry entry(GetEntryFromString(json));
 280   EXPECT_TRUE(entry.get() != NULL);
 281   EXPECT_EQ(GpuControlList::kOsAny, entry->GetOsType());
 282
 283   const GpuControlList::OsType os_type[] = {
 284     GpuControlList::kOsMacosx,
 285     GpuControlList::kOsWin,
 286     GpuControlList::kOsLinux,
 287     GpuControlList::kOsChromeOS,
 288     GpuControlList::kOsAndroid
 289   };
 290   for (size_t i = 0; i < arraysize(os_type); ++i)
 291     EXPECT_TRUE(entry->Contains(os_type[i], "10.6", gpu_info()));
 292 }
 293
 294 TEST_F(GpuControlListEntryTest, ChromeOSEntry) {
 295   const std::string json = LONG_STRING_CONST(
 296       {
 297         "id": 1,
 298         "os": {
 299           "type": "chromeos"
 300         },
 301         "features": [
 302           "test_feature_0"
 303         ]
 304       }
 305   );
 306   ScopedEntry entry(GetEntryFromString(json));
 307   EXPECT_TRUE(entry.get() != NULL);
 308   EXPECT_EQ(GpuControlList::kOsChromeOS, entry->GetOsType());
 309
 310   const GpuControlList::OsType os_type[] = {
 311     GpuControlList::kOsMacosx,
 312     GpuControlList::kOsWin,
 313     GpuControlList::kOsLinux,
 314     GpuControlList::kOsAndroid
 315   };
 316   for (size_t i = 0; i < arraysize(os_type); ++i)
 317     EXPECT_FALSE(entry->Contains(os_type[i], "10.6", gpu_info()));
 318   EXPECT_TRUE(entry->Contains(
 319       GpuControlList::kOsChromeOS, "10.6", gpu_info()));
 320 }
 321
 322 TEST_F(GpuControlListEntryTest, MalformedVendor) {
 323   const std::string json = LONG_STRING_CONST(
 324       {
 325         "id": 1,
 326         "vendor_id": "[0x10de]",
 327         "features": [
 328           "test_feature_0"
 329         ]
 330       }
 331   );
 332   ScopedEntry entry(GetEntryFromString(json));
 333   EXPECT_TRUE(entry.get() == NULL);
 334 }
 335
 336 TEST_F(GpuControlListEntryTest, UnknownFieldEntry) {
 337   const std::string json = LONG_STRING_CONST(
 338       {
 339         "id": 1,
 340         "unknown_field": 0,
 341         "features": [
 342           "test_feature_0"
 343         ]
 344       }
 345   );
 346   ScopedEntry entry(GetEntryFromString(json));
 347   EXPECT_TRUE(entry.get() == NULL);
 348 }
 349
 350 TEST_F(GpuControlListEntryTest, UnknownExceptionFieldEntry) {
 351   const std::string json = LONG_STRING_CONST(
 352       {
 353         "id": 2,
 354         "exceptions": [
 355           {
 356             "unknown_field": 0
 357           }
 358         ],
 359         "features": [
 360           "test_feature_0"
 361         ]
 362       }
 363   );
 364   ScopedEntry entry(GetEntryFromString(json));
 365   EXPECT_TRUE(entry.get() == NULL);
 366 }
 367
 368 TEST_F(GpuControlListEntryTest, UnknownFeatureEntry) {
 369   const std::string json = LONG_STRING_CONST(
 370       {
 371         "id": 1,
 372         "features": [
 373           "some_unknown_feature",
 374           "test_feature_0"
 375         ]
 376       }
 377   );
 378   ScopedEntry entry(GetEntryFromString(json));
 379   EXPECT_TRUE(entry.get() == NULL);
 380 }
 381
 382 TEST_F(GpuControlListEntryTest, GlVersionGLESEntry) {
 383   const std::string json = LONG_STRING_CONST(
 384       {
 385         "id": 1,
 386         "gl_type": "gles",
 387         "gl_version": {
 388           "op": "=",
 389           "value": "3.0"
 390         },
 391         "features": [
 392           "test_feature_0"
 393         ]
 394       }
 395   );
 396   ScopedEntry entry(GetEntryFromString(json));
 397   EXPECT_TRUE(entry.get() != NULL);
 398
 399   GPUInfo gpu_info;
 400   gpu_info.gl_version = "OpenGL ES 3.0 V@66.0 AU@ (CL@)";
 401   EXPECT_TRUE(entry->Contains(GpuControlList::kOsAndroid, "4.4.2", gpu_info));
 402
 403   gpu_info.gl_version = "OpenGL ES 3.0V@66.0 AU@ (CL@)";
 404   EXPECT_TRUE(entry->Contains(GpuControlList::kOsAndroid, "4.4.2", gpu_info));
 405
 406   gpu_info.gl_version = "OpenGL ES 3.1 V@66.0 AU@ (CL@)";
 407   EXPECT_FALSE(entry->Contains(GpuControlList::kOsAndroid, "4.4.2", gpu_info));
 408
 409   gpu_info.gl_version = "3.0 NVIDIA-8.24.11 310.90.9b01";
 410   EXPECT_FALSE(entry->Contains(GpuControlList::kOsMacosx, "10.9", gpu_info));
 411
 412   gpu_info.gl_version = "OpenGL ES 3.0 (ANGLE 1.2.0.2450)";
 413   EXPECT_FALSE(entry->Contains(GpuControlList::kOsWin, "6.1", gpu_info));
 414 }
 415
 416 TEST_F(GpuControlListEntryTest, GlVersionANGLEEntry) {
 417   const std::string json = LONG_STRING_CONST(
 418       {
 419         "id": 1,
 420         "gl_type": "angle",
 421         "gl_version": {
 422           "op": ">",
 423           "value": "2.0"
 424         },
 425         "features": [
 426           "test_feature_0"
 427         ]
 428       }
 429   );
 430   ScopedEntry entry(GetEntryFromString(json));
 431   EXPECT_TRUE(entry.get() != NULL);
 432
 433   GPUInfo gpu_info;
 434   gpu_info.gl_version = "OpenGL ES 3.0 V@66.0 AU@ (CL@)";
 435   EXPECT_FALSE(entry->Contains(GpuControlList::kOsAndroid, "4.4.2", gpu_info));
 436
 437   gpu_info.gl_version = "3.0 NVIDIA-8.24.11 310.90.9b01";
 438   EXPECT_FALSE(entry->Contains(GpuControlList::kOsMacosx, "10.9", gpu_info));
 439
 440   gpu_info.gl_version = "OpenGL ES 3.0 (ANGLE 1.2.0.2450)";
 441   EXPECT_TRUE(entry->Contains(GpuControlList::kOsWin, "6.1", gpu_info));
 442
 443   gpu_info.gl_version = "OpenGL ES 2.0 (ANGLE 1.2.0.2450)";
 444   EXPECT_FALSE(entry->Contains(GpuControlList::kOsWin, "6.1", gpu_info));
 445 }
 446
 447 TEST_F(GpuControlListEntryTest, GlVersionGLEntry) {
 448   const std::string json = LONG_STRING_CONST(
 449       {
 450         "id": 1,
 451         "gl_type": "gl",
 452         "gl_version": {
 453           "op": "<",
 454           "value": "4.0"
 455         },
 456         "features": [
 457           "test_feature_0"
 458         ]
 459       }
 460   );
 461   ScopedEntry entry(GetEntryFromString(json));
 462   EXPECT_TRUE(entry.get() != NULL);
 463
 464   GPUInfo gpu_info;
 465   gpu_info.gl_version = "OpenGL ES 3.0 V@66.0 AU@ (CL@)";
 466   EXPECT_FALSE(entry->Contains(GpuControlList::kOsAndroid, "4.4.2", gpu_info));
 467
 468   gpu_info.gl_version = "3.0 NVIDIA-8.24.11 310.90.9b01";
 469   EXPECT_TRUE(entry->Contains(GpuControlList::kOsMacosx, "10.9", gpu_info));
 470
 471   gpu_info.gl_version = "4.0 NVIDIA-8.24.11 310.90.9b01";
 472   EXPECT_FALSE(entry->Contains(GpuControlList::kOsMacosx, "10.9", gpu_info));
 473
 474   gpu_info.gl_version = "OpenGL ES 3.0 (ANGLE 1.2.0.2450)";
 475   EXPECT_FALSE(entry->Contains(GpuControlList::kOsWin, "6.1", gpu_info));
 476 }
 477
 478 TEST_F(GpuControlListEntryTest, GlVendorEqual) {
 479   const std::string json = LONG_STRING_CONST(
 480       {
 481         "id": 1,
 482         "gl_vendor": "NVIDIA",
 483         "features": [
 484           "test_feature_0"
 485         ]
 486       }
 487   );
 488   ScopedEntry entry(GetEntryFromString(json));
 489   EXPECT_TRUE(entry.get() != NULL);
 490
 491   GPUInfo gpu_info;
 492   gpu_info.gl_vendor = "NVIDIA";
 493   EXPECT_TRUE(entry->Contains(
 494       GpuControlList::kOsMacosx, "10.9", gpu_info));
 495
 496   // Case sensitive.
 497   gpu_info.gl_vendor = "NVidia";
 498   EXPECT_FALSE(entry->Contains(
 499       GpuControlList::kOsMacosx, "10.9", gpu_info));
 500
 501   gpu_info.gl_vendor = "NVIDIA-x";
 502   EXPECT_FALSE(entry->Contains(
 503       GpuControlList::kOsMacosx, "10.9", gpu_info));
 504 }
 505
 506 TEST_F(GpuControlListEntryTest, GlVendorWithDot) {
 507   const std::string json = LONG_STRING_CONST(
 508       {
 509         "id": 1,
 510         "gl_vendor": "X\\.Org.*",
 511         "features": [
 512           "test_feature_0"
 513         ]
 514       }
 515   );
 516   ScopedEntry entry(GetEntryFromString(json));
 517   EXPECT_TRUE(entry.get() != NULL);
 518
 519   GPUInfo gpu_info;
 520   gpu_info.gl_vendor = "X.Org R300 Project";
 521   EXPECT_TRUE(entry->Contains(
 522       GpuControlList::kOsLinux, "", gpu_info));
 523
 524   gpu_info.gl_vendor = "X.Org";
 525   EXPECT_TRUE(entry->Contains(
 526       GpuControlList::kOsLinux, "", gpu_info));
 527 }
 528
 529 TEST_F(GpuControlListEntryTest, GlRendererContains) {
 530   const std::string json = LONG_STRING_CONST(
 531       {
 532         "id": 1,
 533         "gl_renderer": ".*GeForce.*",
 534         "features": [
 535           "test_feature_0"
 536         ]
 537       }
 538   );
 539   ScopedEntry entry(GetEntryFromString(json));
 540   EXPECT_TRUE(entry.get() != NULL);
 541
 542   GPUInfo gpu_info;
 543   gpu_info.gl_renderer = "NVIDIA GeForce GT 120 OpenGL Engine";
 544   EXPECT_TRUE(entry->Contains(
 545       GpuControlList::kOsMacosx, "10.9", gpu_info));
 546
 547   // Case sensitive.
 548   gpu_info.gl_renderer = "NVIDIA GEFORCE GT 120 OpenGL Engine";
 549   EXPECT_FALSE(entry->Contains(
 550       GpuControlList::kOsMacosx, "10.9", gpu_info));
 551
 552   gpu_info.gl_renderer = "GeForce GT 120 OpenGL Engine";
 553   EXPECT_TRUE(entry->Contains(
 554       GpuControlList::kOsMacosx, "10.9", gpu_info));
 555
 556   gpu_info.gl_renderer = "NVIDIA GeForce";
 557   EXPECT_TRUE(entry->Contains(
 558       GpuControlList::kOsMacosx, "10.9", gpu_info));
 559
 560   gpu_info.gl_renderer = "NVIDIA Ge Force";
 561   EXPECT_FALSE(entry->Contains(
 562       GpuControlList::kOsMacosx, "10.9", gpu_info));
 563 }
 564
 565 TEST_F(GpuControlListEntryTest, GlRendererCaseInsensitive) {
 566   const std::string json = LONG_STRING_CONST(
 567       {
 568         "id": 1,
 569         "gl_renderer": "(?i).*software.*",
 570         "features": [
 571           "test_feature_0"
 572         ]
 573       }
 574   );
 575   ScopedEntry entry(GetEntryFromString(json));
 576   EXPECT_TRUE(entry.get() != NULL);
 577
 578   GPUInfo gpu_info;
 579   gpu_info.gl_renderer = "software rasterizer";
 580   EXPECT_TRUE(entry->Contains(
 581       GpuControlList::kOsMacosx, "10.9", gpu_info));
 582
 583   gpu_info.gl_renderer = "Software Rasterizer";
 584   EXPECT_TRUE(entry->Contains(
 585       GpuControlList::kOsMacosx, "10.9", gpu_info));
 586 }
 587
 588 TEST_F(GpuControlListEntryTest, GlExtensionsEndWith) {
 589   const std::string json = LONG_STRING_CONST(
 590       {
 591         "id": 1,
 592         "gl_extensions": ".*GL_SUN_slice_accum",
 593         "features": [
 594           "test_feature_0"
 595         ]
 596       }
 597   );
 598   ScopedEntry entry(GetEntryFromString(json));
 599   EXPECT_TRUE(entry.get() != NULL);
 600
 601   GPUInfo gpu_info;
 602   gpu_info.gl_extensions = "GL_SGIS_generate_mipmap "
 603                            "GL_SGIX_shadow "
 604                            "GL_SUN_slice_accum";
 605   EXPECT_TRUE(entry->Contains(
 606       GpuControlList::kOsMacosx, "10.9", gpu_info));
 607
 608   gpu_info.gl_extensions = "GL_SGIS_generate_mipmap "
 609                            "GL_SUN_slice_accum "
 610                            "GL_SGIX_shadow";
 611   EXPECT_FALSE(entry->Contains(
 612       GpuControlList::kOsMacosx, "10.9", gpu_info));
 613 }
 614
 615 TEST_F(GpuControlListEntryTest, DisabledEntry) {
 616   const std::string json = LONG_STRING_CONST(
 617       {
 618         "id": 1,
 619         "disabled": true,
 620         "features": [
 621           "test_feature_0"
 622         ]
 623       }
 624   );
 625   ScopedEntry entry(GetEntryFromString(json));
 626   EXPECT_TRUE(entry.get() != NULL);
 627   EXPECT_TRUE(entry->disabled());
 628 }
 629
 630 TEST_F(GpuControlListEntryTest, OptimusEntry) {
 631   const std::string json = LONG_STRING_CONST(
 632       {
 633         "id": 1,
 634         "os": {
 635           "type": "linux"
 636         },
 637         "multi_gpu_style": "optimus",
 638         "features": [
 639           "test_feature_0"
 640         ]
 641       }
 642   );
 643   GPUInfo gpu_info;
 644   gpu_info.optimus = true;
 645
 646   ScopedEntry entry(GetEntryFromString(json));
 647   EXPECT_TRUE(entry.get() != NULL);
 648   EXPECT_EQ(GpuControlList::kOsLinux, entry->GetOsType());
 649   EXPECT_TRUE(entry->Contains(
 650       GpuControlList::kOsLinux, "10.6", gpu_info));
 651 }
 652
 653 TEST_F(GpuControlListEntryTest, AMDSwitchableEntry) {
 654   const std::string json = LONG_STRING_CONST(
 655       {
 656         "id": 1,
 657         "os": {
 658           "type": "macosx"
 659         },
 660         "multi_gpu_style": "amd_switchable",
 661         "features": [
 662           "test_feature_0"
 663         ]
 664       }
 665   );
 666   GPUInfo gpu_info;
 667   gpu_info.amd_switchable = true;
 668
 669   ScopedEntry entry(GetEntryFromString(json));
 670   EXPECT_TRUE(entry.get() != NULL);
 671   EXPECT_EQ(GpuControlList::kOsMacosx, entry->GetOsType());
 672   EXPECT_TRUE(entry->Contains(
 673       GpuControlList::kOsMacosx, "10.6", gpu_info));
 674 }
 675
 676 TEST_F(GpuControlListEntryTest, DriverVendorBeginWith) {
 677   const std::string json = LONG_STRING_CONST(
 678       {
 679         "id": 1,
 680         "driver_vendor": "NVIDIA.*",
 681         "features": [
 682           "test_feature_0"
 683         ]
 684       }
 685   );
 686   ScopedEntry entry(GetEntryFromString(json));
 687   EXPECT_TRUE(entry.get() != NULL);
 688
 689   GPUInfo gpu_info;
 690   gpu_info.driver_vendor = "NVIDIA Corporation";
 691   EXPECT_TRUE(entry->Contains(
 692       GpuControlList::kOsMacosx, "10.9", gpu_info));
 693
 694   // Case sensitive.
 695   gpu_info.driver_vendor = "NVidia Corporation";
 696   EXPECT_FALSE(entry->Contains(
 697       GpuControlList::kOsMacosx, "10.9", gpu_info));
 698
 699   gpu_info.driver_vendor = "NVIDIA";
 700   EXPECT_TRUE(entry->Contains(
 701       GpuControlList::kOsMacosx, "10.9", gpu_info));
 702
 703   gpu_info.driver_vendor = "USA NVIDIA";
 704   EXPECT_FALSE(entry->Contains(
 705       GpuControlList::kOsMacosx, "10.9", gpu_info));
 706 }
 707
 708 TEST_F(GpuControlListEntryTest, LexicalDriverVersionEntry) {
 709   const std::string json = LONG_STRING_CONST(
 710       {
 711         "id": 1,
 712         "os": {
 713           "type": "linux"
 714         },
 715         "vendor_id": "0x1002",
 716         "driver_version": {
 717           "op": "=",
 718           "style": "lexical",
 719           "value": "8.76"
 720         },
 721         "features": [
 722           "test_feature_0"
 723         ]
 724       }
 725   );
 726   GPUInfo gpu_info;
 727   gpu_info.gpu.vendor_id = 0x1002;
 728
 729   ScopedEntry entry(GetEntryFromString(json));
 730   EXPECT_TRUE(entry.get() != NULL);
 731   EXPECT_EQ(GpuControlList::kOsLinux, entry->GetOsType());
 732
 733   gpu_info.driver_version = "8.76";
 734   EXPECT_TRUE(entry->Contains(
 735       GpuControlList::kOsLinux, "10.6", gpu_info));
 736
 737   gpu_info.driver_version = "8.768";
 738   EXPECT_TRUE(entry->Contains(
 739       GpuControlList::kOsLinux, "10.6", gpu_info));
 740
 741   gpu_info.driver_version = "8.76.8";
 742   EXPECT_TRUE(entry->Contains(
 743       GpuControlList::kOsLinux, "10.6", gpu_info));
 744 }
 745
 746 TEST_F(GpuControlListEntryTest, NeedsMoreInfoEntry) {
 747   const std::string json = LONG_STRING_CONST(
 748       {
 749         "id": 1,
 750         "vendor_id": "0x8086",
 751         "driver_version": {
 752           "op": "<",
 753           "value": "10.7"
 754         },
 755         "features": [
 756           "test_feature_1"
 757         ]
 758       }
 759   );
 760   ScopedEntry entry(GetEntryFromString(json));
 761   EXPECT_TRUE(entry.get() != NULL);
 762
 763   GPUInfo gpu_info;
 764   gpu_info.gpu.vendor_id = 0x8086;
 765   EXPECT_TRUE(entry->NeedsMoreInfo(gpu_info, true));
 766
 767   gpu_info.driver_version = "10.6";
 768   EXPECT_FALSE(entry->NeedsMoreInfo(gpu_info, true));
 769 }
 770
 771 TEST_F(GpuControlListEntryTest, NeedsMoreInfoForExceptionsEntry) {
 772   const std::string json = LONG_STRING_CONST(
 773       {
 774         "id": 1,
 775         "vendor_id": "0x8086",
 776         "exceptions": [
 777           {
 778             "gl_renderer": ".*mesa.*"
 779           }
 780         ],
 781         "features": [
 782           "test_feature_1"
 783         ]
 784       }
 785   );
 786   ScopedEntry entry(GetEntryFromString(json));
 787   EXPECT_TRUE(entry.get() != NULL);
 788
 789   GPUInfo gpu_info;
 790   gpu_info.gpu.vendor_id = 0x8086;
 791   EXPECT_TRUE(entry->NeedsMoreInfo(gpu_info, true));
 792   EXPECT_FALSE(entry->NeedsMoreInfo(gpu_info, false));
 793
 794   gpu_info.gl_renderer = "mesa";
 795   EXPECT_FALSE(entry->NeedsMoreInfo(gpu_info, true));
 796 }
 797
 798 TEST_F(GpuControlListEntryTest, FeatureTypeAllEntry) {
 799   const std::string json = LONG_STRING_CONST(
 800       {
 801         "id": 1,
 802         "features": [
 803           "all"
 804         ]
 805       }
 806   );
 807   ScopedEntry entry(GetEntryFromString(json, true));
 808   EXPECT_TRUE(entry.get() != NULL);
 809   EXPECT_EQ(3u, entry->features().size());
 810   EXPECT_EQ(1u, entry->features().count(TEST_FEATURE_0));
 811   EXPECT_EQ(1u, entry->features().count(TEST_FEATURE_1));
 812   EXPECT_EQ(1u, entry->features().count(TEST_FEATURE_2));
 813 }
 814
 815 TEST_F(GpuControlListEntryTest, InvalidVendorIdEntry) {
 816   const std::string json = LONG_STRING_CONST(
 817       {
 818         "id": 1,
 819         "vendor_id": "0x0000",
 820         "features": [
 821           "test_feature_1"
 822         ]
 823       }
 824   );
 825   ScopedEntry entry(GetEntryFromString(json));
 826   EXPECT_TRUE(entry.get() == NULL);
 827 }
 828
 829 TEST_F(GpuControlListEntryTest, InvalidDeviceIdEntry) {
 830   const std::string json = LONG_STRING_CONST(
 831       {
 832         "id": 1,
 833         "vendor_id": "0x10de",
 834         "device_id": ["0x1023", "0x0000"],
 835         "features": [
 836           "test_feature_1"
 837         ]
 838       }
 839   );
 840   ScopedEntry entry(GetEntryFromString(json));
 841   EXPECT_TRUE(entry.get() == NULL);
 842 }
 843
 844 TEST_F(GpuControlListEntryTest, SingleActiveGPU) {
 845   const std::string json = LONG_STRING_CONST(
 846       {
 847         "id": 1,
 848         "os": {
 849           "type": "macosx"
 850         },
 851         "vendor_id": "0x10de",
 852         "device_id": ["0x0640"],
 853         "multi_gpu_category": "active",
 854         "features": [
 855           "test_feature_0"
 856         ]
 857       }
 858   );
 859   ScopedEntry entry(GetEntryFromString(json));
 860   EXPECT_TRUE(entry.get() != NULL);
 861   EXPECT_EQ(GpuControlList::kOsMacosx, entry->GetOsType());
 862   EXPECT_TRUE(entry->Contains(
 863       GpuControlList::kOsMacosx, "10.6", gpu_info()));
 864 }
 865
 866 TEST_F(GpuControlListEntryTest, MachineModelName) {
 867   const std::string json = LONG_STRING_CONST(
 868       {
 869         "id": 1,
 870         "os": {
 871           "type": "android"
 872         },
 873         "machine_model_name": [
 874           "Nexus 4", "XT1032", "GT-.*", "SCH-.*"
 875         ],
 876         "features": [
 877           "test_feature_0"
 878         ]
 879       }
 880   );
 881   ScopedEntry entry(GetEntryFromString(json));
 882   EXPECT_TRUE(entry.get() != NULL);
 883   EXPECT_EQ(GpuControlList::kOsAndroid, entry->GetOsType());
 884   GPUInfo gpu_info;
 885
 886   gpu_info.machine_model_name = "Nexus 4";
 887   EXPECT_TRUE(entry->Contains(
 888       GpuControlList::kOsAndroid, "4.1", gpu_info));
 889
 890   gpu_info.machine_model_name = "XT1032";
 891   EXPECT_TRUE(entry->Contains(
 892       GpuControlList::kOsAndroid, "4.1", gpu_info));
 893
 894   gpu_info.machine_model_name = "XT1032i";
 895   EXPECT_FALSE(entry->Contains(
 896       GpuControlList::kOsAndroid, "4.1", gpu_info));
 897
 898   gpu_info.machine_model_name = "Nexus 5";
 899   EXPECT_FALSE(entry->Contains(
 900       GpuControlList::kOsAndroid, "4.1", gpu_info));
 901
 902   gpu_info.machine_model_name = "Nexus";
 903   EXPECT_FALSE(entry->Contains(
 904       GpuControlList::kOsAndroid, "4.1", gpu_info));
 905
 906   gpu_info.machine_model_name = "";
 907   EXPECT_FALSE(entry->Contains(
 908       GpuControlList::kOsAndroid, "4.1", gpu_info));
 909
 910   gpu_info.machine_model_name = "GT-N7100";
 911   EXPECT_TRUE(entry->Contains(
 912       GpuControlList::kOsAndroid, "4.1", gpu_info));
 913
 914   gpu_info.machine_model_name = "GT-I9300";
 915   EXPECT_TRUE(entry->Contains(
 916       GpuControlList::kOsAndroid, "4.1", gpu_info));
 917
 918   gpu_info.machine_model_name = "SCH-I545";
 919   EXPECT_TRUE(entry->Contains(
 920       GpuControlList::kOsAndroid, "4.1", gpu_info));
 921 }
 922
 923 TEST_F(GpuControlListEntryTest, MachineModelNameException) {
 924   const std::string json = LONG_STRING_CONST(
 925       {
 926         "id": 1,
 927         "exceptions": [
 928           {
 929             "os": {
 930               "type": "android"
 931             },
 932             "machine_model_name": ["Nexus.*"]
 933           }
 934         ],
 935         "features": [
 936           "test_feature_0"
 937         ]
 938       }
 939   );
 940   ScopedEntry entry(GetEntryFromString(json));
 941   EXPECT_TRUE(entry.get() != NULL);
 942   EXPECT_EQ(GpuControlList::kOsAny, entry->GetOsType());
 943   GPUInfo gpu_info;
 944
 945   gpu_info.machine_model_name = "Nexus 4";
 946   EXPECT_FALSE(entry->Contains(
 947       GpuControlList::kOsAndroid, "4.1", gpu_info));
 948   EXPECT_TRUE(entry->Contains(
 949       GpuControlList::kOsLinux, "4.1", gpu_info));
 950
 951   gpu_info.machine_model_name = "Nexus 7";
 952   EXPECT_FALSE(entry->Contains(
 953       GpuControlList::kOsAndroid, "4.1", gpu_info));
 954   EXPECT_TRUE(entry->Contains(
 955       GpuControlList::kOsLinux, "4.1", gpu_info));
 956
 957   gpu_info.machine_model_name = "";
 958   EXPECT_TRUE(entry->Contains(
 959       GpuControlList::kOsAndroid, "4.1", gpu_info));
 960   EXPECT_TRUE(entry->Contains(
 961       GpuControlList::kOsLinux, "4.1", gpu_info));
 962 }
 963
 964 TEST_F(GpuControlListEntryTest, MachineModelVersion) {
 965   const std::string json = LONG_STRING_CONST(
 966       {
 967         "id": 1,
 968         "os": {
 969           "type": "macosx"
 970         },
 971         "machine_model_name": ["MacBookPro"],
 972         "machine_model_version": {
 973           "op": "=",
 974           "value": "7.1"
 975         },
 976         "features": [
 977           "test_feature_0"
 978         ]
 979       }
 980   );
 981   ScopedEntry entry(GetEntryFromString(json));
 982   EXPECT_TRUE(entry.get() != NULL);
 983   GPUInfo gpu_info;
 984   gpu_info.machine_model_name = "MacBookPro";
 985   gpu_info.machine_model_version = "7.1";
 986   EXPECT_EQ(GpuControlList::kOsMacosx, entry->GetOsType());
 987   EXPECT_TRUE(entry->Contains(
 988       GpuControlList::kOsMacosx, "10.6", gpu_info));
 989 }
 990
 991 TEST_F(GpuControlListEntryTest, MachineModelVersionException) {
 992   const std::string json = LONG_STRING_CONST(
 993       {
 994         "id": 1,
 995         "os": {
 996           "type": "macosx"
 997         },
 998         "machine_model_name": ["MacBookPro"],
 999         "exceptions": [
1000           {
1001             "machine_model_version": {
1002               "op": ">",
1003               "value": "7.1"
1004             }
1005           }
1006         ],
1007         "features": [
1008           "test_feature_0"
1009         ]
1010       }
1011   );
1012   ScopedEntry entry(GetEntryFromString(json));
1013   EXPECT_TRUE(entry.get() != NULL);
1014   EXPECT_EQ(GpuControlList::kOsMacosx, entry->GetOsType());
1015
1016   GPUInfo gpu_info;
1017   gpu_info.machine_model_name = "MacBookPro";
1018   gpu_info.machine_model_version = "7.0";
1019   EXPECT_TRUE(entry->Contains(
1020       GpuControlList::kOsMacosx, "10.6", gpu_info));
1021
1022   gpu_info.machine_model_version = "7.2";
1023   EXPECT_FALSE(entry->Contains(
1024       GpuControlList::kOsMacosx, "10.6", gpu_info));
1025
1026   gpu_info.machine_model_version = "";
1027   EXPECT_TRUE(entry->Contains(
1028       GpuControlList::kOsMacosx, "10.6", gpu_info));
1029 }
1030
1031 class GpuControlListEntryDualGPUTest : public GpuControlListEntryTest {
1032  public:
1033   GpuControlListEntryDualGPUTest() { }
1034   ~GpuControlListEntryDualGPUTest() override {}
1035
1036   void SetUp() override {
1037     // Set up a NVIDIA/Intel dual, with NVIDIA as primary and Intel as
1038     // secondary, and initially Intel is active.
1039     gpu_info_.gpu.vendor_id = 0x10de;
1040     gpu_info_.gpu.device_id = 0x0640;
1041     gpu_info_.gpu.active = false;
1042     GPUInfo::GPUDevice second_gpu;
1043     second_gpu.vendor_id = 0x8086;
1044     second_gpu.device_id = 0x0166;
1045     second_gpu.active = true;
1046     gpu_info_.secondary_gpus.push_back(second_gpu);
1047   }
1048
1049   void ActivatePrimaryGPU() {
1050     gpu_info_.gpu.active = true;
1051     gpu_info_.secondary_gpus[0].active = false;
1052   }
1053
1054   void EntryShouldApply(const std::string& entry_json) const {
1055     EXPECT_TRUE(EntryApplies(entry_json));
1056   }
1057
1058   void EntryShouldNotApply(const std::string& entry_json) const {
1059     EXPECT_FALSE(EntryApplies(entry_json));
1060   }
1061
1062  private:
1063   bool EntryApplies(const std::string& entry_json) const {
1064     ScopedEntry entry(GetEntryFromString(entry_json));
1065     EXPECT_TRUE(entry.get());
1066     EXPECT_EQ(GpuControlList::kOsMacosx, entry->GetOsType());
1067     return entry->Contains(GpuControlList::kOsMacosx, "10.6", gpu_info());
1068   }
1069 };
1070
1071 TEST_F(GpuControlListEntryDualGPUTest, CategoryAny) {
1072   const std::string json_intel = LONG_STRING_CONST(
1073       {
1074         "id": 1,
1075         "os": {
1076           "type": "macosx"
1077         },
1078         "vendor_id": "0x8086",
1079         "device_id": ["0x0166"],
1080         "multi_gpu_category": "any",
1081         "features": [
1082           "test_feature_0"
1083         ]
1084       }
1085   );
1086   EntryShouldApply(json_intel);
1087
1088   const std::string json_nvidia = LONG_STRING_CONST(
1089       {
1090         "id": 1,
1091         "os": {
1092           "type": "macosx"
1093         },
1094         "vendor_id": "0x10de",
1095         "device_id": ["0x0640"],
1096         "multi_gpu_category": "any",
1097         "features": [
1098           "test_feature_0"
1099         ]
1100       }
1101   );
1102   EntryShouldApply(json_nvidia);
1103 }
1104
1105 TEST_F(GpuControlListEntryDualGPUTest, CategoryPrimarySecondary) {
1106   const std::string json_secondary = LONG_STRING_CONST(
1107       {
1108         "id": 1,
1109         "os": {
1110           "type": "macosx"
1111         },
1112         "vendor_id": "0x8086",
1113         "device_id": ["0x0166"],
1114         "multi_gpu_category": "secondary",
1115         "features": [
1116           "test_feature_0"
1117         ]
1118       }
1119   );
1120   EntryShouldApply(json_secondary);
1121
1122   const std::string json_primary = LONG_STRING_CONST(
1123       {
1124         "id": 1,
1125         "os": {
1126           "type": "macosx"
1127         },
1128         "vendor_id": "0x8086",
1129         "device_id": ["0x0166"],
1130         "multi_gpu_category": "primary",
1131         "features": [
1132           "test_feature_0"
1133         ]
1134       }
1135   );
1136   EntryShouldNotApply(json_primary);
1137
1138   const std::string json_default = LONG_STRING_CONST(
1139       {
1140         "id": 1,
1141         "os": {
1142           "type": "macosx"
1143         },
1144         "vendor_id": "0x8086",
1145         "device_id": ["0x0166"],
1146         "features": [
1147           "test_feature_0"
1148         ]
1149       }
1150   );
1151   // Default is primary.
1152   EntryShouldNotApply(json_default);
1153 }
1154
1155 TEST_F(GpuControlListEntryDualGPUTest, ActiveSecondaryGPU) {
1156   const std::string json = LONG_STRING_CONST(
1157       {
1158         "id": 1,
1159         "os": {
1160           "type": "macosx"
1161         },
1162         "vendor_id": "0x8086",
1163         "device_id": ["0x0166", "0x0168"],
1164         "multi_gpu_category": "active",
1165         "features": [
1166           "test_feature_0"
1167         ]
1168       }
1169   );
1170   // By default, secondary GPU is active.
1171   EntryShouldApply(json);
1172
1173   ActivatePrimaryGPU();
1174   EntryShouldNotApply(json);
1175 }
1176
1177 TEST_F(GpuControlListEntryDualGPUTest, VendorOnlyActiveSecondaryGPU) {
1178   const std::string json = LONG_STRING_CONST(
1179       {
1180         "id": 1,
1181         "os": {
1182           "type": "macosx"
1183         },
1184         "vendor_id": "0x8086",
1185         "multi_gpu_category": "active",
1186         "features": [
1187           "test_feature_0"
1188         ]
1189       }
1190   );
1191   // By default, secondary GPU is active.
1192   EntryShouldApply(json);
1193
1194   ActivatePrimaryGPU();
1195   EntryShouldNotApply(json);
1196 }
1197
1198 TEST_F(GpuControlListEntryDualGPUTest, ActivePrimaryGPU) {
1199   const std::string json = LONG_STRING_CONST(
1200       {
1201         "id": 1,
1202         "os": {
1203           "type": "macosx"
1204         },
1205         "vendor_id": "0x10de",
1206         "device_id": ["0x0640"],
1207         "multi_gpu_category": "active",
1208         "features": [
1209           "test_feature_0"
1210         ]
1211       }
1212   );
1213   // By default, secondary GPU is active.
1214   EntryShouldNotApply(json);
1215
1216   ActivatePrimaryGPU();
1217   EntryShouldApply(json);
1218 }
1219
1220 TEST_F(GpuControlListEntryDualGPUTest, VendorOnlyActivePrimaryGPU) {
1221   const std::string json = LONG_STRING_CONST(
1222       {
1223         "id": 1,
1224         "os": {
1225           "type": "macosx"
1226         },
1227         "vendor_id": "0x10de",
1228         "multi_gpu_category": "active",
1229         "features": [
1230           "test_feature_0"
1231         ]
1232       }
1233   );
1234   // By default, secondary GPU is active.
1235   EntryShouldNotApply(json);
1236
1237   ActivatePrimaryGPU();
1238   EntryShouldApply(json);
1239 }
1240
1241 }  // namespace gpu
1242