« back to all changes in this revision
Viewing changes to tests/gpu-manager.py
- browse files at revision 55
- compare with another revision
- download diff
- download tarball
- view history from revision 55
- Committer: Package Import Robot
- Author(s): Alberto Milone
- Date: 2014-03-19 14:49:04 UTC
- Revision ID: package-import@ubuntu.com-20140319144904-j2teldl6ajqksyw4
Tags: 1:0.2.91
* debian/control:
- Add build dependency on libdrm-dev.
* debian/rules:
- Remove /etc/init/hybrid-gfx.conf.
- Also remove the current upstart job from the architectures
that don't ship gpu-manager.
* gpu-manager.c, tests/gpu-manager.py:
- Replace laptop specific hack to detect the need to offload
rendering to the discrete card with code that opens the
available drm devices and checks the connected outputs.
If any outputs are connected to the Intel card, then we
choose offloading. This also helps when the monitor is
still connected to Intel on desktop systems with Intel +
NVIDIA systems.
- Preliminary work to reduce code duplication in nvidia-prime.
* tests/ubuntu_drivers.py:
- Do not abort if test_auto_install_system fails.
- Add build dependency on libdrm-dev.
* debian/rules:
- Remove /etc/init/hybrid-gfx.conf.
- Also remove the current upstart job from the architectures
that don't ship gpu-manager.
* gpu-manager.c, tests/gpu-manager.py:
- Replace laptop specific hack to detect the need to offload
rendering to the discrete card with code that opens the
available drm devices and checks the connected outputs.
If any outputs are connected to the Intel card, then we
choose offloading. This also helps when the monitor is
still connected to Intel on desktop systems with Intel +
NVIDIA systems.
- Preliminary work to reduce code duplication in nvidia-prime.
* tests/ubuntu_drivers.py:
- Do not abort if test_auto_install_system fails.
added
removed
tests/gpu-manager.py
28
28
29
29
def __init__(self,
30
30
has_single_card=False,
31
is_laptop=False,
31
requires_offloading=False,
32
32
has_intel=False,
33
33
intel_loaded=False,
34
34
intel_unloaded=False,
57
57
matched_quirk=False,
58
58
loaded_with_args=False):
59
59
self.has_single_card = has_single_card
60
self.is_laptop = is_laptop
60
self.requires_offloading = requires_offloading
61
61
self.has_intel = has_intel
62
62
self.intel_loaded = intel_loaded
63
63
self.intel_unloaded = intel_unloaded
128
128
klass.is_driver_enabled_pt = re.compile('Is (.+) enabled\? (.+)')
129
129
klass.has_card_pt = re.compile('Has (.+)\? (.+)')
130
130
klass.single_card_pt = re.compile('Single card detected.*')
131
klass.is_laptop_pt = re.compile('Is laptop\? (.+)')
131
klass.requires_offloading_pt = re.compile('Does it require offloading\? (.+)')
132
132
klass.no_change_stop_pt = re.compile('No change - nothing to do')
133
133
klass.has_changed_pt = re.compile('Has the system changed\? (.+)')
134
134
242
242
except:
243
243
pass
244
244
245
def exec_manager(self, is_laptop=False, uses_lightdm=True):
246
fake_laptop_arg = is_laptop and '--fake-laptop' or '--fake-desktop'
245
def exec_manager(self, requires_offloading=False, uses_lightdm=True):
246
fake_requires_offloading = requires_offloading and '--fake-requires-offloading' or '--fake-no-requires-offloading'
247
247
if with_valgrind:
248
248
valgrind = ['valgrind', '--tool=memcheck', '--leak-check=full',
249
249
'--show-reachable=yes', '--log-file=%s' % self.valgrind_log.name,
279
279
self.dmi_product_version_path.name,
280
280
'--new-boot-file',
281
281
self.new_boot_file.name,
282
fake_laptop_arg,
282
fake_requires_offloading,
283
283
'--log',
284
284
self.log.name]
285
285
338
338
loaded_with_args = self.loaded_with_args_pt.match(line)
339
339
340
340
single_card = self.single_card_pt.match(line)
341
laptop = self.is_laptop_pt.match(line)
341
offloading = self.requires_offloading_pt.match(line)
342
342
343
343
no_change_stop = self.no_change_stop_pt.match(line)
344
344
has_changed = self.has_changed_pt.match(line)
398
398
gpu_test.pxpress_enabled = (is_driver_enabled.group(2).strip().lower() == 'yes')
399
399
elif single_card:
400
400
gpu_test.has_single_card = True
401
elif laptop:
402
gpu_test.is_laptop = (laptop.group(1).strip().lower() == 'yes')
401
elif offloading:
402
gpu_test.requires_offloading = (offloading.group(1).strip().lower() == 'yes')
403
403
elif no_change_stop:
404
404
#gpu_test.has_changed = False
405
405
gpu_test.has_not_acted = True
655
655
loaded_modules, available_drivers,
656
656
enabled_driver,
657
657
unloaded_module='',
658
is_laptop=False,
658
requires_offloading=False,
659
659
proprietary_installer=False,
660
660
matched_quirk=False,
661
661
loaded_with_quirk=False,
673
673
bump_discrete_device_id)
674
674
675
675
# Call the program
676
self.exec_manager(is_laptop=is_laptop)
676
self.exec_manager(requires_offloading=requires_offloading)
677
677
678
678
# Return data
679
679
return self.check_vars()
693
693
# Check the variables
694
694
695
695
# Check if laptop
696
self.assertFalse(gpu_test.is_laptop)
696
self.assertFalse(gpu_test.requires_offloading)
697
697
698
698
self.assertTrue(gpu_test.has_single_card)
699
699
self.assertTrue(gpu_test.has_intel)
727
727
['nvidia'],
728
728
['mesa', 'nvidia'],
729
729
'nvidia',
730
is_laptop=True)
730
requires_offloading=True)
731
731
732
732
# Check the variables
733
733
self.assertTrue(gpu_test.has_single_card)
734
734
735
735
# Check if laptop
736
self.assertTrue(gpu_test.is_laptop)
736
self.assertTrue(gpu_test.requires_offloading)
737
737
738
738
# No Intel
739
739
self.assertFalse(gpu_test.has_intel)
917
917
# Check the variables
918
918
919
919
# Check if laptop
920
self.assertFalse(gpu_test.is_laptop)
920
self.assertFalse(gpu_test.requires_offloading)
921
921
922
922
self.assertTrue(gpu_test.has_single_card)
923
923
self.assertFalse(gpu_test.has_intel)
957
957
# Check the variables
958
958
959
959
# Check if laptop
960
self.assertFalse(gpu_test.is_laptop)
960
self.assertFalse(gpu_test.requires_offloading)
961
961
962
962
self.assertTrue(gpu_test.has_single_card)
963
963
self.assertFalse(gpu_test.has_intel)
1002
1002
# Check the variables
1003
1003
1004
1004
# Check if laptop
1005
self.assertFalse(gpu_test.is_laptop)
1005
self.assertFalse(gpu_test.requires_offloading)
1006
1006
1007
1007
self.assertTrue(gpu_test.has_single_card)
1008
1008
1047
1047
# Check the variables
1048
1048
1049
1049
# Check if laptop
1050
self.assertFalse(gpu_test.is_laptop)
1050
self.assertFalse(gpu_test.requires_offloading)
1051
1051
1052
1052
self.assertTrue(gpu_test.has_single_card)
1053
1053
self.assertFalse(gpu_test.has_intel)
1087
1087
# Check the variables
1088
1088
1089
1089
# Check if laptop
1090
self.assertFalse(gpu_test.is_laptop)
1090
self.assertFalse(gpu_test.requires_offloading)
1091
1091
1092
1092
self.assertTrue(gpu_test.has_single_card)
1093
1093
1129
1129
# Check the variables
1130
1130
1131
1131
# Check if laptop
1132
self.assertFalse(gpu_test.is_laptop)
1132
self.assertFalse(gpu_test.requires_offloading)
1133
1133
1134
1134
self.assertTrue(gpu_test.has_single_card)
1135
1135
self.assertFalse(gpu_test.has_intel)
1171
1171
# Check the variables
1172
1172
1173
1173
# Check if laptop
1174
self.assertFalse(gpu_test.is_laptop)
1174
self.assertFalse(gpu_test.requires_offloading)
1175
1175
1176
1176
self.assertTrue(gpu_test.has_single_card)
1177
1177
self.assertFalse(gpu_test.has_intel)
1216
1216
# Check the variables
1217
1217
1218
1218
# Check if laptop
1219
self.assertFalse(gpu_test.is_laptop)
1219
self.assertFalse(gpu_test.requires_offloading)
1220
1220
1221
1221
self.assertTrue(gpu_test.has_single_card)
1222
1222
self.assertFalse(gpu_test.has_intel)
1258
1258
# Check the variables
1259
1259
1260
1260
# Check if laptop
1261
self.assertFalse(gpu_test.is_laptop)
1261
self.assertFalse(gpu_test.requires_offloading)
1262
1262
1263
1263
self.assertTrue(gpu_test.has_single_card)
1264
1264
1300
1300
# Check the variables
1301
1301
1302
1302
# Check if laptop
1303
self.assertFalse(gpu_test.is_laptop)
1303
self.assertFalse(gpu_test.requires_offloading)
1304
1304
1305
1305
self.assertTrue(gpu_test.has_single_card)
1306
1306
1343
1343
# Check the variables
1344
1344
1345
1345
# Check if laptop
1346
self.assertFalse(gpu_test.is_laptop)
1346
self.assertFalse(gpu_test.requires_offloading)
1347
1347
1348
1348
self.assertTrue(gpu_test.has_single_card)
1349
1349
1385
1385
# Check the variables
1386
1386
1387
1387
# Check if laptop
1388
self.assertFalse(gpu_test.is_laptop)
1388
self.assertFalse(gpu_test.requires_offloading)
1389
1389
1390
1390
self.assertTrue(gpu_test.has_single_card)
1391
1391
1430
1430
# Check the variables
1431
1431
1432
1432
# Check if laptop
1433
self.assertFalse(gpu_test.is_laptop)
1433
self.assertFalse(gpu_test.requires_offloading)
1434
1434
1435
1435
self.assertTrue(gpu_test.has_single_card)
1436
1436
1479
1479
# Check the variables
1480
1480
1481
1481
# Check if laptop
1482
self.assertFalse(gpu_test.is_laptop)
1482
self.assertFalse(gpu_test.requires_offloading)
1483
1483
1484
1484
self.assertTrue(gpu_test.has_single_card)
1485
1485
1523
1523
# Check the variables
1524
1524
1525
1525
# Check if laptop
1526
self.assertFalse(gpu_test.is_laptop)
1526
self.assertFalse(gpu_test.requires_offloading)
1527
1527
1528
1528
self.assertTrue(gpu_test.has_single_card)
1529
1529
1573
1573
# Check the variables
1574
1574
1575
1575
# Check if laptop
1576
self.assertFalse(gpu_test.is_laptop)
1576
self.assertFalse(gpu_test.requires_offloading)
1577
1577
1578
1578
self.assertTrue(gpu_test.has_single_card)
1579
1579
1618
1618
# Check the variables
1619
1619
1620
1620
# Check if laptop
1621
self.assertFalse(gpu_test.is_laptop)
1621
self.assertFalse(gpu_test.requires_offloading)
1622
1622
1623
1623
self.assertTrue(gpu_test.has_single_card)
1624
1624
1668
1668
# Check the variables
1669
1669
1670
1670
# Check if laptop
1671
self.assertFalse(gpu_test.is_laptop)
1671
self.assertFalse(gpu_test.requires_offloading)
1672
1672
1673
1673
self.assertTrue(gpu_test.has_single_card)
1674
1674
1712
1712
# Check the variables
1713
1713
1714
1714
# Check if laptop
1715
self.assertFalse(gpu_test.is_laptop)
1715
self.assertFalse(gpu_test.requires_offloading)
1716
1716
1717
1717
self.assertTrue(gpu_test.has_single_card)
1718
1718
1754
1754
# Check the variables
1755
1755
1756
1756
# Check if laptop
1757
self.assertFalse(gpu_test.is_laptop)
1757
self.assertFalse(gpu_test.requires_offloading)
1758
1758
1759
1759
self.assertTrue(gpu_test.has_single_card)
1760
1760
1796
1796
# Check the variables
1797
1797
1798
1798
# Check if laptop
1799
self.assertFalse(gpu_test.is_laptop)
1799
self.assertFalse(gpu_test.requires_offloading)
1800
1800
1801
1801
self.assertTrue(gpu_test.has_single_card)
1802
1802
1840
1840
# Check the variables
1841
1841
1842
1842
# Check if laptop
1843
self.assertFalse(gpu_test.is_laptop)
1843
self.assertFalse(gpu_test.requires_offloading)
1844
1844
1845
1845
self.assertTrue(gpu_test.has_single_card)
1846
1846
1883
1883
# Check the variables
1884
1884
1885
1885
# Check if laptop
1886
self.assertFalse(gpu_test.is_laptop)
1886
self.assertFalse(gpu_test.requires_offloading)
1887
1887
1888
1888
self.assertTrue(gpu_test.has_single_card)
1889
1889
1935
1935
# Check the variables
1936
1936
1937
1937
# Check if laptop
1938
self.assertFalse(gpu_test.is_laptop)
1938
self.assertFalse(gpu_test.requires_offloading)
1939
1939
1940
1940
self.assertTrue(gpu_test.has_single_card)
1941
1941
1978
1978
# Check the variables
1979
1979
1980
1980
# Check if laptop
1981
self.assertFalse(gpu_test.is_laptop)
1981
self.assertFalse(gpu_test.requires_offloading)
1982
1982
1983
1983
self.assertTrue(gpu_test.has_single_card)
1984
1984
2022
2022
# Check the variables
2023
2023
2024
2024
# Check if laptop
2025
self.assertFalse(gpu_test.is_laptop)
2025
self.assertFalse(gpu_test.requires_offloading)
2026
2026
2027
2027
self.assertTrue(gpu_test.has_single_card)
2028
2028
2064
2064
# Check the variables
2065
2065
2066
2066
# Check if laptop
2067
self.assertFalse(gpu_test.is_laptop)
2067
self.assertFalse(gpu_test.requires_offloading)
2068
2068
2069
2069
self.assertTrue(gpu_test.has_single_card)
2070
2070
2108
2108
# Check the variables
2109
2109
2110
2110
# Check if laptop
2111
self.assertFalse(gpu_test.is_laptop)
2111
self.assertFalse(gpu_test.requires_offloading)
2112
2112
2113
2113
self.assertTrue(gpu_test.has_single_card)
2114
2114
2151
2151
# Check the variables
2152
2152
2153
2153
# Check if laptop
2154
self.assertFalse(gpu_test.is_laptop)
2154
self.assertFalse(gpu_test.requires_offloading)
2155
2155
2156
2156
self.assertTrue(gpu_test.has_single_card)
2157
2157
2196
2196
# Check the variables
2197
2197
2198
2198
# Check if laptop
2199
self.assertFalse(gpu_test.is_laptop)
2199
self.assertFalse(gpu_test.requires_offloading)
2200
2200
2201
2201
self.assertTrue(gpu_test.has_single_card)
2202
2202
2238
2238
# Check the variables
2239
2239
2240
2240
# Check if laptop
2241
self.assertFalse(gpu_test.is_laptop)
2241
self.assertFalse(gpu_test.requires_offloading)
2242
2242
2243
2243
self.assertTrue(gpu_test.has_single_card)
2244
2244
2281
2281
# Check the variables
2282
2282
2283
2283
# Check if laptop
2284
self.assertFalse(gpu_test.is_laptop)
2284
self.assertFalse(gpu_test.requires_offloading)
2285
2285
2286
2286
self.assertTrue(gpu_test.has_single_card)
2287
2287
2325
2325
# Check the variables
2326
2326
2327
2327
# Check if laptop
2328
self.assertFalse(gpu_test.is_laptop)
2328
self.assertFalse(gpu_test.requires_offloading)
2329
2329
2330
2330
self.assertTrue(gpu_test.has_single_card)
2331
2331
2370
2370
# Check the variables
2371
2371
2372
2372
# Check if laptop
2373
self.assertFalse(gpu_test.is_laptop)
2373
self.assertFalse(gpu_test.requires_offloading)
2374
2374
2375
2375
self.assertTrue(gpu_test.has_single_card)
2376
2376
self.assertTrue(gpu_test.has_intel)
2411
2411
# Check the variables
2412
2412
2413
2413
# Check if laptop
2414
self.assertFalse(gpu_test.is_laptop)
2414
self.assertFalse(gpu_test.requires_offloading)
2415
2415
2416
2416
self.assertTrue(gpu_test.has_single_card)
2417
2417
self.assertTrue(gpu_test.has_intel)
2451
2451
# Check the variables
2452
2452
2453
2453
# Check if laptop
2454
self.assertFalse(gpu_test.is_laptop)
2454
self.assertFalse(gpu_test.requires_offloading)
2455
2455
2456
2456
self.assertTrue(gpu_test.has_single_card)
2457
2457
self.assertTrue(gpu_test.has_intel)
2491
2491
# Check the variables
2492
2492
2493
2493
# Check if laptop
2494
self.assertFalse(gpu_test.is_laptop)
2494
self.assertFalse(gpu_test.requires_offloading)
2495
2495
2496
2496
self.assertTrue(gpu_test.has_single_card)
2497
2497
self.assertTrue(gpu_test.has_intel)
2535
2535
# Check the variables
2536
2536
2537
2537
# Check if laptop
2538
self.assertFalse(gpu_test.is_laptop)
2538
self.assertFalse(gpu_test.requires_offloading)
2539
2539
2540
2540
self.assertTrue(gpu_test.has_single_card)
2541
2541
# No Intel
2577
2577
# Check the variables
2578
2578
2579
2579
# Check if laptop
2580
self.assertFalse(gpu_test.is_laptop)
2580
self.assertFalse(gpu_test.requires_offloading)
2581
2581
2582
2582
self.assertTrue(gpu_test.has_single_card)
2583
2583
# No Intel
2618
2618
# Check the variables
2619
2619
2620
2620
# Check if laptop
2621
self.assertFalse(gpu_test.is_laptop)
2621
self.assertFalse(gpu_test.requires_offloading)
2622
2622
2623
2623
self.assertTrue(gpu_test.has_single_card)
2624
2624
# No Intel
2659
2659
# Check the variables
2660
2660
2661
2661
# Check if laptop
2662
self.assertFalse(gpu_test.is_laptop)
2662
self.assertFalse(gpu_test.requires_offloading)
2663
2663
2664
2664
self.assertTrue(gpu_test.has_single_card)
2665
2665
#No Intel
2707
2707
# Check the variables
2708
2708
2709
2709
# Check if laptop
2710
self.assertFalse(gpu_test.is_laptop)
2710
self.assertFalse(gpu_test.requires_offloading)
2711
2711
2712
2712
self.assertTrue(gpu_test.has_single_card)
2713
2713
2751
2751
# Check the variables
2752
2752
2753
2753
# Check if laptop
2754
self.assertFalse(gpu_test.is_laptop)
2754
self.assertFalse(gpu_test.requires_offloading)
2755
2755
2756
2756
self.assertTrue(gpu_test.has_single_card)
2757
2757
2795
2795
# Check the variables
2796
2796
2797
2797
# Check if laptop
2798
self.assertFalse(gpu_test.is_laptop)
2798
self.assertFalse(gpu_test.requires_offloading)
2799
2799
2800
2800
self.assertTrue(gpu_test.has_single_card)
2801
2801
2839
2839
# Check the variables
2840
2840
2841
2841
# Check if laptop
2842
self.assertFalse(gpu_test.is_laptop)
2842
self.assertFalse(gpu_test.requires_offloading)
2843
2843
2844
2844
self.assertTrue(gpu_test.has_single_card)
2845
2845
2879
2879
['i915', 'radeon'],
2880
2880
['mesa'],
2881
2881
'mesa',
2882
is_laptop=True)
2882
requires_offloading=True)
2883
2883
2884
2884
# Check the variables
2885
2885
2886
2886
# Check if laptop
2887
self.assertTrue(gpu_test.is_laptop)
2887
self.assertTrue(gpu_test.requires_offloading)
2888
2888
2889
2889
self.assertFalse(gpu_test.has_single_card)
2890
2890
2921
2921
['i915', 'radeon'],
2922
2922
['mesa'],
2923
2923
'mesa',
2924
is_laptop=True)
2924
requires_offloading=True)
2925
2925
2926
2926
# Check the variables
2927
2927
2928
2928
# Check if laptop
2929
self.assertTrue(gpu_test.is_laptop)
2929
self.assertTrue(gpu_test.requires_offloading)
2930
2930
2931
2931
self.assertFalse(gpu_test.has_single_card)
2932
2932
2963
2963
['i915'],
2964
2964
['mesa'],
2965
2965
'mesa',
2966
is_laptop=True)
2966
requires_offloading=True)
2967
2967
2968
2968
# Check the variables
2969
2969
2970
2970
# Check if laptop
2971
self.assertTrue(gpu_test.is_laptop)
2971
self.assertTrue(gpu_test.requires_offloading)
2972
2972
2973
2973
self.assertTrue(gpu_test.has_single_card)
2974
2974
3012
3012
# Check the variables
3013
3013
3014
3014
# Check if laptop
3015
self.assertFalse(gpu_test.is_laptop)
3015
self.assertFalse(gpu_test.requires_offloading)
3016
3016
3017
3017
self.assertFalse(gpu_test.has_single_card)
3018
3018
3053
3053
# Check the variables
3054
3054
3055
3055
# Check if laptop
3056
self.assertFalse(gpu_test.is_laptop)
3056
self.assertFalse(gpu_test.requires_offloading)
3057
3057
3058
3058
self.assertFalse(gpu_test.has_single_card)
3059
3059
3094
3094
# Check the variables
3095
3095
3096
3096
# Check if laptop
3097
self.assertFalse(gpu_test.is_laptop)
3097
self.assertFalse(gpu_test.requires_offloading)
3098
3098
3099
3099
self.assertTrue(gpu_test.has_single_card)
3100
3100
3136
3136
['i915', 'fglrx'],
3137
3137
['mesa', 'fglrx'],
3138
3138
'fglrx',
3139
is_laptop=True)
3139
requires_offloading=True)
3140
3140
3141
3141
# Check the variables
3142
3142
3143
3143
# Check if laptop
3144
self.assertTrue(gpu_test.is_laptop)
3144
self.assertTrue(gpu_test.requires_offloading)
3145
3145
3146
3146
self.assertFalse(gpu_test.has_single_card)
3147
3147
3187
3187
['i915', 'fglrx'],
3188
3188
['mesa', 'fglrx'],
3189
3189
'fglrx',
3190
is_laptop=True)
3190
requires_offloading=True)
3191
3191
3192
3192
# Has changed
3193
3193
self.assertTrue(gpu_test.has_changed)
3255
3255
['i915', 'fglrx'],
3256
3256
['mesa', 'fglrx'],
3257
3257
'fglrx',
3258
is_laptop=True)
3258
requires_offloading=True)
3259
3259
3260
3260
# Has changed
3261
3261
self.assertTrue(gpu_test.has_changed)
3325
3325
['i915', 'fglrx'],
3326
3326
['mesa', 'fglrx'],
3327
3327
'fglrx',
3328
is_laptop=True)
3328
requires_offloading=True)
3329
3329
3330
3330
# Has changed
3331
3331
self.assertTrue(gpu_test.has_changed)
3396
3396
['i915', 'fglrx'],
3397
3397
['mesa', 'fglrx'],
3398
3398
'fglrx',
3399
is_laptop=True)
3399
requires_offloading=True)
3400
3400
3401
3401
# Has changed
3402
3402
self.assertTrue(gpu_test.has_changed)
3466
3466
['mesa', 'fglrx'],
3467
3467
'fglrx',
3468
3468
unloaded_module='fglrx',
3469
is_laptop=True)
3469
requires_offloading=True)
3470
3470
3471
3471
# Check that fglrx was unloaded
3472
3472
self.assertTrue(gpu_test.fglrx_unloaded)
3533
3533
['mesa', 'fglrx'],
3534
3534
'fglrx',
3535
3535
unloaded_module='fglrx',
3536
is_laptop=True)
3536
requires_offloading=True)
3537
3537
3538
3538
# Check that fglrx was unloaded
3539
3539
self.assertTrue(gpu_test.fglrx_unloaded)
3562
3562
['i915', 'fake'],
3563
3563
['mesa', 'fglrx'],
3564
3564
'fglrx',
3565
is_laptop=True)
3565
requires_offloading=True)
3566
3566
3567
3567
# Check the variables
3568
3568
3569
3569
# Check if laptop
3570
self.assertTrue(gpu_test.is_laptop)
3570
self.assertTrue(gpu_test.requires_offloading)
3571
3571
3572
3572
self.assertFalse(gpu_test.has_single_card)
3573
3573
3607
3607
['i915', 'fglrx'],
3608
3608
['mesa', 'fglrx'],
3609
3609
'mesa',
3610
is_laptop=True)
3610
requires_offloading=True)
3611
3611
3612
3612
# Check the variables
3613
3613
3614
3614
# Check if laptop
3615
self.assertTrue(gpu_test.is_laptop)
3615
self.assertTrue(gpu_test.requires_offloading)
3616
3616
3617
3617
self.assertFalse(gpu_test.has_single_card)
3618
3618
3654
3654
['i915', 'fglrx'],
3655
3655
['mesa', 'fglrx'],
3656
3656
'pxpress',
3657
is_laptop=True)
3657
requires_offloading=True)
3658
3658
3659
3659
# Check the variables
3660
3660
3661
3661
# Check if laptop
3662
self.assertTrue(gpu_test.is_laptop)
3662
self.assertTrue(gpu_test.requires_offloading)
3663
3663
3664
3664
self.assertFalse(gpu_test.has_single_card)
3665
3665
3704
3704
['i915', 'fake'],
3705
3705
['mesa', 'fglrx'],
3706
3706
'pxpress',
3707
is_laptop=True)
3707
requires_offloading=True)
3708
3708
3709
3709
# Check the variables
3710
3710
3711
3711
# Check if laptop
3712
self.assertTrue(gpu_test.is_laptop)
3712
self.assertTrue(gpu_test.requires_offloading)
3713
3713
3714
3714
self.assertFalse(gpu_test.has_single_card)
3715
3715
3750
3750
['i915', 'fglrx'],
3751
3751
['mesa', 'fglrx'],
3752
3752
'mesa',
3753
is_laptop=True)
3753
requires_offloading=True)
3754
3754
3755
3755
# Check the variables
3756
3756
3757
3757
# Check if laptop
3758
self.assertTrue(gpu_test.is_laptop)
3758
self.assertTrue(gpu_test.requires_offloading)
3759
3759
3760
3760
self.assertFalse(gpu_test.has_single_card)
3761
3761
3798
3798
['i915', 'fglrx'],
3799
3799
['mesa', 'fglrx'],
3800
3800
'fglrx',
3801
is_laptop=True)
3801
requires_offloading=True)
3802
3802
3803
3803
# Check the variables
3804
3804
3805
3805
# Check if laptop
3806
self.assertTrue(gpu_test.is_laptop)
3806
self.assertTrue(gpu_test.requires_offloading)
3807
3807
3808
3808
self.assertFalse(gpu_test.has_single_card)
3809
3809
3844
3844
['i915', 'fake'],
3845
3845
['mesa', 'fglrx'],
3846
3846
'fglrx',
3847
is_laptop=True)
3847
requires_offloading=True)
3848
3848
3849
3849
# Check the variables
3850
3850
3851
3851
# Check if laptop
3852
self.assertTrue(gpu_test.is_laptop)
3852
self.assertTrue(gpu_test.requires_offloading)
3853
3853
3854
3854
self.assertFalse(gpu_test.has_single_card)
3855
3855
3890
3890
['i915', 'fglrx'],
3891
3891
['mesa', 'fglrx'],
3892
3892
'mesa',
3893
is_laptop=True)
3893
requires_offloading=True)
3894
3894
3895
3895
# Check the variables
3896
3896
3897
3897
# Check if laptop
3898
self.assertTrue(gpu_test.is_laptop)
3898
self.assertTrue(gpu_test.requires_offloading)
3899
3899
3900
3900
self.assertFalse(gpu_test.has_single_card)
3901
3901
3938
3938
['i915', 'fglrx'],
3939
3939
['mesa', 'fglrx'],
3940
3940
'pxpress',
3941
is_laptop=True)
3941
requires_offloading=True)
3942
3942
3943
3943
# Check the variables
3944
3944
3945
3945
# Check if laptop
3946
self.assertTrue(gpu_test.is_laptop)
3946
self.assertTrue(gpu_test.requires_offloading)
3947
3947
3948
3948
self.assertFalse(gpu_test.has_single_card)
3949
3949
3986
3986
['i915', 'fake'],
3987
3987
['mesa', 'fglrx'],
3988
3988
'pxpress',
3989
is_laptop=True)
3989
requires_offloading=True)
3990
3990
3991
3991
# Check the variables
3992
3992
3993
3993
# Check if laptop
3994
self.assertTrue(gpu_test.is_laptop)
3994
self.assertTrue(gpu_test.requires_offloading)
3995
3995
3996
3996
self.assertFalse(gpu_test.has_single_card)
3997
3997
4032
4032
['i915', 'fglrx'],
4033
4033
['mesa', 'fglrx'],
4034
4034
'mesa',
4035
is_laptop=True)
4035
requires_offloading=True)
4036
4036
4037
4037
# Check the variables
4038
4038
4039
4039
# Check if laptop
4040
self.assertTrue(gpu_test.is_laptop)
4040
self.assertTrue(gpu_test.requires_offloading)
4041
4041
4042
4042
self.assertFalse(gpu_test.has_single_card)
4043
4043
4080
4080
['i915', 'fglrx'],
4081
4081
['mesa', 'fglrx'],
4082
4082
'fglrx',
4083
is_laptop=True)
4083
requires_offloading=True)
4084
4084
4085
4085
# Check the variables
4086
4086
4087
4087
# Check if laptop
4088
self.assertTrue(gpu_test.is_laptop)
4088
self.assertTrue(gpu_test.requires_offloading)
4089
4089
4090
4090
self.assertTrue(gpu_test.has_single_card)
4091
4091
4125
4125
['i915', 'fake'],
4126
4126
['mesa', 'fglrx'],
4127
4127
'fglrx',
4128
is_laptop=True)
4128
requires_offloading=True)
4129
4129
4130
4130
# Check the variables
4131
4131
4132
4132
# Check if laptop
4133
self.assertTrue(gpu_test.is_laptop)
4133
self.assertTrue(gpu_test.requires_offloading)
4134
4134
4135
4135
self.assertTrue(gpu_test.has_single_card)
4136
4136
4170
4170
['i915', 'fglrx'],
4171
4171
['mesa', 'fglrx'],
4172
4172
'mesa',
4173
is_laptop=True)
4173
requires_offloading=True)
4174
4174
4175
4175
# Check the variables
4176
4176
4177
4177
# Check if laptop
4178
self.assertTrue(gpu_test.is_laptop)
4178
self.assertTrue(gpu_test.requires_offloading)
4179
4179
4180
4180
self.assertTrue(gpu_test.has_single_card)
4181
4181
4217
4217
['i915', 'fglrx'],
4218
4218
['mesa', 'fglrx'],
4219
4219
'pxpress',
4220
is_laptop=True)
4220
requires_offloading=True)
4221
4221
4222
4222
4223
4223
# Check the variables
4224
4224
4225
4225
# Check if laptop
4226
self.assertTrue(gpu_test.is_laptop)
4226
self.assertTrue(gpu_test.requires_offloading)
4227
4227
4228
4228
self.assertTrue(gpu_test.has_single_card)
4229
4229
4263
4263
['i915', 'fake'],
4264
4264
['mesa', 'fglrx'],
4265
4265
'pxpress',
4266
is_laptop=True)
4266
requires_offloading=True)
4267
4267
4268
4268
# Check the variables
4269
4269
4270
4270
# Check if laptop
4271
self.assertTrue(gpu_test.is_laptop)
4271
self.assertTrue(gpu_test.requires_offloading)
4272
4272
4273
4273
self.assertTrue(gpu_test.has_single_card)
4274
4274
4308
4308
['i915', 'fglrx'],
4309
4309
['mesa', 'fglrx'],
4310
4310
'mesa',
4311
is_laptop=True)
4311
requires_offloading=True)
4312
4312
4313
4313
# Check the variables
4314
4314
4315
4315
# Check if laptop
4316
self.assertTrue(gpu_test.is_laptop)
4316
self.assertTrue(gpu_test.requires_offloading)
4317
4317
4318
4318
self.assertTrue(gpu_test.has_single_card)
4319
4319
4360
4360
# Check the variables
4361
4361
4362
4362
# Check if laptop
4363
self.assertFalse(gpu_test.is_laptop)
4363
self.assertFalse(gpu_test.requires_offloading)
4364
4364
4365
4365
self.assertFalse(gpu_test.has_single_card)
4366
4366
4404
4404
# Check the variables
4405
4405
4406
4406
# Check if laptop
4407
self.assertFalse(gpu_test.is_laptop)
4407
self.assertFalse(gpu_test.requires_offloading)
4408
4408
4409
4409
self.assertFalse(gpu_test.has_single_card)
4410
4410
4448
4448
# Check the variables
4449
4449
4450
4450
# Check if laptop
4451
self.assertFalse(gpu_test.is_laptop)
4451
self.assertFalse(gpu_test.requires_offloading)
4452
4452
4453
4453
self.assertFalse(gpu_test.has_single_card)
4454
4454
4492
4492
# Check the variables
4493
4493
4494
4494
# Check if laptop
4495
self.assertFalse(gpu_test.is_laptop)
4495
self.assertFalse(gpu_test.requires_offloading)
4496
4496
4497
4497
self.assertFalse(gpu_test.has_single_card)
4498
4498
4539
4539
# Check the variables
4540
4540
4541
4541
# Check if laptop
4542
self.assertFalse(gpu_test.is_laptop)
4542
self.assertFalse(gpu_test.requires_offloading)
4543
4543
4544
4544
self.assertFalse(gpu_test.has_single_card)
4545
4545
4584
4584
# Check the variables
4585
4585
4586
4586
# Check if laptop
4587
self.assertFalse(gpu_test.is_laptop)
4587
self.assertFalse(gpu_test.requires_offloading)
4588
4588
4589
4589
self.assertFalse(gpu_test.has_single_card)
4590
4590
4629
4629
# Check the variables
4630
4630
4631
4631
# Check if laptop
4632
self.assertFalse(gpu_test.is_laptop)
4632
self.assertFalse(gpu_test.requires_offloading)
4633
4633
4634
4634
self.assertFalse(gpu_test.has_single_card)
4635
4635
4673
4673
# Check the variables
4674
4674
4675
4675
# Check if laptop
4676
self.assertFalse(gpu_test.is_laptop)
4676
self.assertFalse(gpu_test.requires_offloading)
4677
4677
4678
4678
self.assertFalse(gpu_test.has_single_card)
4679
4679
4717
4717
# Check the variables
4718
4718
4719
4719
# Check if laptop
4720
self.assertFalse(gpu_test.is_laptop)
4720
self.assertFalse(gpu_test.requires_offloading)
4721
4721
4722
4722
self.assertFalse(gpu_test.has_single_card)
4723
4723
4761
4761
# Check the variables
4762
4762
4763
4763
# Check if laptop
4764
self.assertFalse(gpu_test.is_laptop)
4764
self.assertFalse(gpu_test.requires_offloading)
4765
4765
4766
4766
self.assertFalse(gpu_test.has_single_card)
4767
4767
4805
4805
# Check the variables
4806
4806
4807
4807
# Check if laptop
4808
self.assertFalse(gpu_test.is_laptop)
4808
self.assertFalse(gpu_test.requires_offloading)
4809
4809
4810
4810
self.assertFalse(gpu_test.has_single_card)
4811
4811
4849
4849
# Check the variables
4850
4850
4851
4851
# Check if laptop
4852
self.assertFalse(gpu_test.is_laptop)
4852
self.assertFalse(gpu_test.requires_offloading)
4853
4853
4854
4854
self.assertFalse(gpu_test.has_single_card)
4855
4855
4893
4893
# Check the variables
4894
4894
4895
4895
# Check if laptop
4896
self.assertFalse(gpu_test.is_laptop)
4896
self.assertFalse(gpu_test.requires_offloading)
4897
4897
4898
4898
self.assertTrue(gpu_test.has_single_card)
4899
4899
4936
4936
# Check the variables
4937
4937
4938
4938
# Check if laptop
4939
self.assertFalse(gpu_test.is_laptop)
4939
self.assertFalse(gpu_test.requires_offloading)
4940
4940
4941
4941
self.assertTrue(gpu_test.has_single_card)
4942
4942
4979
4979
# Check the variables
4980
4980
4981
4981
# Check if laptop
4982
self.assertFalse(gpu_test.is_laptop)
4982
self.assertFalse(gpu_test.requires_offloading)
4983
4983
4984
4984
self.assertTrue(gpu_test.has_single_card)
4985
4985
5022
5022
# Check the variables
5023
5023
5024
5024
# Check if laptop
5025
self.assertFalse(gpu_test.is_laptop)
5025
self.assertFalse(gpu_test.requires_offloading)
5026
5026
5027
5027
self.assertTrue(gpu_test.has_single_card)
5028
5028
5065
5065
# Check the variables
5066
5066
5067
5067
# Check if laptop
5068
self.assertFalse(gpu_test.is_laptop)
5068
self.assertFalse(gpu_test.requires_offloading)
5069
5069
5070
5070
self.assertTrue(gpu_test.has_single_card)
5071
5071
5108
5108
# Check the variables
5109
5109
5110
5110
# Check if laptop
5111
self.assertFalse(gpu_test.is_laptop)
5111
self.assertFalse(gpu_test.requires_offloading)
5112
5112
5113
5113
self.assertTrue(gpu_test.has_single_card)
5114
5114
5148
5148
['i915', 'nouveau'],
5149
5149
['mesa'],
5150
5150
'mesa',
5151
is_laptop=True)
5151
requires_offloading=True)
5152
5152
5153
5153
# Check the variables
5154
5154
5155
5155
# Check if laptop
5156
self.assertTrue(gpu_test.is_laptop)
5156
self.assertTrue(gpu_test.requires_offloading)
5157
5157
5158
5158
self.assertFalse(gpu_test.has_single_card)
5159
5159
5190
5190
['i915', 'nouveau'],
5191
5191
['mesa'],
5192
5192
'mesa',
5193
is_laptop=True)
5193
requires_offloading=True)
5194
5194
5195
5195
# Check the variables
5196
5196
5197
5197
# Check if laptop
5198
self.assertTrue(gpu_test.is_laptop)
5198
self.assertTrue(gpu_test.requires_offloading)
5199
5199
5200
5200
self.assertFalse(gpu_test.has_single_card)
5201
5201
5232
5232
['i915'],
5233
5233
['mesa'],
5234
5234
'mesa',
5235
is_laptop=True)
5235
requires_offloading=True)
5236
5236
5237
5237
# Check the variables
5238
5238
5239
5239
# Check if laptop
5240
self.assertTrue(gpu_test.is_laptop)
5240
self.assertTrue(gpu_test.requires_offloading)
5241
5241
5242
5242
self.assertTrue(gpu_test.has_single_card)
5243
5243
5279
5279
# Check the variables
5280
5280
5281
5281
# Check if laptop
5282
self.assertFalse(gpu_test.is_laptop)
5282
self.assertFalse(gpu_test.requires_offloading)
5283
5283
5284
5284
self.assertFalse(gpu_test.has_single_card)
5285
5285
5320
5320
# Check the variables
5321
5321
5322
5322
# Check if laptop
5323
self.assertFalse(gpu_test.is_laptop)
5323
self.assertFalse(gpu_test.requires_offloading)
5324
5324
5325
5325
self.assertFalse(gpu_test.has_single_card)
5326
5326
5361
5361
# Check the variables
5362
5362
5363
5363
# Check if laptop
5364
self.assertFalse(gpu_test.is_laptop)
5364
self.assertFalse(gpu_test.requires_offloading)
5365
5365
5366
5366
self.assertTrue(gpu_test.has_single_card)
5367
5367
5413
5413
['i915', 'nvidia'],
5414
5414
['mesa', 'nvidia'],
5415
5415
'nvidia',
5416
is_laptop=True)
5416
requires_offloading=True)
5417
5417
5418
5418
# Check the variables
5419
5419
5422
5422
self.assertTrue(gpu_test.loaded_with_args)
5423
5423
5424
5424
# Check if laptop
5425
self.assertTrue(gpu_test.is_laptop)
5425
self.assertTrue(gpu_test.requires_offloading)
5426
5426
5427
5427
self.assertFalse(gpu_test.has_single_card)
5428
5428
5473
5473
['i915', 'nvidia'],
5474
5474
['mesa', 'nvidia'],
5475
5475
'nvidia',
5476
is_laptop=True)
5476
requires_offloading=True)
5477
5477
5478
5478
# Check the variables
5479
5479
5496
5496
['i915', 'fake'],
5497
5497
['mesa', 'nvidia'],
5498
5498
'nvidia',
5499
is_laptop=True)
5499
requires_offloading=True)
5500
5500
# Check the variables
5501
5501
5502
5502
# Check if laptop
5503
self.assertTrue(gpu_test.is_laptop)
5503
self.assertTrue(gpu_test.requires_offloading)
5504
5504
5505
5505
self.assertFalse(gpu_test.has_single_card)
5506
5506
5546
5546
['i915', 'nvidia'],
5547
5547
['mesa', 'nvidia'],
5548
5548
'mesa',
5549
is_laptop=True)
5549
requires_offloading=True)
5550
5550
5551
5551
# Check the variables
5552
5552
5553
5553
# Check if laptop
5554
self.assertTrue(gpu_test.is_laptop)
5554
self.assertTrue(gpu_test.requires_offloading)
5555
5555
5556
5556
self.assertFalse(gpu_test.has_single_card)
5557
5557
5596
5596
['i915', 'nvidia'],
5597
5597
['mesa', 'nvidia'],
5598
5598
'prime',
5599
is_laptop=True)
5599
requires_offloading=True)
5600
5600
5601
5601
# Check the variables
5602
5602
5603
5603
# Check if laptop
5604
self.assertTrue(gpu_test.is_laptop)
5604
self.assertTrue(gpu_test.requires_offloading)
5605
5605
5606
5606
self.assertFalse(gpu_test.has_single_card)
5607
5607
5647
5647
['i915', 'fake'],
5648
5648
['mesa', 'nvidia'],
5649
5649
'prime',
5650
is_laptop=True)
5650
requires_offloading=True)
5651
5651
5652
5652
# Check the variables
5653
5653
5654
5654
# Check if laptop
5655
self.assertTrue(gpu_test.is_laptop)
5655
self.assertTrue(gpu_test.requires_offloading)
5656
5656
5657
5657
self.assertFalse(gpu_test.has_single_card)
5658
5658
5699
5699
['i915', 'nvidia'],
5700
5700
['mesa', 'nvidia'],
5701
5701
'mesa',
5702
is_laptop=True)
5702
requires_offloading=True)
5703
5703
5704
5704
# Check the variables
5705
5705
5706
5706
# Check if laptop
5707
self.assertTrue(gpu_test.is_laptop)
5707
self.assertTrue(gpu_test.requires_offloading)
5708
5708
5709
5709
self.assertFalse(gpu_test.has_single_card)
5710
5710
5750
5750
['i915', 'nvidia'],
5751
5751
['mesa', 'nvidia'],
5752
5752
'nvidia',
5753
is_laptop=True)
5753
requires_offloading=True)
5754
5754
5755
5755
# Check the variables
5756
5756
5757
5757
# Check if laptop
5758
self.assertTrue(gpu_test.is_laptop)
5758
self.assertTrue(gpu_test.requires_offloading)
5759
5759
5760
5760
self.assertFalse(gpu_test.has_single_card)
5761
5761
5803
5803
['i915', 'fake'],
5804
5804
['mesa', 'nvidia'],
5805
5805
'nvidia',
5806
is_laptop=True)
5806
requires_offloading=True)
5807
5807
5808
5808
# Check the variables
5809
5809
5810
5810
# Check if laptop
5811
self.assertTrue(gpu_test.is_laptop)
5811
self.assertTrue(gpu_test.requires_offloading)
5812
5812
5813
5813
self.assertFalse(gpu_test.has_single_card)
5814
5814
5854
5854
['i915', 'nvidia'],
5855
5855
['mesa', 'nvidia'],
5856
5856
'mesa',
5857
is_laptop=True)
5857
requires_offloading=True)
5858
5858
5859
5859
# Check the variables
5860
5860
5861
5861
# Check if laptop
5862
self.assertTrue(gpu_test.is_laptop)
5862
self.assertTrue(gpu_test.requires_offloading)
5863
5863
5864
5864
self.assertFalse(gpu_test.has_single_card)
5865
5865
5905
5905
['i915', 'nvidia'],
5906
5906
['mesa', 'nvidia'],
5907
5907
'prime',
5908
is_laptop=True)
5908
requires_offloading=True)
5909
5909
5910
5910
# Check the variables
5911
5911
5912
5912
# Check if laptop
5913
self.assertTrue(gpu_test.is_laptop)
5913
self.assertTrue(gpu_test.requires_offloading)
5914
5914
5915
5915
self.assertFalse(gpu_test.has_single_card)
5916
5916
5956
5956
['i915', 'fake'],
5957
5957
['mesa', 'nvidia'],
5958
5958
'prime',
5959
is_laptop=True)
5959
requires_offloading=True)
5960
5960
5961
5961
# Check the variables
5962
5962
5963
5963
# Check if laptop
5964
self.assertTrue(gpu_test.is_laptop)
5964
self.assertTrue(gpu_test.requires_offloading)
5965
5965
5966
5966
self.assertFalse(gpu_test.has_single_card)
5967
5967
6008
6008
['i915', 'nvidia'],
6009
6009
['mesa', 'nvidia'],
6010
6010
'mesa',
6011
is_laptop=True)
6011
requires_offloading=True)
6012
6012
6013
6013
# Check the variables
6014
6014
6015
6015
# Check if laptop
6016
self.assertTrue(gpu_test.is_laptop)
6016
self.assertTrue(gpu_test.requires_offloading)
6017
6017
6018
6018
self.assertFalse(gpu_test.has_single_card)
6019
6019
6053
6053
['i915', 'nvidia'],
6054
6054
['mesa', 'nvidia'],
6055
6055
'nvidia',
6056
is_laptop=True)
6056
requires_offloading=True)
6057
6057
6058
6058
# Check the variables
6059
6059
6060
6060
# Check if laptop
6061
self.assertTrue(gpu_test.is_laptop)
6061
self.assertTrue(gpu_test.requires_offloading)
6062
6062
6063
6063
self.assertTrue(gpu_test.has_single_card)
6064
6064
6096
6096
['i915', 'fake'],
6097
6097
['mesa', 'nvidia'],
6098
6098
'nvidia',
6099
is_laptop=True)
6099
requires_offloading=True)
6100
6100
# Check the variables
6101
6101
6102
6102
# Check if laptop
6103
self.assertTrue(gpu_test.is_laptop)
6103
self.assertTrue(gpu_test.requires_offloading)
6104
6104
6105
6105
self.assertTrue(gpu_test.has_single_card)
6106
6106
6146
6146
['mesa', 'nvidia'],
6147
6147
'prime',
6148
6148
unloaded_module='nvidia',
6149
is_laptop=True)
6149
requires_offloading=True)
6150
6150
6151
6151
# Check the variables
6152
6152
6153
6153
# Check if laptop
6154
self.assertTrue(gpu_test.is_laptop)
6154
self.assertTrue(gpu_test.requires_offloading)
6155
6155
6156
6156
self.assertTrue(gpu_test.has_single_card)
6157
6157
6198
6198
['mesa', 'nvidia'],
6199
6199
'prime',
6200
6200
unloaded_module='nvidia',
6201
is_laptop=True)
6201
requires_offloading=True)
6202
6202
6203
6203
# Check the variables
6204
6204
6205
6205
# Check if laptop
6206
self.assertTrue(gpu_test.is_laptop)
6206
self.assertTrue(gpu_test.requires_offloading)
6207
6207
6208
6208
self.assertTrue(gpu_test.has_single_card)
6209
6209
6241
6241
['i915', 'nvidia'],
6242
6242
['mesa', 'nvidia'],
6243
6243
'mesa',
6244
is_laptop=True)
6244
requires_offloading=True)
6245
6245
6246
6246
# Check the variables
6247
6247
6248
6248
# Check if laptop
6249
self.assertTrue(gpu_test.is_laptop)
6249
self.assertTrue(gpu_test.requires_offloading)
6250
6250
6251
6251
self.assertTrue(gpu_test.has_single_card)
6252
6252
6284
6284
['i915', 'nvidia'],
6285
6285
['mesa', 'nvidia'],
6286
6286
'prime',
6287
is_laptop=True)
6287
requires_offloading=True)
6288
6288
6289
6289
# Check the variables
6290
6290
6291
6291
# Check if laptop
6292
self.assertTrue(gpu_test.is_laptop)
6292
self.assertTrue(gpu_test.requires_offloading)
6293
6293
6294
6294
self.assertTrue(gpu_test.has_single_card)
6295
6295
6327
6327
['i915'],
6328
6328
['mesa', 'nvidia'],
6329
6329
'prime',
6330
is_laptop=True)
6330
requires_offloading=True)
6331
6331
6332
6332
# Check the variables
6333
6333
6334
6334
# Check if laptop
6335
self.assertTrue(gpu_test.is_laptop)
6335
self.assertTrue(gpu_test.requires_offloading)
6336
6336
6337
6337
self.assertTrue(gpu_test.has_single_card)
6338
6338
6370
6370
['i915', 'nvidia'],
6371
6371
['mesa', 'nvidia'],
6372
6372
'mesa',
6373
is_laptop=True)
6373
requires_offloading=True)
6374
6374
6375
6375
# Check the variables
6376
6376
6377
6377
# Check if laptop
6378
self.assertTrue(gpu_test.is_laptop)
6378
self.assertTrue(gpu_test.requires_offloading)
6379
6379
6380
6380
self.assertTrue(gpu_test.has_single_card)
6381
6381
6420
6420
# Check the variables
6421
6421
6422
6422
# Check if laptop
6423
self.assertFalse(gpu_test.is_laptop)
6423
self.assertFalse(gpu_test.requires_offloading)
6424
6424
6425
6425
self.assertFalse(gpu_test.has_single_card)
6426
6426
6461
6461
# Check the variables
6462
6462
6463
6463
# Check if laptop
6464
self.assertFalse(gpu_test.is_laptop)
6464
self.assertFalse(gpu_test.requires_offloading)
6465
6465
6466
6466
self.assertFalse(gpu_test.has_single_card)
6467
6467
6504
6504
# Check the variables
6505
6505
6506
6506
# Check if laptop
6507
self.assertFalse(gpu_test.is_laptop)
6507
self.assertFalse(gpu_test.requires_offloading)
6508
6508
6509
6509
self.assertFalse(gpu_test.has_single_card)
6510
6510
6548
6548
# Check the variables
6549
6549
6550
6550
# Check if laptop
6551
self.assertFalse(gpu_test.is_laptop)
6551
self.assertFalse(gpu_test.requires_offloading)
6552
6552
6553
6553
self.assertFalse(gpu_test.has_single_card)
6554
6554
6591
6591
# Check the variables
6592
6592
6593
6593
# Check if laptop
6594
self.assertFalse(gpu_test.is_laptop)
6594
self.assertFalse(gpu_test.requires_offloading)
6595
6595
6596
6596
self.assertFalse(gpu_test.has_single_card)
6597
6597
6634
6634
# Check the variables
6635
6635
6636
6636
# Check if laptop
6637
self.assertFalse(gpu_test.is_laptop)
6637
self.assertFalse(gpu_test.requires_offloading)
6638
6638
6639
6639
self.assertFalse(gpu_test.has_single_card)
6640
6640
6677
6677
# Check the variables
6678
6678
6679
6679
# Check if laptop
6680
self.assertFalse(gpu_test.is_laptop)
6680
self.assertFalse(gpu_test.requires_offloading)
6681
6681
6682
6682
self.assertFalse(gpu_test.has_single_card)
6683
6683
6799
6799
# Check the variables
6800
6800
6801
6801
# Check if laptop
6802
self.assertFalse(gpu_test.is_laptop)
6802
self.assertFalse(gpu_test.requires_offloading)
6803
6803
6804
6804
self.assertFalse(gpu_test.has_single_card)
6805
6805
6842
6842
# Check the variables
6843
6843
6844
6844
# Check if laptop
6845
self.assertFalse(gpu_test.is_laptop)
6845
self.assertFalse(gpu_test.requires_offloading)
6846
6846
6847
6847
self.assertFalse(gpu_test.has_single_card)
6848
6848
6885
6885
# Check the variables
6886
6886
6887
6887
# Check if laptop
6888
self.assertFalse(gpu_test.is_laptop)
6888
self.assertFalse(gpu_test.requires_offloading)
6889
6889
6890
6890
self.assertFalse(gpu_test.has_single_card)
6891
6891
6928
6928
# Check the variables
6929
6929
6930
6930
# Check if laptop
6931
self.assertFalse(gpu_test.is_laptop)
6931
self.assertFalse(gpu_test.requires_offloading)
6932
6932
6933
6933
self.assertFalse(gpu_test.has_single_card)
6934
6934
6976
6976
# Check the variables
6977
6977
6978
6978
# Check if laptop
6979
self.assertFalse(gpu_test.is_laptop)
6979
self.assertFalse(gpu_test.requires_offloading)
6980
6980
6981
6981
self.assertTrue(gpu_test.has_single_card)
6982
6982
7018
7018
# Check the variables
7019
7019
7020
7020
# Check if laptop
7021
self.assertFalse(gpu_test.is_laptop)
7021
self.assertFalse(gpu_test.requires_offloading)
7022
7022
7023
7023
self.assertTrue(gpu_test.has_single_card)
7024
7024
7060
7060
# Check the variables
7061
7061
7062
7062
# Check if laptop
7063
self.assertFalse(gpu_test.is_laptop)
7063
self.assertFalse(gpu_test.requires_offloading)
7064
7064
7065
7065
self.assertTrue(gpu_test.has_single_card)
7066
7066
7102
7102
# Check the variables
7103
7103
7104
7104
# Check if laptop
7105
self.assertFalse(gpu_test.is_laptop)
7105
self.assertFalse(gpu_test.requires_offloading)
7106
7106
7107
7107
self.assertTrue(gpu_test.has_single_card)
7108
7108
7144
7144
# Check the variables
7145
7145
7146
7146
# Check if laptop
7147
self.assertFalse(gpu_test.is_laptop)
7147
self.assertFalse(gpu_test.requires_offloading)
7148
7148
7149
7149
self.assertTrue(gpu_test.has_single_card)
7150
7150
7186
7186
# Check the variables
7187
7187
7188
7188
# Check if laptop
7189
self.assertFalse(gpu_test.is_laptop)
7189
self.assertFalse(gpu_test.requires_offloading)
7190
7190
7191
7191
self.assertTrue(gpu_test.has_single_card)
7192
7192
7231
7231
# Check the variables
7232
7232
7233
7233
# Check if laptop
7234
self.assertFalse(gpu_test.is_laptop)
7234
self.assertFalse(gpu_test.requires_offloading)
7235
7235
7236
7236
self.assertFalse(gpu_test.has_single_card)
7237
7237
7272
7272
# Check the variables
7273
7273
7274
7274
# Check if laptop
7275
self.assertFalse(gpu_test.is_laptop)
7275
self.assertFalse(gpu_test.requires_offloading)
7276
7276
7277
7277
self.assertFalse(gpu_test.has_single_card)
7278
7278
7313
7313
# Check the variables
7314
7314
7315
7315
# Check if laptop
7316
self.assertFalse(gpu_test.is_laptop)
7316
self.assertFalse(gpu_test.requires_offloading)
7317
7317
7318
7318
self.assertFalse(gpu_test.has_single_card)
7319
7319
7356
7356
# Check the variables
7357
7357
7358
7358
# Check if laptop
7359
self.assertFalse(gpu_test.is_laptop)
7359
self.assertFalse(gpu_test.requires_offloading)
7360
7360
7361
7361
self.assertFalse(gpu_test.has_single_card)
7362
7362
7399
7399
# Check the variables
7400
7400
7401
7401
# Check if laptop
7402
self.assertFalse(gpu_test.is_laptop)
7402
self.assertFalse(gpu_test.requires_offloading)
7403
7403
7404
7404
self.assertFalse(gpu_test.has_single_card)
7405
7405
7442
7442
# Check the variables
7443
7443
7444
7444
# Check if laptop
7445
self.assertFalse(gpu_test.is_laptop)
7445
self.assertFalse(gpu_test.requires_offloading)
7446
7446
7447
7447
self.assertFalse(gpu_test.has_single_card)
7448
7448
7485
7485
# Check the variables
7486
7486
7487
7487
# Check if laptop
7488
self.assertFalse(gpu_test.is_laptop)
7488
self.assertFalse(gpu_test.requires_offloading)
7489
7489
7490
7490
self.assertFalse(gpu_test.has_single_card)
7491
7491
7612
7612
# Check the variables
7613
7613
7614
7614
# Check if laptop
7615
self.assertFalse(gpu_test.is_laptop)
7615
self.assertFalse(gpu_test.requires_offloading)
7616
7616
7617
7617
self.assertFalse(gpu_test.has_single_card)
7618
7618
7655
7655
# Check the variables
7656
7656
7657
7657
# Check if laptop
7658
self.assertFalse(gpu_test.is_laptop)
7658
self.assertFalse(gpu_test.requires_offloading)
7659
7659
7660
7660
self.assertFalse(gpu_test.has_single_card)
7661
7661
7698
7698
# Check the variables
7699
7699
7700
7700
# Check if laptop
7701
self.assertFalse(gpu_test.is_laptop)
7701
self.assertFalse(gpu_test.requires_offloading)
7702
7702
7703
7703
self.assertFalse(gpu_test.has_single_card)
7704
7704
7741
7741
# Check the variables
7742
7742
7743
7743
# Check if laptop
7744
self.assertFalse(gpu_test.is_laptop)
7744
self.assertFalse(gpu_test.requires_offloading)
7745
7745
7746
7746
self.assertFalse(gpu_test.has_single_card)
7747
7747
7789
7789
# Check the variables
7790
7790
7791
7791
# Check if laptop
7792
self.assertFalse(gpu_test.is_laptop)
7792
self.assertFalse(gpu_test.requires_offloading)
7793
7793
7794
7794
self.assertTrue(gpu_test.has_single_card)
7795
7795
7831
7831
# Check the variables
7832
7832
7833
7833
# Check if laptop
7834
self.assertFalse(gpu_test.is_laptop)
7834
self.assertFalse(gpu_test.requires_offloading)
7835
7835
7836
7836
self.assertTrue(gpu_test.has_single_card)
7837
7837
7873
7873
# Check the variables
7874
7874
7875
7875
# Check if laptop
7876
self.assertFalse(gpu_test.is_laptop)
7876
self.assertFalse(gpu_test.requires_offloading)
7877
7877
7878
7878
self.assertTrue(gpu_test.has_single_card)
7879
7879
7915
7915
# Check the variables
7916
7916
7917
7917
# Check if laptop
7918
self.assertFalse(gpu_test.is_laptop)
7918
self.assertFalse(gpu_test.requires_offloading)
7919
7919
7920
7920
self.assertTrue(gpu_test.has_single_card)
7921
7921
7957
7957
# Check the variables
7958
7958
7959
7959
# Check if laptop
7960
self.assertFalse(gpu_test.is_laptop)
7960
self.assertFalse(gpu_test.requires_offloading)
7961
7961
7962
7962
self.assertTrue(gpu_test.has_single_card)
7963
7963
7999
7999
# Check the variables
8000
8000
8001
8001
# Check if laptop
8002
self.assertFalse(gpu_test.is_laptop)
8002
self.assertFalse(gpu_test.requires_offloading)
8003
8003
8004
8004
self.assertTrue(gpu_test.has_single_card)
8005
8005
8041
8041
['fglrx', 'fake'],
8042
8042
['mesa', 'fglrx'],
8043
8043
'fglrx',
8044
is_laptop=True)
8044
requires_offloading=True)
8045
8045
8046
8046
# Check the variables
8047
8047
8048
8048
# Check if laptop
8049
self.assertTrue(gpu_test.is_laptop)
8049
self.assertTrue(gpu_test.requires_offloading)
8050
8050
8051
8051
self.assertFalse(gpu_test.has_single_card)
8052
8052
8083
8083
['fake_old', 'fake'],
8084
8084
['mesa', 'fglrx'],
8085
8085
'fglrx',
8086
is_laptop=True)
8086
requires_offloading=True)
8087
8087
8088
8088
# Check the variables
8089
8089
8090
8090
# Check if laptop
8091
self.assertTrue(gpu_test.is_laptop)
8091
self.assertTrue(gpu_test.requires_offloading)
8092
8092
8093
8093
self.assertFalse(gpu_test.has_single_card)
8094
8094
8125
8125
['fglrx', 'fake'],
8126
8126
['mesa', 'fglrx'],
8127
8127
'mesa',
8128
is_laptop=True)
8128
requires_offloading=True)
8129
8129
8130
8130
# Check the variables
8131
8131
8132
8132
# Check if laptop
8133
self.assertTrue(gpu_test.is_laptop)
8133
self.assertTrue(gpu_test.requires_offloading)
8134
8134
8135
8135
self.assertFalse(gpu_test.has_single_card)
8136
8136
8169
8169
['fglrx', 'fake'],
8170
8170
['mesa', 'fglrx'],
8171
8171
'pxpress',
8172
is_laptop=True)
8172
requires_offloading=True)
8173
8173
8174
8174
# Check the variables
8175
8175
8176
8176
# Check if laptop
8177
self.assertTrue(gpu_test.is_laptop)
8177
self.assertTrue(gpu_test.requires_offloading)
8178
8178
8179
8179
self.assertFalse(gpu_test.has_single_card)
8180
8180
8213
8213
['fake_old', 'fake'],
8214
8214
['mesa', 'fglrx'],
8215
8215
'pxpress',
8216
is_laptop=True)
8216
requires_offloading=True)
8217
8217
8218
8218
# Check the variables
8219
8219
8220
8220
# Check if laptop
8221
self.assertTrue(gpu_test.is_laptop)
8221
self.assertTrue(gpu_test.requires_offloading)
8222
8222
8223
8223
self.assertFalse(gpu_test.has_single_card)
8224
8224
8257
8257
['fglrx', 'fake'],
8258
8258
['mesa', 'fglrx'],
8259
8259
'mesa',
8260
is_laptop=True)
8260
requires_offloading=True)
8261
8261
8262
8262
# Check the variables
8263
8263
8264
8264
# Check if laptop
8265
self.assertTrue(gpu_test.is_laptop)
8265
self.assertTrue(gpu_test.requires_offloading)
8266
8266
8267
8267
self.assertFalse(gpu_test.has_single_card)
8268
8268
8301
8301
['fglrx', 'fake'],
8302
8302
['mesa', 'fglrx'],
8303
8303
'fglrx',
8304
is_laptop=True)
8304
requires_offloading=True)
8305
8305
8306
8306
# Check the variables
8307
8307
8308
8308
# Check if laptop
8309
self.assertTrue(gpu_test.is_laptop)
8309
self.assertTrue(gpu_test.requires_offloading)
8310
8310
8311
8311
self.assertFalse(gpu_test.has_single_card)
8312
8312
8359
8359
['fglrx', 'fake'],
8360
8360
['mesa', 'fglrx'],
8361
8361
'fglrx',
8362
is_laptop=True)
8362
requires_offloading=True)
8363
8363
8364
8364
# AMD
8365
8365
self.assertTrue(gpu_test.has_amd)
8400
8400
['fglrx', 'fake'],
8401
8401
['mesa', 'fglrx'],
8402
8402
'fglrx',
8403
is_laptop=True)
8403
requires_offloading=True)
8404
8404
8405
8405
# AMD
8406
8406
self.assertTrue(gpu_test.has_amd)
8431
8431
['fake_old', 'fake'],
8432
8432
['mesa', 'fglrx'],
8433
8433
'fglrx',
8434
is_laptop=True)
8434
requires_offloading=True)
8435
8435
8436
8436
# Check the variables
8437
8437
8438
8438
# Check if laptop
8439
self.assertTrue(gpu_test.is_laptop)
8439
self.assertTrue(gpu_test.requires_offloading)
8440
8440
8441
8441
self.assertFalse(gpu_test.has_single_card)
8442
8442
8475
8475
['fglrx', 'fake'],
8476
8476
['mesa', 'fglrx'],
8477
8477
'mesa',
8478
is_laptop=True)
8478
requires_offloading=True)
8479
8479
8480
8480
# Check the variables
8481
8481
8482
8482
# Check if laptop
8483
self.assertTrue(gpu_test.is_laptop)
8483
self.assertTrue(gpu_test.requires_offloading)
8484
8484
8485
8485
self.assertFalse(gpu_test.has_single_card)
8486
8486
8519
8519
['fglrx', 'fake'],
8520
8520
['mesa', 'fglrx'],
8521
8521
'pxpress',
8522
is_laptop=True)
8522
requires_offloading=True)
8523
8523
8524
8524
# Check the variables
8525
8525
8526
8526
# Check if laptop
8527
self.assertTrue(gpu_test.is_laptop)
8527
self.assertTrue(gpu_test.requires_offloading)
8528
8528
8529
8529
self.assertFalse(gpu_test.has_single_card)
8530
8530
8563
8563
['fake_old', 'fake'],
8564
8564
['mesa', 'fglrx'],
8565
8565
'pxpress',
8566
is_laptop=True)
8566
requires_offloading=True)
8567
8567
8568
8568
# Check the variables
8569
8569
8570
8570
# Check if laptop
8571
self.assertTrue(gpu_test.is_laptop)
8571
self.assertTrue(gpu_test.requires_offloading)
8572
8572
8573
8573
self.assertFalse(gpu_test.has_single_card)
8574
8574
8612
8612
['fglrx', 'fake'],
8613
8613
['mesa', 'fglrx'],
8614
8614
'fglrx',
8615
is_laptop=True)
8615
requires_offloading=True)
8616
8616
8617
8617
# Check the variables
8618
8618
8619
8619
# Check if laptop
8620
self.assertTrue(gpu_test.is_laptop)
8620
self.assertTrue(gpu_test.requires_offloading)
8621
8621
8622
8622
self.assertTrue(gpu_test.has_single_card)
8623
8623
8655
8655
['fake_old', 'fake'],
8656
8656
['mesa', 'fglrx'],
8657
8657
'fglrx',
8658
is_laptop=True)
8658
requires_offloading=True)
8659
8659
8660
8660
# Check the variables
8661
8661
8662
8662
# Check if laptop
8663
self.assertTrue(gpu_test.is_laptop)
8663
self.assertTrue(gpu_test.requires_offloading)
8664
8664
8665
8665
self.assertTrue(gpu_test.has_single_card)
8666
8666
8698
8698
['fglrx', 'fake'],
8699
8699
['mesa', 'fglrx'],
8700
8700
'mesa',
8701
is_laptop=True)
8701
requires_offloading=True)
8702
8702
8703
8703
# Check the variables
8704
8704
8705
8705
# Check if laptop
8706
self.assertTrue(gpu_test.is_laptop)
8706
self.assertTrue(gpu_test.requires_offloading)
8707
8707
8708
8708
self.assertTrue(gpu_test.has_single_card)
8709
8709
8741
8741
['fglrx', 'fake'],
8742
8742
['mesa', 'fglrx'],
8743
8743
'pxpress',
8744
is_laptop=True)
8744
requires_offloading=True)
8745
8745
8746
8746
# Check the variables
8747
8747
8748
8748
# Check if laptop
8749
self.assertTrue(gpu_test.is_laptop)
8749
self.assertTrue(gpu_test.requires_offloading)
8750
8750
8751
8751
self.assertTrue(gpu_test.has_single_card)
8752
8752
8784
8784
['fake_old', 'fake'],
8785
8785
['mesa', 'fglrx'],
8786
8786
'pxpress',
8787
is_laptop=True)
8787
requires_offloading=True)
8788
8788
8789
8789
# Check the variables
8790
8790
8791
8791
# Check if laptop
8792
self.assertTrue(gpu_test.is_laptop)
8792
self.assertTrue(gpu_test.requires_offloading)
8793
8793
8794
8794
self.assertTrue(gpu_test.has_single_card)
8795
8795
8827
8827
['fglrx', 'fake'],
8828
8828
['mesa', 'fglrx'],
8829
8829
'mesa',
8830
is_laptop=True)
8830
requires_offloading=True)
8831
8831
8832
8832
# Check the variables
8833
8833
8834
8834
# Check if laptop
8835
self.assertTrue(gpu_test.is_laptop)
8835
self.assertTrue(gpu_test.requires_offloading)
8836
8836
8837
8837
self.assertTrue(gpu_test.has_single_card)
8838
8838
8877
8877
# Check the variables
8878
8878
8879
8879
# Check if laptop
8880
self.assertFalse(gpu_test.is_laptop)
8880
self.assertFalse(gpu_test.requires_offloading)
8881
8881
8882
8882
self.assertFalse(gpu_test.has_single_card)
8883
8883
8917
8917
# Check the variables
8918
8918
8919
8919
# Check if laptop
8920
self.assertFalse(gpu_test.is_laptop)
8920
self.assertFalse(gpu_test.requires_offloading)
8921
8921
8922
8922
self.assertFalse(gpu_test.has_single_card)
8923
8923
8959
8959
['radeon', 'fake'],
8960
8960
['mesa'],
8961
8961
'mesa',
8962
is_laptop=True)
8962
requires_offloading=True)
8963
8963
8964
8964
# Check the variables
8965
8965
8966
8966
# Check if laptop
8967
self.assertTrue(gpu_test.is_laptop)
8967
self.assertTrue(gpu_test.requires_offloading)
8968
8968
8969
8969
self.assertFalse(gpu_test.has_single_card)
8970
8970
9000
9000
['fake_old', 'fake'],
9001
9001
['mesa'],
9002
9002
'mesa',
9003
is_laptop=True)
9003
requires_offloading=True)
9004
9004
9005
9005
# Check the variables
9006
9006
9007
9007
# Check if laptop
9008
self.assertTrue(gpu_test.is_laptop)
9008
self.assertTrue(gpu_test.requires_offloading)
9009
9009
9010
9010
self.assertFalse(gpu_test.has_single_card)
9011
9011
9048
9048
# Check the variables
9049
9049
9050
9050
# Check if laptop
9051
self.assertFalse(gpu_test.is_laptop)
9051
self.assertFalse(gpu_test.requires_offloading)
9052
9052
9053
9053
self.assertFalse(gpu_test.has_single_card)
9054
9054
9182
9182
# Check the variables
9183
9183
9184
9184
# Check if laptop
9185
self.assertFalse(gpu_test.is_laptop)
9185
self.assertFalse(gpu_test.requires_offloading)
9186
9186
9187
9187
self.assertFalse(gpu_test.has_single_card)
9188
9188
9223
9223
# Check the variables
9224
9224
9225
9225
# Check if laptop
9226
self.assertFalse(gpu_test.is_laptop)
9226
self.assertFalse(gpu_test.requires_offloading)
9227
9227
9228
9228
self.assertFalse(gpu_test.has_single_card)
9229
9229
9358
9358
# Check the variables
9359
9359
9360
9360
# Check if laptop
9361
self.assertFalse(gpu_test.is_laptop)
9361
self.assertFalse(gpu_test.requires_offloading)
9362
9362
9363
9363
self.assertFalse(gpu_test.has_single_card)
9364
9364
9494
9494
# Check the variables
9495
9495
9496
9496
# Check if laptop
9497
self.assertFalse(gpu_test.is_laptop)
9497
self.assertFalse(gpu_test.requires_offloading)
9498
9498
9499
9499
self.assertFalse(gpu_test.has_single_card)
9500
9500
9537
9537
# Check the variables
9538
9538
9539
9539
# Check if laptop
9540
self.assertFalse(gpu_test.is_laptop)
9540
self.assertFalse(gpu_test.requires_offloading)
9541
9541
9542
9542
self.assertFalse(gpu_test.has_single_card)
9543
9543
9580
9580
# Check the variables
9581
9581
9582
9582
# Check if laptop
9583
self.assertFalse(gpu_test.is_laptop)
9583
self.assertFalse(gpu_test.requires_offloading)
9584
9584
9585
9585
self.assertFalse(gpu_test.has_single_card)
9586
9586
9623
9623
# Check the variables
9624
9624
9625
9625
# Check if laptop
9626
self.assertFalse(gpu_test.is_laptop)
9626
self.assertFalse(gpu_test.requires_offloading)
9627
9627
9628
9628
self.assertFalse(gpu_test.has_single_card)
9629
9629
9666
9666
# Check the variables
9667
9667
9668
9668
# Check if laptop
9669
self.assertFalse(gpu_test.is_laptop)
9669
self.assertFalse(gpu_test.requires_offloading)
9670
9670
9671
9671
self.assertFalse(gpu_test.has_single_card)
9672
9672
9709
9709
# Check the variables
9710
9710
9711
9711
# Check if laptop
9712
self.assertFalse(gpu_test.is_laptop)
9712
self.assertFalse(gpu_test.requires_offloading)
9713
9713
9714
9714
self.assertFalse(gpu_test.has_single_card)
9715
9715
9752
9752
# Check the variables
9753
9753
9754
9754
# Check if laptop
9755
self.assertFalse(gpu_test.is_laptop)
9755
self.assertFalse(gpu_test.requires_offloading)
9756
9756
9757
9757
self.assertFalse(gpu_test.has_single_card)
9758
9758
9798
9798
# Check the variables
9799
9799
9800
9800
# Check if laptop
9801
self.assertFalse(gpu_test.is_laptop)
9801
self.assertFalse(gpu_test.requires_offloading)
9802
9802
9803
9803
self.assertFalse(gpu_test.has_single_card)
9804
9804
9839
9839
# Check the variables
9840
9840
9841
9841
# Check if laptop
9842
self.assertFalse(gpu_test.is_laptop)
9842
self.assertFalse(gpu_test.requires_offloading)
9843
9843
9844
9844
self.assertFalse(gpu_test.has_single_card)
9845
9845
9880
9880
# Check the variables
9881
9881
9882
9882
# Check if laptop
9883
self.assertFalse(gpu_test.is_laptop)
9883
self.assertFalse(gpu_test.requires_offloading)
9884
9884
9885
9885
self.assertFalse(gpu_test.has_single_card)
9886
9886
9923
9923
# Check the variables
9924
9924
9925
9925
# Check if laptop
9926
self.assertFalse(gpu_test.is_laptop)
9926
self.assertFalse(gpu_test.requires_offloading)
9927
9927
9928
9928
self.assertFalse(gpu_test.has_single_card)
9929
9929
9966
9966
# Check the variables
9967
9967
9968
9968
# Check if laptop
9969
self.assertFalse(gpu_test.is_laptop)
9969
self.assertFalse(gpu_test.requires_offloading)
9970
9970
9971
9971
self.assertFalse(gpu_test.has_single_card)
9972
9972
10009
10009
# Check the variables
10010
10010
10011
10011
# Check if laptop
10012
self.assertFalse(gpu_test.is_laptop)
10012
self.assertFalse(gpu_test.requires_offloading)
10013
10013
10014
10014
self.assertFalse(gpu_test.has_single_card)
10015
10015
10052
10052
# Check the variables
10053
10053
10054
10054
# Check if laptop
10055
self.assertFalse(gpu_test.is_laptop)
10055
self.assertFalse(gpu_test.requires_offloading)
10056
10056
10057
10057
self.assertFalse(gpu_test.has_single_card)
10058
10058
10174
10174
# Check the variables
10175
10175
10176
10176
# Check if laptop
10177
self.assertFalse(gpu_test.is_laptop)
10177
self.assertFalse(gpu_test.requires_offloading)
10178
10178
10179
10179
self.assertFalse(gpu_test.has_single_card)
10180
10180
10217
10217
# Check the variables
10218
10218
10219
10219
# Check if laptop
10220
self.assertFalse(gpu_test.is_laptop)
10220
self.assertFalse(gpu_test.requires_offloading)
10221
10221
10222
10222
self.assertFalse(gpu_test.has_single_card)
10223
10223
10260
10260
# Check the variables
10261
10261
10262
10262
# Check if laptop
10263
self.assertFalse(gpu_test.is_laptop)
10263
self.assertFalse(gpu_test.requires_offloading)
10264
10264
10265
10265
self.assertFalse(gpu_test.has_single_card)
10266
10266
10303
10303
# Check the variables
10304
10304
10305
10305
# Check if laptop
10306
self.assertFalse(gpu_test.is_laptop)
10306
self.assertFalse(gpu_test.requires_offloading)
10307
10307
10308
10308
self.assertFalse(gpu_test.has_single_card)
10309
10309
10389
10389
# no selected alternative
10390
10390
self.fake_alternative = ''
10391
10391
10392
self.exec_manager(is_laptop=False)
10392
self.exec_manager(requires_offloading=False)
10393
10393
10394
10394
# Return data
10395
10395
gpu_test = self.check_vars()
10433
10433
# no selected alternative
10434
10434
self.fake_alternative = ''
10435
10435
10436
self.exec_manager(is_laptop=False)
10436
self.exec_manager(requires_offloading=False)
10437
10437
10438
10438
# Return data
10439
10439
gpu_test = self.check_vars()
Loggerhead is a web-based interface for Breezy
Version: 2.0.1