python: Fix a couple of syntax errors.
authorWerner Koch <wk@gnupg.org>
Thu, 20 Sep 2018 15:30:48 +0000 (17:30 +0200)
committerWerner Koch <wk@gnupg.org>
Thu, 20 Sep 2018 15:45:07 +0000 (17:45 +0200)
* lang/python/tests/t-keylist-from-data.py: Add missing line
continuation.
* lang/python/tests/t-keylist.py: Ditto.
* lang/python/tests/t-quick-key-creation.py: Ditto.
* lang/python/tests/t-quick-subkey-creation.py: Ditto.

Signed-off-by: Werner Koch <wk@gnupg.org>
lang/python/tests/t-keylist-from-data.py
lang/python/tests/t-keylist.py
lang/python/tests/t-quick-key-creation.py
lang/python/tests/t-quick-subkey-creation.py

index f82ca84..4fd9ba0 100755 (executable)
@@ -162,18 +162,18 @@ def check_global(key, uids, n_subkeys):
     assert key.can_sign, "Key unexpectedly unusable for signing"
     assert key.can_certify, "Key unexpectedly unusable for certifications"
     assert not key.secret, "Key unexpectedly secret"
-    assert not key.protocol != gpg.constants.protocol.
-    OpenPGP, "Key has unexpected protocol: {}".format(key.protocol)
-    assert not key.issuer_serial,
-    "Key unexpectedly carries issuer serial: {}".format(key.issuer_serial)
-    assert not key.issuer_name,
-    "Key unexpectedly carries issuer name: {}".format(key.issuer_name)
-    assert not key.chain_id,
-    "Key unexpectedly carries chain ID: {}".format(key.chain_id)
-    assert key.owner_trust == gpg.constants.validity.UNKNOWN,
-    "Key has unexpected owner trust: {}".format(key.owner_trust)
-    assert len(key.subkeys) - 1 == n_subkeys,
-    "Key `{}' has unexpected number of subkeys".format(uids[0][0])
+    assert not key.protocol != gpg.constants.protocol.OpenPGP, \
+        "Key has unexpected protocol: {}".format(key.protocol)
+    assert not key.issuer_serial, \
+        "Key unexpectedly carries issuer serial: {}".format(key.issuer_serial)
+    assert not key.issuer_name, \
+        "Key unexpectedly carries issuer name: {}".format(key.issuer_name)
+    assert not key.chain_id, \
+        "Key unexpectedly carries chain ID: {}".format(key.chain_id)
+    assert key.owner_trust == gpg.constants.validity.UNKNOWN, \
+        "Key has unexpected owner trust: {}".format(key.owner_trust)
+    assert len(key.subkeys) - 1 == n_subkeys, \
+        "Key `{}' has unexpected number of subkeys".format(uids[0][0])
 
 
 def check_subkey(fpr, which, subkey):
@@ -183,49 +183,51 @@ def check_subkey(fpr, which, subkey):
     assert not subkey.invalid, which + " key unexpectedly invalid"
 
     if which == "Primary":
-        assert not subkey.can_encrypt,
-        which + " key unexpectedly usable for encryption"
-        assert subkey.can_sign,
-        which + " key unexpectedly unusable for signing"
-        assert subkey.can_certify,
-        which + " key unexpectedly unusable for certifications"
+        assert not subkey.can_encrypt, \
+            which + " key unexpectedly usable for encryption"
+        assert subkey.can_sign, \
+            which + " key unexpectedly unusable for signing"
+        assert subkey.can_certify, \
+            which + " key unexpectedly unusable for certifications"
     else:
-        assert subkey.can_encrypt,
-        which + " key unexpectedly unusable for encryption"
-        assert not subkey.can_sign,
-        which + " key unexpectedly usable for signing"
-        assert not subkey.can_certify,
-        which + " key unexpectedly usable for certifications"
+        assert subkey.can_encrypt, \
+            which + " key unexpectedly unusable for encryption"
+        assert not subkey.can_sign, \
+            which + " key unexpectedly usable for signing"
+        assert not subkey.can_certify, \
+            which + " key unexpectedly usable for certifications"
 
     assert not subkey.secret, which + " key unexpectedly secret"
     assert not subkey.is_cardkey, "Public key marked as card key"
     assert not subkey.card_number, "Public key with card number set"
-    assert not subkey.pubkey_algo !=
-    (gpg.constants.pk.DSA if which == "Primary" else gpg.constants.pk.ELG_E),
-    which + " key has unexpected public key algo: {}".format(subkey.
-                                                             pubkey_algo)
-    assert subkey.length == 1024,
-    which + " key has unexpected length: {}".format(subkey.length)
-    assert fpr.endswith(subkey.keyid),
-    which + " key has unexpected key ID: {}".format(subkey.keyid)
-    assert which == "Secondary" or subkey.fpr == fpr,
-    which + " key has unexpected fingerprint: {}".format(subkey.fpr)
-    assert not subkey.expires,
-    which + " key unexpectedly expires: {}".format(subkey.expires)
+    assert not subkey.pubkey_algo != \
+        (gpg.constants.pk.DSA if which == "Primary"
+         else gpg.constants.pk.ELG_E), \
+         which + " key has unexpected public key algo: {}".format(subkey.
+                                                                  pubkey_algo)
+    assert subkey.length == 1024, \
+        which + " key has unexpected length: {}".format(subkey.length)
+    assert fpr.endswith(subkey.keyid), \
+        which + " key has unexpected key ID: {}".format(subkey.keyid)
+    assert which == "Secondary" or subkey.fpr == fpr, \
+        which + " key has unexpected fingerprint: {}".format(subkey.fpr)
+    assert not subkey.expires, \
+        which + " key unexpectedly expires: {}".format(subkey.expires)
 
 
 def check_uid(which, ref, uid):
     assert not uid.revoked, which + " user ID unexpectedly revoked"
     assert not uid.invalid, which + " user ID unexpectedly invalid"
-    assert uid.validity == gpg.constants.validity.UNKNOWN,
-    which + " user ID has unexpected validity: {}".format(uid.validity)
+    assert uid.validity == gpg.constants.validity.UNKNOWN, \
+        which + " user ID has unexpected validity: {}".format(uid.validity)
     assert not uid.signatures, which + " user ID unexpectedly signed"
-    assert uid.name == ref[0],
-    "Unexpected name in {} user ID: {!r}".format(which.lower(), uid.name)
-    assert uid.comment == ref[1],
-    "Unexpected comment in {} user ID: {!r}".format(which.lower(), uid.comment)
-    assert uid.email == ref[2],
-    "Unexpected email in {} user ID: {!r}".format(which.lower(), uid.email)
+    assert uid.name == ref[0], \
+        "Unexpected name in {} user ID: {!r}".format(which.lower(), uid.name)
+    assert uid.comment == ref[1], \
+        "Unexpected comment in {} user ID: {!r}".format(which.lower(),
+                                                        uid.comment)
+    assert uid.email == ref[2], \
+        "Unexpected email in {} user ID: {!r}".format(which.lower(), uid.email)
 
 
 # Export all the data from our keyring...
index b725fc3..9cbada5 100755 (executable)
@@ -162,25 +162,25 @@ def check_global(key, uids, n_subkeys):
     assert key.can_sign, "Key unexpectedly unusable for signing"
     assert key.can_certify, "Key unexpectedly unusable for certifications"
     assert not key.secret, "Key unexpectedly secret"
-    assert not key.protocol != gpg.constants.protocol.OpenPGP,
-    "Key has unexpected protocol: {}".format(key.protocol)
-    assert not key.issuer_serial,
-    "Key unexpectedly carries issuer serial: {}".format(key.issuer_serial)
-    assert not key.issuer_name,
-    "Key unexpectedly carries issuer name: {}".format(key.issuer_name)
-    assert not key.chain_id,
-    "Key unexpectedly carries chain ID: {}".format(key.chain_id)
+    assert not key.protocol != gpg.constants.protocol.OpenPGP, \
+        "Key has unexpected protocol: {}".format(key.protocol)
+    assert not key.issuer_serial, \
+        "Key unexpectedly carries issuer serial: {}".format(key.issuer_serial)
+    assert not key.issuer_name, \
+        "Key unexpectedly carries issuer name: {}".format(key.issuer_name)
+    assert not key.chain_id, \
+        "Key unexpectedly carries chain ID: {}".format(key.chain_id)
 
     # Only key Alfa is trusted
-    assert key.uids[0].name == 'Alfa Test' or
-    key.owner_trust == gpg.constants.validity.UNKNOWN,
-    "Key has unexpected owner trust: {}".format(key.owner_trust)
-    assert key.uids[0].name != 'Alfa Test' or key.owner_trust == gpg.constants.
-    validity.ULTIMATE, "Key has unexpected owner trust: {}".
-    format(key.owner_trust)
+    assert (key.uids[0].name == 'Alfa Test'
+            or key.owner_trust == gpg.constants.validity.UNKNOWN), \
+            "Key has unexpected owner trust: {}".format(key.owner_trust)
+    assert (key.uids[0].name != 'Alfa Test'
+            or key.owner_trust == gpg.constants.validity.ULTIMATE), \
+            "Key has unexpected owner trust: {}".format(key.owner_trust)
 
-    assert len(key.subkeys) - 1 == n_subkeys,
-    "Key `{}' has unexpected number of subkeys".format(uids[0][0])
+    assert len(key.subkeys) - 1 == n_subkeys, \
+        "Key `{}' has unexpected number of subkeys".format(uids[0][0])
 
 
 def check_subkey(fpr, which, subkey):
@@ -207,18 +207,19 @@ def check_subkey(fpr, which, subkey):
     assert not subkey.secret, which + " key unexpectedly secret"
     assert not subkey.is_cardkey, "Public key marked as card key"
     assert not subkey.card_number, "Public key with card number set"
-    assert not subkey.pubkey_algo !=
-    (gpg.constants.pk.DSA if which == "Primary" else gpg.constants.pk.ELG_E),
-    which + " key has unexpected public key algo: {}".format(subkey.
+    assert not subkey.pubkey_algo != \
+        (gpg.constants.pk.DSA if which == "Primary"
+         else gpg.constants.pk.ELG_E), \
+        which + " key has unexpected public key algo: {}".format(subkey.
                                                              pubkey_algo)
-    assert subkey.length == 1024,
-    which + " key has unexpected length: {}".format(subkey.length)
-    assert fpr.endswith(subkey.keyid),
-    which + " key has unexpected key ID: {}".format(subkey.keyid)
-    assert which == "Secondary" or subkey.fpr == fpr,
-    which + " key has unexpected fingerprint: {}".format(subkey.fpr)
-    assert not subkey.expires,
-    which + " key unexpectedly expires: {}".format(subkey.expires)
+    assert subkey.length == 1024, \
+        which + " key has unexpected length: {}".format(subkey.length)
+    assert fpr.endswith(subkey.keyid), \
+        which + " key has unexpected key ID: {}".format(subkey.keyid)
+    assert which == "Secondary" or subkey.fpr == fpr, \
+        which + " key has unexpected fingerprint: {}".format(subkey.fpr)
+    assert not subkey.expires, \
+        which + " key unexpectedly expires: {}".format(subkey.expires)
 
 
 def check_uid(which, ref, uid):
@@ -227,16 +228,16 @@ def check_uid(which, ref, uid):
     assert uid.validity == (gpg.constants.validity.UNKNOWN
                             if uid.name.split()[0]
                             not in {'Alfa', 'Alpha', 'Alice'} else
-                            gpg.constants.validity.ULTIMATE),
-    which + " user ID has unexpectedly validity: {}".format(uid.validity)
+                            gpg.constants.validity.ULTIMATE), \
+        which + " user ID has unexpectedly validity: {}".format(uid.validity)
     assert not uid.signatures, which + " user ID unexpectedly signed"
-    assert uid.name == ref[0],
-    "Unexpected name in {} user ID: {!r}".format(which.lower(), uid.name)
-    assert uid.comment == ref[1],
-    "Unexpected comment in {} user ID: {!r}".format(which.lower(),
-                                                    uid.comment)
-    assert uid.email == ref[2],
-    "Unexpected email in {} user ID: {!r}".format(which.lower(), uid.email)
+    assert uid.name == ref[0], \
+        "Unexpected name in {} user ID: {!r}".format(which.lower(), uid.name)
+    assert uid.comment == ref[1], \
+        "Unexpected comment in {} user ID: {!r}".\
+        format(which.lower(), uid.comment)
+    assert uid.email == ref[2], \
+        "Unexpected email in {} user ID: {!r}".format(which.lower(), uid.email)
 
 
 i = 0
index 4720928..b3303ff 100755 (executable)
@@ -80,8 +80,11 @@ with support.EphemeralContext() as ctx:
         "Primary keys expiration time is off"
 
     # Check capabilities
-    for sign, encrypt, certify, authenticate in itertools.
-    product([False, True], [False, True], [False, True], [False, True]):
+    for sign, encrypt, certify, authenticate \
+            in itertools.product([False, True],
+                                 [False, True],
+                                 [False, True],
+                                 [False, True]):
         # Filter some out
         if not (sign or encrypt or certify or authenticate):
             # This triggers the default capabilities tested before.
index 30424c1..cdbb71b 100755 (executable)
@@ -60,8 +60,10 @@ with support.EphemeralContext() as ctx:
         "subkeys expiration time is off"
 
     # Check capabilities
-    for sign, encrypt, authenticate in itertools.
-    product([False, True], [False, True], [False, True]):
+    for sign, encrypt, authenticate \
+            in itertools.product([False, True],
+                                 [False, True],
+                                 [False, True]):
         # Filter some out
         if not (sign or encrypt or authenticate):
             # This triggers the default capabilities tested before.