Lines Matching refs:self
65 def __init__(self, bus): argument
66 self.loop = gobject.MainLoop()
67 self.signals = []
68 self.bus = bus
70 def __exit__(self, type, value, traceback): argument
71 for s in self.signals:
74 def add_signal(self, handler, interface, name, byte_arrays=False): argument
75 s = self.bus.add_signal_receiver(handler, dbus_interface=interface,
78 self.signals.append(s)
80 def timeout(self, *args): argument
82 self.loop.quit()
86 def __init__(self, dev, count, funcs, operation="Operation", argument
88 self._dev = dev
89 self._count = count
90 self._funcs = funcs
91 self._operation = operation
92 self._expected = expected
93 def __enter__(self): argument
94 cmd = "TEST_ALLOC_FAIL %d:%s" % (self._count, self._funcs)
95 if "OK" not in self._dev.request(cmd):
97 def __exit__(self, type, value, traceback): argument
99 raise Exception("%s succeeded during out-of-memory" % self._operation)
100 if type == dbus.exceptions.DBusException and self._expected in str(value):
102 if self._dev.request("GET_ALLOC_FAIL") != "0:%s" % self._funcs:
103 raise Exception("%s did not trigger allocation failure" % self._operation)
467 def __init__(self, bus): argument
468 TestDbus.__init__(self, bus)
469 self.signal_received = False
470 self.signal_received_deprecated = False
471 self.sets_done = False
473 def __enter__(self): argument
474 gobject.timeout_add(1, self.run_sets)
475 gobject.timeout_add(1000, self.timeout)
476 self.add_signal(self.propertiesChanged, WPAS_DBUS_IFACE_WPS,
478 self.add_signal(self.propertiesChanged2, dbus.PROPERTIES_IFACE,
480 self.loop.run()
481 return self
483 def propertiesChanged(self, properties): argument
486 self.signal_received_deprecated = True
487 if self.sets_done and self.signal_received:
488 self.loop.quit()
490 def propertiesChanged2(self, interface_name, changed_properties, argument
496 self.signal_received = True
497 if self.sets_done and self.signal_received_deprecated:
498 self.loop.quit()
500 def run_sets(self, *args): argument
515 self.dbus_sets_done = True
518 def success(self): argument
519 return self.signal_received and self.signal_received_deprecated
648 def __init__(self, bus, wps): argument
649 TestDbus.__init__(self, bus)
650 self.success_seen = False
651 self.credentials_received = False
652 self.wps = wps
654 def __enter__(self): argument
655 gobject.timeout_add(1, self.start_pbc)
656 gobject.timeout_add(15000, self.timeout)
657 self.add_signal(self.wpsEvent, WPAS_DBUS_IFACE_WPS, "Event")
658 self.add_signal(self.credentials, WPAS_DBUS_IFACE_WPS,
660 self.loop.run()
661 return self
663 def wpsEvent(self, name, args): argument
666 self.success_seen = True
667 if self.credentials_received:
668 self.loop.quit()
670 def credentials(self, args): argument
672 self.credentials_received = True
673 if self.success_seen:
674 self.loop.quit()
676 def start_pbc(self, *args): argument
678 self.wps.Start({'Role': 'enrollee', 'Type': 'pbc'})
681 def success(self): argument
682 return self.success_seen and self.credentials_received
709 def __init__(self, bus, wps): argument
710 TestDbus.__init__(self, bus)
711 self.overlap_seen = False
712 self.wps = wps
714 def __enter__(self): argument
715 gobject.timeout_add(1, self.start_pbc)
716 gobject.timeout_add(15000, self.timeout)
717 self.add_signal(self.wpsEvent, WPAS_DBUS_IFACE_WPS, "Event")
718 self.loop.run()
719 return self
721 def wpsEvent(self, name, args): argument
724 self.overlap_seen = True
725 self.loop.quit()
727 def start_pbc(self, *args): argument
729 self.wps.Start({'Role': 'enrollee', 'Type': 'pbc'})
732 def success(self): argument
733 return self.overlap_seen
763 def __init__(self, bus): argument
764 TestDbus.__init__(self, bus)
765 self.success_seen = False
766 self.credentials_received = False
768 def __enter__(self): argument
769 gobject.timeout_add(1, self.start_pin)
770 gobject.timeout_add(15000, self.timeout)
771 self.add_signal(self.wpsEvent, WPAS_DBUS_IFACE_WPS, "Event")
772 self.add_signal(self.credentials, WPAS_DBUS_IFACE_WPS,
774 self.loop.run()
775 return self
777 def wpsEvent(self, name, args): argument
780 self.success_seen = True
781 if self.credentials_received:
782 self.loop.quit()
784 def credentials(self, args): argument
786 self.credentials_received = True
787 if self.success_seen:
788 self.loop.quit()
790 def start_pin(self, *args): argument
797 def success(self): argument
798 return self.success_seen and self.credentials_received
823 def __init__(self, bus): argument
824 TestDbus.__init__(self, bus)
825 self.success_seen = False
826 self.failed = False
828 def __enter__(self): argument
829 gobject.timeout_add(1, self.start_pin)
830 gobject.timeout_add(15000, self.timeout)
831 self.add_signal(self.wpsEvent, WPAS_DBUS_IFACE_WPS, "Event")
832 self.add_signal(self.credentials, WPAS_DBUS_IFACE_WPS,
834 self.loop.run()
835 return self
837 def wpsEvent(self, name, args): argument
840 self.success_seen = True
841 if self.credentials_received:
842 self.loop.quit()
844 def credentials(self, args): argument
846 self.credentials_received = True
847 if self.success_seen:
848 self.loop.quit()
850 def start_pin(self, *args): argument
860 def success(self): argument
861 return self.success_seen and self.credentials_received
886 def __init__(self, bus): argument
887 TestDbus.__init__(self, bus)
888 self.success_seen = False
889 self.credentials_received = False
891 def __enter__(self): argument
892 gobject.timeout_add(1, self.start_pin)
893 gobject.timeout_add(15000, self.timeout)
894 self.add_signal(self.wpsEvent, WPAS_DBUS_IFACE_WPS, "Event")
895 self.add_signal(self.credentials, WPAS_DBUS_IFACE_WPS,
897 self.loop.run()
898 return self
900 def wpsEvent(self, name, args): argument
903 self.success_seen = True
904 if self.credentials_received:
905 self.loop.quit()
910 def credentials(self, args): argument
912 self.credentials_received = True
913 if self.success_seen:
914 self.loop.quit()
916 def start_pin(self, *args): argument
923 def success(self): argument
924 return self.success_seen and self.credentials_received
950 def __init__(self, bus): argument
951 TestDbus.__init__(self, bus)
952 self.credentials_received = False
954 def __enter__(self): argument
955 gobject.timeout_add(100, self.start_reg)
956 gobject.timeout_add(15000, self.timeout)
957 self.add_signal(self.wpsEvent, WPAS_DBUS_IFACE_WPS, "Event")
958 self.add_signal(self.credentials, WPAS_DBUS_IFACE_WPS,
960 self.loop.run()
961 return self
963 def wpsEvent(self, name, args): argument
966 def credentials(self, args): argument
968 self.credentials_received = True
969 self.loop.quit()
971 def start_reg(self, *args): argument
978 def success(self): argument
979 return self.credentials_received
1091 def __init__(self, bus): argument
1092 TestDbus.__init__(self, bus)
1093 self.scan_completed = 0
1094 self.bss_added = False
1095 self.fail_reason = None
1097 def __enter__(self): argument
1098 gobject.timeout_add(1, self.run_scan)
1099 gobject.timeout_add(15000, self.timeout)
1100 self.add_signal(self.scanDone, WPAS_DBUS_IFACE, "ScanDone")
1101 self.add_signal(self.bssAdded, WPAS_DBUS_IFACE, "BSSAdded")
1102 self.add_signal(self.bssRemoved, WPAS_DBUS_IFACE, "BSSRemoved")
1103 self.loop.run()
1104 return self
1106 def scanDone(self, success): argument
1108 self.scan_completed += 1
1109 if self.scan_completed == 1:
1113 elif self.scan_completed == 2:
1116 elif self.bss_added and self.scan_completed == 3:
1117 self.loop.quit()
1119 def bssAdded(self, bss, properties): argument
1124 self.fail_reason = "Unexpected WPS dictionary entry in non-WPS BSS"
1125 self.loop.quit()
1126 self.bss_added = True
1127 if self.scan_completed == 3:
1128 self.loop.quit()
1130 def bssRemoved(self, bss): argument
1133 def run_scan(self, *args): argument
1144 def success(self): argument
1145 return self.scan_completed == 3 and self.bss_added
1298 def __init__(self, bus): argument
1299 TestDbus.__init__(self, bus)
1300 self.network_added = False
1301 self.network_selected = False
1302 self.network_removed = False
1303 self.state = 0
1305 def __enter__(self): argument
1306 gobject.timeout_add(1, self.run_connect)
1307 gobject.timeout_add(15000, self.timeout)
1308 self.add_signal(self.networkAdded, WPAS_DBUS_IFACE, "NetworkAdded")
1309 self.add_signal(self.networkRemoved, WPAS_DBUS_IFACE,
1311 self.add_signal(self.networkSelected, WPAS_DBUS_IFACE,
1313 self.add_signal(self.propertiesChanged, WPAS_DBUS_IFACE,
1315 self.loop.run()
1316 return self
1318 def networkAdded(self, network, properties): argument
1321 self.network_added = True
1323 def networkRemoved(self, network): argument
1325 self.network_removed = True
1327 def networkSelected(self, network): argument
1329 self.network_selected = True
1331 def propertiesChanged(self, properties): argument
1334 if self.state == 0:
1335 self.state = 1
1337 elif self.state == 2:
1338 self.state = 3
1340 elif self.state == 4:
1341 self.state = 5
1343 elif self.state == 5:
1344 self.state = 6
1346 elif self.state == 7:
1347 self.state = 8
1351 self.state = -1
1353 iface.RemoveNetwork(self.netw)
1355 if self.state == 1:
1356 self.state = 2
1357 iface.SelectNetwork(self.netw)
1358 elif self.state == 3:
1359 self.state = 4
1361 elif self.state == 6:
1362 self.state = 7
1364 elif self.state == 8:
1365 self.state = 9
1366 self.loop.quit()
1368 def run_connect(self, *args): argument
1375 self.netw = iface.AddNetwork(args)
1376 iface.SelectNetwork(self.netw)
1379 def success(self): argument
1380 if not self.network_added or \
1381 not self.network_removed or \
1382 not self.network_selected:
1384 return self.state == 9
1399 def __init__(self, bus): argument
1400 TestDbus.__init__(self, bus)
1401 self.network_added = False
1402 self.network_selected = False
1403 self.network_removed = False
1404 self.state = 0
1406 def __enter__(self): argument
1407 gobject.timeout_add(1, self.run_connect)
1408 gobject.timeout_add(15000, self.timeout)
1409 self.add_signal(self.networkAdded, WPAS_DBUS_IFACE, "NetworkAdded")
1410 self.add_signal(self.networkRemoved, WPAS_DBUS_IFACE,
1412 self.add_signal(self.networkSelected, WPAS_DBUS_IFACE,
1414 self.add_signal(self.propertiesChanged, WPAS_DBUS_IFACE,
1416 self.loop.run()
1417 return self
1419 def networkAdded(self, network, properties): argument
1422 self.network_added = True
1424 def networkRemoved(self, network): argument
1426 self.network_removed = True
1428 def networkSelected(self, network): argument
1430 self.network_selected = True
1432 def propertiesChanged(self, properties): argument
1435 if self.state == 0:
1436 self.state = 1
1438 elif self.state == 2:
1439 self.state = 3
1441 elif self.state == 4:
1442 self.state = 5
1444 elif self.state == 5:
1445 self.state = 6
1447 elif self.state == 7:
1448 self.state = 8
1452 self.state = -1
1456 if self.state == 1:
1457 self.state = 2
1458 iface.SelectNetwork(self.netw)
1459 elif self.state == 3:
1460 self.state = 4
1462 elif self.state == 6:
1463 self.state = 7
1465 elif self.state == 8:
1466 self.state = 9
1467 self.loop.quit()
1469 def run_connect(self, *args): argument
1475 self.netw = iface.AddNetwork(args)
1476 iface.SelectNetwork(self.netw)
1479 def success(self): argument
1480 if not self.network_added or \
1481 not self.network_removed or \
1482 not self.network_selected:
1484 return self.state == 9
1501 def __init__(self, bus): argument
1502 TestDbus.__init__(self, bus)
1503 self.connected = False
1505 def __enter__(self): argument
1506 gobject.timeout_add(1, self.run_connect)
1507 gobject.timeout_add(15000, self.timeout)
1508 self.add_signal(self.propertiesChanged, WPAS_DBUS_IFACE,
1510 self.add_signal(self.networkRequest, WPAS_DBUS_IFACE,
1512 self.loop.run()
1513 return self
1515 def propertiesChanged(self, properties): argument
1518 self.connected = True
1519 self.loop.quit()
1521 def networkRequest(self, path, field, txt): argument
1526 def run_connect(self, *args): argument
1533 self.netw = iface.AddNetwork(args)
1534 iface.SelectNetwork(self.netw)
1537 def success(self): argument
1538 return self.connected
1558 def __init__(self, bus): argument
1559 TestDbus.__init__(self, bus)
1560 self.network_added = False
1561 self.network_selected = False
1562 self.network_removed = False
1563 self.state = 0
1565 def __enter__(self): argument
1566 gobject.timeout_add(1, self.run_connect)
1567 gobject.timeout_add(1500, self.timeout)
1568 self.add_signal(self.networkAdded, WPAS_DBUS_IFACE, "NetworkAdded")
1569 self.add_signal(self.networkRemoved, WPAS_DBUS_IFACE,
1571 self.add_signal(self.networkSelected, WPAS_DBUS_IFACE,
1573 self.add_signal(self.propertiesChanged, WPAS_DBUS_IFACE,
1575 self.loop.run()
1576 return self
1578 def networkAdded(self, network, properties): argument
1581 self.network_added = True
1583 def networkRemoved(self, network): argument
1585 self.network_removed = True
1587 def networkSelected(self, network): argument
1589 self.network_selected = True
1591 def propertiesChanged(self, properties): argument
1594 if self.state == 0:
1595 self.state = 1
1597 elif self.state == 2:
1598 self.state = 3
1600 elif self.state == 4:
1601 self.state = 5
1603 elif self.state == 5:
1604 self.state = 6
1608 self.state = -1
1610 iface.RemoveNetwork(self.netw)
1612 if self.state == 1:
1613 self.state = 2
1614 iface.SelectNetwork(self.netw)
1615 elif self.state == 3:
1616 self.state = 4
1618 elif self.state == 6:
1619 self.state = 7
1620 self.loop.quit()
1622 def run_connect(self, *args): argument
1630 self.netw = iface.AddNetwork(args)
1633 self.loop.quit()
1636 iface.SelectNetwork(self.netw)
1639 self.loop.quit()
1643 def success(self): argument
1644 if not self.network_added or \
1645 not self.network_removed or \
1646 not self.network_selected:
1648 return self.state == 7
1718 def __init__(self, bus): argument
1719 TestDbus.__init__(self, bus)
1720 self.certification_received = False
1721 self.eap_status = False
1722 self.state = 0
1724 def __enter__(self): argument
1725 gobject.timeout_add(1, self.run_connect)
1726 gobject.timeout_add(15000, self.timeout)
1727 self.add_signal(self.propertiesChanged, WPAS_DBUS_IFACE,
1729 self.add_signal(self.certification, WPAS_DBUS_IFACE,
1731 self.add_signal(self.networkRequest, WPAS_DBUS_IFACE,
1733 self.add_signal(self.eap, WPAS_DBUS_IFACE, "EAP")
1734 self.loop.run()
1735 return self
1737 def propertiesChanged(self, properties): argument
1740 if self.state == 0:
1741 self.state = 1
1744 net_obj = bus.get_object(WPAS_DBUS_SERVICE, self.netw)
1746 self.server_dnsname},
1750 elif self.state == 2:
1751 self.state = 3
1754 net_obj = bus.get_object(WPAS_DBUS_SERVICE, self.netw)
1756 self.server_dnsname + "FOO"},
1761 if self.state == 1:
1762 self.state = 2
1764 iface.SelectNetwork(self.netw)
1765 if self.state == 3:
1766 self.state = 4
1767 iface.SelectNetwork(self.netw)
1769 def certification(self, args): argument
1771 self.certification_received = True
1780 self.server_dnsname = dnsname
1782 def eap(self, status, parameter): argument
1785 self.eap_status = True
1786 …if self.state == 4 and status == 'remote certificate verification' and parameter == 'AltSubject mi…
1787 self.state = 5
1788 self.loop.quit()
1790 def networkRequest(self, path, field, txt): argument
1795 def run_connect(self, *args): argument
1807 self.netw = iface.AddNetwork(args)
1808 iface.SelectNetwork(self.netw)
1811 def success(self): argument
1812 if not self.eap_status or not self.certification_received:
1814 return self.state == 5
2194 def __init__(self, bus): argument
2195 TestDbus.__init__(self, bus)
2196 self.blob_added = False
2197 self.blob_removed = False
2199 def __enter__(self): argument
2200 gobject.timeout_add(1, self.run_blob)
2201 gobject.timeout_add(15000, self.timeout)
2202 self.add_signal(self.blobAdded, WPAS_DBUS_IFACE, "BlobAdded")
2203 self.add_signal(self.blobRemoved, WPAS_DBUS_IFACE, "BlobRemoved")
2204 self.loop.run()
2205 return self
2207 def blobAdded(self, blobName): argument
2210 self.blob_added = True
2212 def blobRemoved(self, blobName): argument
2215 self.blob_removed = True
2216 self.loop.quit()
2218 def run_blob(self, *args): argument
2224 def success(self): argument
2225 return self.blob_added and self.blob_removed
2342 def __init__(self, bus): argument
2343 TestDbus.__init__(self, bus)
2344 self.tdls_setup = False
2345 self.tdls_teardown = False
2347 def __enter__(self): argument
2348 gobject.timeout_add(1, self.run_tdls)
2349 gobject.timeout_add(15000, self.timeout)
2350 self.add_signal(self.propertiesChanged, WPAS_DBUS_IFACE,
2352 self.loop.run()
2353 return self
2355 def propertiesChanged(self, properties): argument
2358 def run_tdls(self, *args): argument
2361 gobject.timeout_add(100, self.run_tdls2)
2364 def run_tdls2(self, *args): argument
2367 gobject.timeout_add(500, self.run_tdls3)
2370 def run_tdls3(self, *args): argument
2374 self.tdls_setup = True
2378 gobject.timeout_add(200, self.run_tdls4)
2381 def run_tdls4(self, *args): argument
2385 self.tdls_teardown = True
2388 self.loop.quit()
2391 def success(self): argument
2392 return self.tdls_setup and self.tdls_teardown
2413 def __init__(self, bus): argument
2414 TestDbus.__init__(self, bus)
2415 self.tdls_setup = False
2416 self.tdls_done = False
2418 def __enter__(self): argument
2419 gobject.timeout_add(1, self.run_tdls)
2420 gobject.timeout_add(15000, self.timeout)
2421 self.add_signal(self.propertiesChanged, WPAS_DBUS_IFACE,
2423 self.loop.run()
2424 return self
2426 def propertiesChanged(self, properties): argument
2429 def run_tdls(self, *args): argument
2432 gobject.timeout_add(100, self.run_tdls2)
2435 def run_tdls2(self, *args): argument
2438 gobject.timeout_add(500, self.run_tdls3)
2441 def run_tdls3(self, *args): argument
2445 self.tdls_setup = True
2498 gobject.timeout_add(200, self.run_tdls4)
2501 def run_tdls4(self, *args): argument
2504 self.tdls_done = True
2505 self.loop.quit()
2508 def success(self): argument
2509 return self.tdls_setup and self.tdls_done
2809 def __init__(self, bus): argument
2810 TestDbus.__init__(self, bus)
2811 self.reported = False
2813 def __enter__(self): argument
2814 gobject.timeout_add(1, self.run_test)
2815 gobject.timeout_add(15000, self.timeout)
2816 self.add_signal(self.groupStarted, WPAS_DBUS_IFACE_P2PDEVICE,
2818 self.add_signal(self.probeRequest, WPAS_DBUS_IFACE, "ProbeRequest",
2820 self.loop.run()
2821 return self
2823 def groupStarted(self, properties): argument
2827 self.iface = dbus.Interface(g_if_obj, WPAS_DBUS_IFACE)
2828 self.iface.SubscribeProbeReq()
2829 self.group_p2p = dbus.Interface(g_if_obj, WPAS_DBUS_IFACE_P2PDEVICE)
2831 def probeRequest(self, args): argument
2833 self.reported = True
2834 self.loop.quit()
2836 def run_test(self, *args): argument
2843 def success(self): argument
2844 return self.reported
3212 def __init__(self, bus): argument
3213 TestDbus.__init__(self, bus)
3214 self.found = False
3215 self.found2 = False
3216 self.found_prop = False
3217 self.lost = False
3218 self.find_stopped = False
3220 def __enter__(self): argument
3221 gobject.timeout_add(1, self.run_test)
3222 gobject.timeout_add(15000, self.timeout)
3223 self.add_signal(self.deviceFound, WPAS_DBUS_IFACE_P2PDEVICE,
3225 self.add_signal(self.deviceFoundProperties,
3227 self.add_signal(self.deviceLost, WPAS_DBUS_IFACE_P2PDEVICE,
3229 self.add_signal(self.provisionDiscoveryResponseEnterPin,
3232 self.add_signal(self.findStopped, WPAS_DBUS_IFACE_P2PDEVICE,
3234 self.loop.run()
3235 return self
3237 def deviceFound(self, path): argument
3276 self.found = True
3282 self.found2 = True
3286 if self.found and self.found2:
3291 def deviceLost(self, path): argument
3293 if not self.found or not self.found2:
3299 self.lost = True
3306 self.loop.quit()
3308 def deviceFoundProperties(self, path, properties): argument
3312 self.found_prop = True
3314 def provisionDiscoveryResponseEnterPin(self, peer_object): argument
3318 def findStopped(self): argument
3320 self.find_stopped = True
3322 def run_test(self, *args): argument
3328 def success(self): argument
3329 return self.found and self.lost and self.found2 and self.find_stopped
3366 def __init__(self, bus): argument
3367 TestDbus.__init__(self, bus)
3368 self.found = False
3370 def __enter__(self): argument
3371 gobject.timeout_add(1, self.run_test)
3372 gobject.timeout_add(5000, self.timeout)
3373 self.add_signal(self.deviceFound, WPAS_DBUS_IFACE_P2PDEVICE,
3375 self.loop.run()
3376 return self
3378 def deviceFound(self, path): argument
3380 self.found = True
3381 self.loop.quit()
3383 def run_test(self, *args): argument
3388 def success(self): argument
3389 return self.found
3576 def __init__(self, bus): argument
3577 TestDbus.__init__(self, bus)
3578 self.done = False
3580 def __enter__(self): argument
3581 gobject.timeout_add(1, self.run_test)
3582 gobject.timeout_add(15000, self.timeout)
3583 self.add_signal(self.deviceFound, WPAS_DBUS_IFACE_P2PDEVICE,
3585 self.add_signal(self.serviceDiscoveryResponse,
3588 self.loop.run()
3589 return self
3591 def deviceFound(self, path): argument
3597 def serviceDiscoveryResponse(self, sd_request): argument
3599 self.done = True
3600 self.loop.quit()
3602 def run_test(self, *args): argument
3608 def success(self): argument
3609 return self.done
3637 def __init__(self, bus): argument
3638 TestDbus.__init__(self, bus)
3639 self.sd = False
3641 def __enter__(self): argument
3642 gobject.timeout_add(1, self.run_test)
3643 gobject.timeout_add(15000, self.timeout)
3644 self.add_signal(self.deviceFound, WPAS_DBUS_IFACE_P2PDEVICE,
3646 self.add_signal(self.serviceDiscoveryRequest,
3649 self.loop.run()
3650 return self
3652 def deviceFound(self, path): argument
3655 def serviceDiscoveryRequest(self, sd_request): argument
3657 self.sd = True
3663 self.loop.quit()
3665 def run_test(self, *args): argument
3672 def success(self): argument
3673 return self.sd
3699 def __init__(self, bus): argument
3700 TestDbus.__init__(self, bus)
3701 self.first = True
3702 self.waiting_end = False
3703 self.exceptions = False
3704 self.deauthorized = False
3705 self.done = False
3707 def __enter__(self): argument
3708 gobject.timeout_add(1, self.run_test)
3709 gobject.timeout_add(15000, self.timeout)
3710 self.add_signal(self.deviceFound, WPAS_DBUS_IFACE_P2PDEVICE,
3712 self.add_signal(self.groupStarted, WPAS_DBUS_IFACE_P2PDEVICE,
3714 self.add_signal(self.groupFinished, WPAS_DBUS_IFACE_P2PDEVICE,
3716 self.add_signal(self.persistentGroupAdded,
3719 self.add_signal(self.persistentGroupRemoved,
3722 self.add_signal(self.provisionDiscoveryRequestDisplayPin,
3725 self.add_signal(self.staAuthorized, WPAS_DBUS_IFACE,
3727 self.add_signal(self.staDeauthorized, WPAS_DBUS_IFACE,
3729 self.loop.run()
3730 return self
3732 def groupStarted(self, properties): argument
3734 self.group = properties['group_object']
3735 self.g_if_obj = bus.get_object(WPAS_DBUS_SERVICE,
3737 role = self.g_if_obj.Get(WPAS_DBUS_IFACE_P2PDEVICE, "Role",
3740 self.exceptions = True
3742 group = self.g_if_obj.Get(WPAS_DBUS_IFACE_P2PDEVICE, "Group",
3745 self.exceptions = True
3747 go = self.g_if_obj.Get(WPAS_DBUS_IFACE_P2PDEVICE, "PeerGO",
3750 self.exceptions = True
3752 if self.first:
3753 self.first = False
3755 group_p2p = dbus.Interface(self.g_if_obj,
3761 def groupFinished(self, properties): argument
3763 if self.waiting_end:
3765 p2p.RemovePersistentGroup(self.persistent)
3769 self.persistent,
3773 def persistentGroupAdded(self, path, properties): argument
3775 self.persistent = path
3777 def persistentGroupRemoved(self, path): argument
3779 self.done = True
3780 self.loop.quit()
3782 def deviceFound(self, path): argument
3785 self.peer = peer_obj.GetAll(WPAS_DBUS_P2P_PEER,
3788 logger.debug('peer properties: ' + str(self.peer))
3790 def provisionDiscoveryRequestDisplayPin(self, peer_object, pin): argument
3792 self.peer_path = peer_object
3797 'P2PDeviceAddress': self.peer['DeviceAddress'],
3798 'Bssid': self.peer['DeviceAddress'],
3800 wps = dbus.Interface(self.g_if_obj, WPAS_DBUS_IFACE_WPS)
3803 self.exceptions = True
3807 self.exceptions = True
3810 'P2PDeviceAddress': self.peer['DeviceAddress'],
3816 def staAuthorized(self, name): argument
3818 peer_obj = bus.get_object(WPAS_DBUS_SERVICE, self.peer_path)
3824 self.exceptions = True
3826 if res['Groups'][0] != self.group:
3827 self.exceptions = True
3830 g_obj = bus.get_object(WPAS_DBUS_SERVICE, self.group)
3836 self.exceptions = True
3854 self.exceptions = True
3857 self.exceptions = True
3869 self.exceptions = True
3872 self.exceptions = True
3880 self.exceptions = True
3884 self.exceptions = True
3891 self.exceptions = True
3895 self.exceptions = True
3902 self.exceptions = True
3906 self.exceptions = True
3913 self.exceptions = True
3917 self.exceptions = True
3920 p2p.RemoveClient({'peer': self.peer_path})
3922 self.waiting_end = True
3927 group_p2p = dbus.Interface(self.g_if_obj,
3931 def staDeauthorized(self, name): argument
3933 self.deauthorized = True
3935 def run_test(self, *args): argument
3943 def success(self): argument
3944 return self.done and self.deauthorized and not self.exceptions
3960 def __init__(self, bus): argument
3961 TestDbus.__init__(self, bus)
3962 self.first = True
3963 self.waiting_end = False
3964 self.done = False
3966 def __enter__(self): argument
3967 gobject.timeout_add(1, self.run_test)
3968 gobject.timeout_add(15000, self.timeout)
3969 self.add_signal(self.deviceFound, WPAS_DBUS_IFACE_P2PDEVICE,
3971 self.add_signal(self.groupStarted, WPAS_DBUS_IFACE_P2PDEVICE,
3973 self.add_signal(self.groupFinished, WPAS_DBUS_IFACE_P2PDEVICE,
3975 self.add_signal(self.provisionDiscoveryPBCRequest,
3978 self.add_signal(self.staAuthorized, WPAS_DBUS_IFACE,
3980 self.loop.run()
3981 return self
3983 def groupStarted(self, properties): argument
3985 self.group = properties['group_object']
3986 self.g_if_obj = bus.get_object(WPAS_DBUS_SERVICE,
3990 def groupFinished(self, properties): argument
3992 self.done = True
3993 self.loop.quit()
3995 def deviceFound(self, path): argument
3998 self.peer = peer_obj.GetAll(WPAS_DBUS_P2P_PEER,
4001 logger.debug('peer properties: ' + str(self.peer))
4003 def provisionDiscoveryPBCRequest(self, peer_object): argument
4005 self.peer_path = peer_object
4009 'P2PDeviceAddress': self.peer['DeviceAddress'],
4012 wps = dbus.Interface(self.g_if_obj, WPAS_DBUS_IFACE_WPS)
4015 def staAuthorized(self, name): argument
4020 group_p2p = dbus.Interface(self.g_if_obj,
4024 def run_test(self, *args): argument
4030 def success(self): argument
4031 return self.done
4048 def __init__(self, bus): argument
4049 TestDbus.__init__(self, bus)
4050 self.done = False
4052 def __enter__(self): argument
4053 gobject.timeout_add(1, self.run_test)
4054 gobject.timeout_add(15000, self.timeout)
4055 self.add_signal(self.groupStarted, WPAS_DBUS_IFACE_P2PDEVICE,
4057 self.add_signal(self.groupFinished, WPAS_DBUS_IFACE_P2PDEVICE,
4059 self.add_signal(self.staAuthorized, WPAS_DBUS_IFACE,
4061 self.loop.run()
4062 return self
4064 def groupStarted(self, properties): argument
4083 self.group_p2p = dbus.Interface(g_if_obj, WPAS_DBUS_IFACE_P2PDEVICE)
4085 def groupFinished(self, properties): argument
4087 self.done = True
4088 self.loop.quit()
4090 def staAuthorized(self, name): argument
4093 self.group_p2p.Disconnect()
4095 def run_test(self, *args): argument
4101 def success(self): argument
4102 return self.done
4119 def __init__(self, bus): argument
4120 TestDbus.__init__(self, bus)
4121 self.done = False
4122 self.peer = None
4123 self.go = None
4125 def __enter__(self): argument
4126 gobject.timeout_add(1, self.run_test)
4127 gobject.timeout_add(15000, self.timeout)
4128 self.add_signal(self.deviceFound, WPAS_DBUS_IFACE_P2PDEVICE,
4130 self.add_signal(self.groupStarted, WPAS_DBUS_IFACE_P2PDEVICE,
4132 self.add_signal(self.groupFinished, WPAS_DBUS_IFACE_P2PDEVICE,
4134 self.add_signal(self.invitationResult, WPAS_DBUS_IFACE_P2PDEVICE,
4136 self.loop.run()
4137 return self
4139 def deviceFound(self, path): argument
4147 self.peer = path
4149 self.go = path
4150 if self.peer and self.go:
4153 args = {'peer': self.go,
4161 def groupStarted(self, properties): argument
4175 if go != self.go:
4200 args = {'peer': self.peer}
4203 def groupFinished(self, properties): argument
4205 self.done = True
4206 self.loop.quit()
4208 def invitationResult(self, result): argument
4214 def run_test(self, *args): argument
4219 def success(self): argument
4220 return self.done
4243 def __init__(self, bus): argument
4244 TestDbus.__init__(self, bus)
4245 self.done = False
4247 def __enter__(self): argument
4248 gobject.timeout_add(1, self.run_test)
4249 gobject.timeout_add(15000, self.timeout)
4250 self.add_signal(self.invitationReceived, WPAS_DBUS_IFACE_P2PDEVICE,
4252 self.loop.run()
4253 return self
4255 def invitationReceived(self, result): argument
4257 self.done = True
4258 self.loop.quit()
4260 def run_test(self, *args): argument
4266 def success(self): argument
4267 return self.done
4378 def __init__(self, bus): argument
4379 TestDbus.__init__(self, bus)
4381 def __enter__(self): argument
4382 gobject.timeout_add(1, self.run_test)
4383 gobject.timeout_add(15000, self.timeout)
4384 self.add_signal(self.groupStarted, WPAS_DBUS_IFACE_P2PDEVICE,
4386 self.add_signal(self.groupFinished, WPAS_DBUS_IFACE_P2PDEVICE,
4388 self.add_signal(self.persistentGroupAdded,
4391 self.loop.run()
4392 return self
4394 def groupStarted(self, properties): argument
4401 def groupFinished(self, properties): argument
4403 self.loop.quit()
4405 def persistentGroupAdded(self, path, properties): argument
4407 self.persistent = path
4409 def run_test(self, *args): argument
4417 def success(self): argument
4473 def __init__(self, bus): argument
4474 TestDbus.__init__(self, bus)
4475 self.first = True
4476 self.waiting_end = False
4477 self.done = False
4478 self.invited = False
4480 def __enter__(self): argument
4481 gobject.timeout_add(1, self.run_test)
4482 gobject.timeout_add(15000, self.timeout)
4483 self.add_signal(self.deviceFound, WPAS_DBUS_IFACE_P2PDEVICE,
4485 self.add_signal(self.groupStarted, WPAS_DBUS_IFACE_P2PDEVICE,
4487 self.add_signal(self.groupFinished, WPAS_DBUS_IFACE_P2PDEVICE,
4489 self.add_signal(self.persistentGroupAdded,
4492 self.add_signal(self.provisionDiscoveryRequestDisplayPin,
4495 self.add_signal(self.staAuthorized, WPAS_DBUS_IFACE,
4497 self.loop.run()
4498 return self
4500 def groupStarted(self, properties): argument
4502 self.g_if_obj = bus.get_object(WPAS_DBUS_SERVICE,
4504 if not self.invited:
4514 def groupFinished(self, properties): argument
4516 if self.invited:
4517 self.done = True
4518 self.loop.quit()
4524 'peer': self.peer_path}
4532 args = {'persistent_group_object': self.persistent,
4533 'peer': self.peer_path}
4535 self.invited = True
4537 self.sta_group_ev = dev[1].wait_global_event(["P2P-GROUP-STARTED"],
4539 if self.sta_group_ev is None:
4542 def persistentGroupAdded(self, path, properties): argument
4544 self.persistent = path
4546 def deviceFound(self, path): argument
4549 self.peer = peer_obj.GetAll(WPAS_DBUS_P2P_PEER,
4553 def provisionDiscoveryRequestDisplayPin(self, peer_object, pin): argument
4555 self.peer_path = peer_object
4559 'P2PDeviceAddress': self.peer['DeviceAddress'],
4560 'Bssid': self.peer['DeviceAddress'],
4564 wps = dbus.Interface(self.g_if_obj, WPAS_DBUS_IFACE_WPS)
4566 self.sta_group_ev = dev[1].wait_global_event(["P2P-GROUP-STARTED"],
4568 if self.sta_group_ev is None:
4571 def staAuthorized(self, name): argument
4573 dev[1].group_form_result(self.sta_group_ev)
4578 group_p2p = dbus.Interface(self.g_if_obj, WPAS_DBUS_IFACE_P2PDEVICE)
4581 def run_test(self, *args): argument
4589 def success(self): argument
4590 return self.done
4603 def __init__(self, bus): argument
4604 TestDbus.__init__(self, bus)
4605 self.done = False
4607 def __enter__(self): argument
4608 gobject.timeout_add(1, self.run_test)
4609 gobject.timeout_add(15000, self.timeout)
4610 self.add_signal(self.deviceFound, WPAS_DBUS_IFACE_P2PDEVICE,
4612 self.add_signal(self.goNegotiationRequest,
4616 self.add_signal(self.goNegotiationSuccess,
4620 self.add_signal(self.groupStarted, WPAS_DBUS_IFACE_P2PDEVICE,
4622 self.add_signal(self.groupFinished, WPAS_DBUS_IFACE_P2PDEVICE,
4624 self.loop.run()
4625 return self
4627 def deviceFound(self, path): argument
4630 def goNegotiationRequest(self, path, dev_passwd_id, go_intent=0): argument
4647 def goNegotiationSuccess(self, properties): argument
4650 def groupStarted(self, properties): argument
4657 def groupFinished(self, properties): argument
4659 self.done = True
4660 self.loop.quit()
4662 def run_test(self, *args): argument
4670 def success(self): argument
4671 return self.done
4685 def __init__(self, bus): argument
4686 TestDbus.__init__(self, bus)
4687 self.done = False
4688 self.peer_joined = False
4689 self.peer_disconnected = False
4691 def __enter__(self): argument
4692 gobject.timeout_add(1, self.run_test)
4693 gobject.timeout_add(15000, self.timeout)
4694 self.add_signal(self.deviceFound, WPAS_DBUS_IFACE_P2PDEVICE,
4696 self.add_signal(self.goNegotiationSuccess,
4700 self.add_signal(self.groupStarted, WPAS_DBUS_IFACE_P2PDEVICE,
4702 self.add_signal(self.groupFinished, WPAS_DBUS_IFACE_P2PDEVICE,
4704 self.add_signal(self.staDeauthorized, WPAS_DBUS_IFACE,
4706 self.add_signal(self.peerJoined, WPAS_DBUS_GROUP,
4708 self.add_signal(self.peerDisconnected, WPAS_DBUS_GROUP,
4710 self.loop.run()
4711 return self
4713 def deviceFound(self, path): argument
4734 self.sta_group_ev = ev
4736 def goNegotiationSuccess(self, properties): argument
4739 def groupStarted(self, properties): argument
4741 self.g_if_obj = bus.get_object(WPAS_DBUS_SERVICE,
4743 dev[1].group_form_result(self.sta_group_ev)
4746 def staDeauthorized(self, name): argument
4748 group_p2p = dbus.Interface(self.g_if_obj, WPAS_DBUS_IFACE_P2PDEVICE)
4751 def peerJoined(self, peer): argument
4753 self.peer_joined = True
4755 def peerDisconnected(self, peer): argument
4757 self.peer_disconnected = True
4759 def groupFinished(self, properties): argument
4761 self.done = True
4762 self.loop.quit()
4764 def run_test(self, *args): argument
4769 def success(self): argument
4770 return self.done and self.peer_joined and self.peer_disconnected
4784 def __init__(self, bus): argument
4785 TestDbus.__init__(self, bus)
4786 self.done = False
4787 self.peer_group_added = False
4788 self.peer_group_removed = False
4790 def __enter__(self): argument
4791 gobject.timeout_add(1, self.run_test)
4792 gobject.timeout_add(15000, self.timeout)
4793 self.add_signal(self.deviceFound, WPAS_DBUS_IFACE_P2PDEVICE,
4795 self.add_signal(self.goNegotiationSuccess,
4799 self.add_signal(self.groupStarted, WPAS_DBUS_IFACE_P2PDEVICE,
4801 self.add_signal(self.groupFinished, WPAS_DBUS_IFACE_P2PDEVICE,
4803 self.add_signal(self.propertiesChanged, dbus.PROPERTIES_IFACE,
4805 self.loop.run()
4806 return self
4808 def deviceFound(self, path): argument
4821 self.sta_group_ev = ev
4823 def goNegotiationSuccess(self, properties): argument
4826 def groupStarted(self, properties): argument
4832 dev[1].group_form_result(self.sta_group_ev)
4835 def groupFinished(self, properties): argument
4837 self.done = True
4839 def propertiesChanged(self, interface_name, changed_properties, argument
4847 self.peer_group_added = True
4849 if not self.peer_group_added:
4854 self.peer_group_removed = True
4855 self.loop.quit()
4857 def run_test(self, *args): argument
4862 def success(self): argument
4863 return self.done and self.peer_group_added and self.peer_group_removed
4877 def __init__(self, bus): argument
4878 TestDbus.__init__(self, bus)
4879 self.done = False
4880 self.peer_group_added = False
4881 self.peer_group_removed = False
4883 def __enter__(self): argument
4884 gobject.timeout_add(1, self.run_test)
4885 gobject.timeout_add(15000, self.timeout)
4886 self.add_signal(self.deviceFound, WPAS_DBUS_IFACE_P2PDEVICE,
4888 self.add_signal(self.goNegotiationSuccess,
4892 self.add_signal(self.groupStarted, WPAS_DBUS_IFACE_P2PDEVICE,
4894 self.add_signal(self.groupFinished, WPAS_DBUS_IFACE_P2PDEVICE,
4896 self.add_signal(self.propertiesChanged, dbus.PROPERTIES_IFACE,
4898 self.loop.run()
4899 return self
4901 def deviceFound(self, path): argument
4914 self.sta_group_ev = ev
4916 def goNegotiationSuccess(self, properties): argument
4919 def groupStarted(self, properties): argument
4923 dev[1].group_form_result(self.sta_group_ev)
4926 def groupFinished(self, properties): argument
4928 self.done = True
4930 def propertiesChanged(self, interface_name, changed_properties, argument
4938 self.peer_group_added = True
4939 if len(changed_properties["Groups"]) == 0 and self.peer_group_added:
4940 self.peer_group_removed = True
4941 self.loop.quit()
4943 def run_test(self, *args): argument
4948 def success(self): argument
4949 return self.done and self.peer_group_added and self.peer_group_removed
4970 def __init__(self, bus): argument
4971 TestDbus.__init__(self, bus)
4972 self.done = False
4973 self.group_started = False
4974 self.peer_group_added = False
4975 self.peer_group_removed = False
4977 def __enter__(self): argument
4978 gobject.timeout_add(1, self.run_test)
4979 gobject.timeout_add(15000, self.timeout)
4980 self.add_signal(self.deviceFound, WPAS_DBUS_IFACE_P2PDEVICE,
4982 self.add_signal(self.goNegotiationSuccess,
4986 self.add_signal(self.groupStarted, WPAS_DBUS_IFACE_P2PDEVICE,
4988 self.add_signal(self.groupFinished, WPAS_DBUS_IFACE_P2PDEVICE,
4990 self.add_signal(self.propertiesChanged, dbus.PROPERTIES_IFACE,
4992 self.loop.run()
4993 return self
4995 def deviceFound(self, path): argument
5008 self.sta_group_ev = ev
5010 def goNegotiationSuccess(self, properties): argument
5013 def groupStarted(self, properties): argument
5015 self.group_started = True
5018 dev[1].group_form_result(self.sta_group_ev)
5026 def groupFinished(self, properties): argument
5028 self.done = True
5030 def propertiesChanged(self, interface_name, changed_properties, argument
5035 if not self.group_started:
5040 self.peer_group_added = True
5042 self.peer_group_removed = True
5043 self.loop.quit()
5045 def run_test(self, *args): argument
5050 def success(self): argument
5051 return self.done and self.peer_group_added and self.peer_group_removed
5064 def __init__(self, bus): argument
5065 TestDbus.__init__(self, bus)
5066 self.wps_failed = False
5067 self.formation_failure = False
5069 def __enter__(self): argument
5070 gobject.timeout_add(1, self.run_test)
5071 gobject.timeout_add(15000, self.timeout)
5072 self.add_signal(self.goNegotiationRequest,
5076 self.add_signal(self.goNegotiationSuccess,
5080 self.add_signal(self.groupStarted, WPAS_DBUS_IFACE_P2PDEVICE,
5082 self.add_signal(self.wpsFailed, WPAS_DBUS_IFACE_P2PDEVICE,
5084 self.add_signal(self.groupFormationFailure,
5087 self.loop.run()
5088 return self
5090 def goNegotiationRequest(self, path, dev_passwd_id, go_intent=0): argument
5098 def goNegotiationSuccess(self, properties): argument
5101 def groupStarted(self, properties): argument
5105 def wpsFailed(self, name, args): argument
5107 self.wps_failed = True
5108 if self.formation_failure:
5109 self.loop.quit()
5111 def groupFormationFailure(self, reason): argument
5113 self.formation_failure = True
5114 if self.wps_failed:
5115 self.loop.quit()
5117 def run_test(self, *args): argument
5125 def success(self): argument
5126 return self.wps_failed and self.formation_failure
5144 def __init__(self, bus): argument
5145 TestDbus.__init__(self, bus)
5146 self.done = False
5147 self.peer = None
5148 self.go = None
5149 self.group1 = None
5150 self.group2 = None
5151 self.groups_removed = False
5153 def __enter__(self): argument
5154 gobject.timeout_add(1, self.run_test)
5155 gobject.timeout_add(15000, self.timeout)
5156 self.add_signal(self.propertiesChanged, dbus.PROPERTIES_IFACE,
5158 self.add_signal(self.deviceFound, WPAS_DBUS_IFACE_P2PDEVICE,
5160 self.add_signal(self.groupStarted, WPAS_DBUS_IFACE_P2PDEVICE,
5162 self.add_signal(self.groupFinished, WPAS_DBUS_IFACE_P2PDEVICE,
5164 self.add_signal(self.peerJoined, WPAS_DBUS_GROUP,
5166 self.loop.run()
5167 return self
5169 def propertiesChanged(self, interface_name, changed_properties, argument
5173 def deviceFound(self, path): argument
5176 self.peer = path
5178 self.go = path
5179 if self.go and not self.group1:
5184 args = {'peer': self.go,
5191 def groupStarted(self, properties): argument
5204 if not self.group1:
5205 self.group1 = properties['group_object']
5206 self.group1iface = properties['interface_object']
5207 self.g1_if_obj = bus.get_object(WPAS_DBUS_SERVICE,
5208 self.group1iface)
5213 elif not self.group2:
5214 self.group2 = properties['group_object']
5215 self.group2iface = properties['interface_object']
5216 self.g2_if_obj = bus.get_object(WPAS_DBUS_SERVICE,
5217 self.group2iface)
5218 self.g2_bssid = res['BSSID']
5220 if self.group1 and self.group2:
5228 g_wps = dbus.Interface(self.g2_if_obj, WPAS_DBUS_IFACE_WPS)
5231 bssid = ':'.join(["%02x" % i for i in struct.unpack('6B', self.g2_bssid)])
5239 def groupFinished(self, properties): argument
5242 if self.group1 == properties['group_object']:
5243 self.group1 = None
5244 elif self.group2 == properties['group_object']:
5245 self.group2 = None
5247 if not self.group1 and not self.group2:
5248 self.done = True
5249 self.loop.quit()
5251 def peerJoined(self, peer): argument
5253 if self.groups_removed:
5255 self.check_results()
5260 group_p2p = dbus.Interface(self.g2_if_obj,
5265 group_p2p = dbus.Interface(self.g1_if_obj,
5268 self.groups_removed = True
5270 def check_results(self): argument
5273 g1_obj = bus.get_object(WPAS_DBUS_SERVICE, self.group1)
5278 g2_obj = bus.get_object(WPAS_DBUS_SERVICE, self.group2)
5283 logger.info("group1 = " + self.group1)
5286 logger.info("group2 = " + self.group2)
5303 def run_test(self, *args): argument
5308 def success(self): argument
5309 return self.done
5331 def __init__(self, bus): argument
5332 TestDbus.__init__(self, bus)
5333 self.done = False
5335 def __enter__(self): argument
5336 gobject.timeout_add(1, self.run_test)
5337 gobject.timeout_add(15000, self.timeout)
5338 self.add_signal(self.deviceFound, WPAS_DBUS_IFACE_P2PDEVICE,
5340 self.loop.run()
5341 return self
5343 def deviceFound(self, path): argument
5349 self.done = True
5350 self.loop.quit()
5352 def run_test(self, *args): argument
5357 def success(self): argument
5358 return self.done
5401 def __init__(self, bus): argument
5402 TestDbus.__init__(self, bus)
5403 self.done = False
5405 def __enter__(self): argument
5406 gobject.timeout_add(1, self.run_test)
5407 gobject.timeout_add(15000, self.timeout)
5408 self.add_signal(self.groupStarted, WPAS_DBUS_IFACE_P2PDEVICE,
5410 self.loop.run()
5411 return self
5413 def groupStarted(self, properties): argument
5415 self.loop.quit()
5423 self.done = True
5425 def run_test(self, *args): argument
5429 def success(self): argument
5430 return self.done
5524 def __init__(self, bus): argument
5525 TestDbus.__init__(self, bus)
5526 self.started = False
5527 self.sta_added = False
5528 self.sta_removed = False
5529 self.authorized = False
5530 self.deauthorized = False
5531 self.stations = False
5533 def __enter__(self): argument
5534 gobject.timeout_add(1, self.run_connect)
5535 gobject.timeout_add(15000, self.timeout)
5536 self.add_signal(self.networkAdded, WPAS_DBUS_IFACE, "NetworkAdded")
5537 self.add_signal(self.networkSelected, WPAS_DBUS_IFACE,
5539 self.add_signal(self.propertiesChanged, WPAS_DBUS_IFACE,
5541 self.add_signal(self.stationAdded, WPAS_DBUS_IFACE, "StationAdded")
5542 self.add_signal(self.stationRemoved, WPAS_DBUS_IFACE,
5544 self.add_signal(self.staAuthorized, WPAS_DBUS_IFACE,
5546 self.add_signal(self.staDeauthorized, WPAS_DBUS_IFACE,
5548 self.loop.run()
5549 return self
5551 def networkAdded(self, network, properties): argument
5555 def networkSelected(self, network): argument
5557 self.network_selected = True
5559 def propertiesChanged(self, properties): argument
5562 self.started = True
5565 def stationAdded(self, station, properties): argument
5568 self.sta_added = True
5573 self.stations = True
5577 def stationRemoved(self, station): argument
5579 self.sta_removed = True
5584 self.stations = False
5586 self.loop.quit()
5588 def staAuthorized(self, name): argument
5590 self.authorized = True
5593 def staDeauthorized(self, name): argument
5595 self.deauthorized = True
5597 def run_connect(self, *args): argument
5606 self.netw = iface.AddNetwork(args)
5607 iface.SelectNetwork(self.netw)
5610 def success(self): argument
5611 return self.started and self.sta_added and self.sta_removed and \
5612 self.authorized and self.deauthorized
5630 def __init__(self, bus): argument
5631 TestDbus.__init__(self, bus)
5632 self.started = False
5633 self.scan_completed = False
5635 def __enter__(self): argument
5636 gobject.timeout_add(1, self.run_connect)
5637 gobject.timeout_add(15000, self.timeout)
5638 self.add_signal(self.propertiesChanged, WPAS_DBUS_IFACE,
5640 self.add_signal(self.scanDone, WPAS_DBUS_IFACE, "ScanDone")
5641 self.loop.run()
5642 return self
5644 def propertiesChanged(self, properties): argument
5647 self.started = True
5653 def scanDone(self, success): argument
5655 if self.started:
5656 self.scan_completed = True
5657 self.loop.quit()
5659 def run_connect(self, *args): argument
5668 self.netw = iface.AddNetwork(args)
5669 iface.SelectNetwork(self.netw)
5672 def success(self): argument
5673 return self.started and self.scan_completed
5692 def __init__(self, bus): argument
5693 TestDbus.__init__(self, bus)
5694 self.done = False
5696 def __enter__(self): argument
5697 gobject.timeout_add(1, self.run_connect)
5698 gobject.timeout_add(15000, self.timeout)
5699 self.add_signal(self.propertiesChanged, WPAS_DBUS_IFACE,
5701 self.add_signal(self.eap, WPAS_DBUS_IFACE, "EAP")
5702 self.loop.run()
5703 return self
5705 def propertiesChanged(self, properties): argument
5708 self.done = True
5709 self.loop.quit()
5711 def eap(self, status, parameter): argument
5714 def run_connect(self, *args): argument
5725 self.netw = iface.AddNetwork(args)
5726 iface.SelectNetwork(self.netw)
5729 def success(self): argument
5730 return self.done
5935 def __init__(self, bus): argument
5936 TestDbus.__init__(self, bus)
5937 self.assoc_status_seen = False
5938 self.state = 0
5940 def __enter__(self): argument
5941 gobject.timeout_add(1, self.run_connect)
5942 gobject.timeout_add(15000, self.timeout)
5943 self.add_signal(self.propertiesChanged, WPAS_DBUS_IFACE,
5945 self.loop.run()
5946 return self
5948 def propertiesChanged(self, properties): argument
5955 self.assoc_status_seen = True
5957 self.loop.quit()
5959 def run_connect(self, *args): argument
5964 self.netw = iface.AddNetwork(args)
5965 iface.SelectNetwork(self.netw)
5968 def success(self): argument
5969 return self.assoc_status_seen
5985 def __init__(self, bus): argument
5986 TestDbus.__init__(self, bus)
5987 self.done = False
5989 def __enter__(self): argument
5990 gobject.timeout_add(1, self.run_test)
5991 gobject.timeout_add(15000, self.timeout)
5992 self.add_signal(self.meshGroupStarted, WPAS_DBUS_IFACE_MESH,
5994 self.add_signal(self.meshGroupRemoved, WPAS_DBUS_IFACE_MESH,
5996 self.add_signal(self.meshPeerConnected, WPAS_DBUS_IFACE_MESH,
5998 self.add_signal(self.meshPeerDisconnected, WPAS_DBUS_IFACE_MESH,
6000 self.loop.run()
6001 return self
6003 def meshGroupStarted(self, args): argument
6006 def meshGroupRemoved(self, args): argument
6008 self.done = True
6009 self.loop.quit()
6011 def meshPeerConnected(self, args): argument
6031 def meshPeerDisconnected(self, args): argument
6035 def run_test(self, *args): argument
6040 def success(self): argument
6041 return self.done
6063 def __init__(self, bus): argument
6064 TestDbus.__init__(self, bus)
6065 self.state = 0
6067 def __enter__(self): argument
6068 gobject.timeout_add(1, self.run_connect)
6069 gobject.timeout_add(15000, self.timeout)
6070 self.add_signal(self.propertiesChanged, WPAS_DBUS_IFACE,
6072 self.loop.run()
6073 return self
6075 def propertiesChanged(self, properties): argument
6078 if self.state == 0:
6079 self.state = 1
6091 elif self.state == 1:
6094 self.state = 2
6095 self.loop.quit()
6097 def run_connect(self, *args): argument
6104 self.netw = iface.AddNetwork(args)
6105 iface.SelectNetwork(self.netw)
6108 def success(self): argument
6109 return self.state == 2
6183 def __init__(self, bus): argument
6184 TestDbus.__init__(self, bus)
6185 self.interworking_ap_seen = False
6186 self.interworking_select_done = False
6188 def __enter__(self): argument
6189 gobject.timeout_add(1, self.run_select)
6190 gobject.timeout_add(15000, self.timeout)
6191 self.add_signal(self.interworkingAPAdded, WPAS_DBUS_IFACE,
6193 self.add_signal(self.interworkingSelectDone, WPAS_DBUS_IFACE,
6195 self.loop.run()
6196 return self
6198 def interworkingAPAdded(self, bss, cred, properties): argument
6200 if self.cred == cred:
6201 self.interworking_ap_seen = True
6203 def interworkingSelectDone(self): argument
6205 self.interworking_select_done = True
6206 self.loop.quit()
6208 def run_select(self, *args): argument
6217 self.cred = iface.AddCred(dbus.Dictionary(args, signature='sv'))
6221 def success(self): argument
6222 return self.interworking_ap_seen and self.interworking_select_done
6257 def __init__(self, bus): argument
6258 TestDbus.__init__(self, bus)
6259 self.hs20_t_and_c_seen = False
6261 def __enter__(self): argument
6262 gobject.timeout_add(1, self.run_connect)
6263 gobject.timeout_add(15000, self.timeout)
6264 self.add_signal(self.hs20TermsAndConditions, WPAS_DBUS_IFACE,
6266 self.loop.run()
6267 return self
6269 def hs20TermsAndConditions(self, t_c_url): argument
6273 self.hs20_t_and_c_seen = True
6275 def run_connect(self, *args): argument
6283 def success(self): argument
6284 return self.hs20_t_and_c_seen
6346 def __init__(self, bus): argument
6347 TestDbus.__init__(self, bus)
6348 self.anqp_query_done = False
6350 def __enter__(self): argument
6351 gobject.timeout_add(1, self.run_query)
6352 gobject.timeout_add(15000, self.timeout)
6353 self.add_signal(self.anqpQueryDone, WPAS_DBUS_IFACE,
6355 self.loop.run()
6356 return self
6358 def anqpQueryDone(self, addr, result): argument
6361 self.anqp_query_done = True
6363 def run_query(self, *args): argument
6369 def success(self): argument
6370 return self.anqp_query_done
6391 def __init__(self, bus): argument
6392 TestDbus.__init__(self, bus)
6393 self.capability_list = False
6394 self.venue_name = False
6395 self.roaming_consortium = False
6396 self.nai_realm = False
6398 def __enter__(self): argument
6399 gobject.timeout_add(1, self.run_query)
6400 gobject.timeout_add(15000, self.timeout)
6401 self.add_signal(self.propertiesChanged, WPAS_DBUS_BSS,
6403 self.loop.run()
6404 return self
6406 def propertiesChanged(self, properties): argument
6410 self.capability_list = 'CapabilityList' in anqp_properties
6411 self.venue_name = 'VenueName' in anqp_properties
6412 self.roaming_consortium = 'RoamingConsortium' in anqp_properties
6413 self.nai_realm = 'NAIRealm' in anqp_properties
6415 def run_query(self, *args): argument
6421 def success(self): argument
6422 … return self.capability_list and self.venue_name and self.roaming_consortium and self.nai_realm