Simplify "expect_packet" tests.

test/broker/01-connect-anon-denied.py

@@ -31,6 +31,8 @@ def do_test(proto_ver):
         sock = mosq_test.do_client_connect(connect_packet, connack_packet, port=port)
         sock.close()
         rc = 0
+    except mosq_test.TestError:
+        pass
     finally:
         os.remove(conf_file)
         broker.terminate()

test/broker/01-connect-bad-packet.py

@@ -26,6 +26,8 @@ def do_test(proto_ver):
         if e.errno == errno.ECONNRESET:
             # Connection has been closed by peer, this is the expected behaviour
             rc = 0
+    except mosq_test.TestError:
+        pass
     finally:
         broker.terminate()
         broker.wait()

test/broker/01-connect-disconnect-v5.py

@@ -55,6 +55,8 @@ try:
     props = mqtt5_props.gen_string_pair_prop(mqtt5_props.PROP_USER_PROPERTY, "key", "value")
     disconnect_packet = mosq_test.gen_disconnect(proto_ver=5, reason_code=0, properties=props)
     disco_test("disco len>2", disconnect_packet)
+except mosq_test.TestError:
+    pass
 finally:
     broker.terminate()
     broker.wait()

test/broker/01-connect-duplicate.py

@@ -22,6 +22,8 @@ def do_test(proto_ver):
             rc = 0
     except socket.error:
         rc = 0
+    except mosq_test.TestError:
+        pass
     finally:
         broker.terminate()
         broker.wait()

test/broker/01-connect-invalid-id-0.py

@@ -20,6 +20,8 @@ def do_test(proto_ver):
         sock = mosq_test.do_client_connect(connect_packet, connack_packet, port=port)
         sock.close()
         rc = 0
+    except mosq_test.TestError:
+        pass
     finally:
         broker.terminate()
         broker.wait()

test/broker/01-connect-invalid-id-missing.py

@@ -16,6 +16,8 @@ try:
     sock = mosq_test.do_client_connect(connect_packet, connack_packet, port=port)
     sock.close()
     rc = 0
+except mosq_test.TestError:
+    pass
 finally:
     broker.terminate()
     broker.wait()

test/broker/01-connect-invalid-id-utf8.py

@@ -22,6 +22,8 @@ def do_test(proto_ver):
         # Exception occurs if connack packet returned
         rc = 0
         sock.close()
+    except mosq_test.TestError:
+        pass
     finally:
         broker.terminate()
         broker.wait()

test/broker/01-connect-invalid-protonum.py

@@ -17,6 +17,8 @@ try:
     sock.close()
     rc = 0
 
+except mosq_test.TestError:
+    pass
 finally:
     broker.terminate()
     broker.wait()

test/broker/01-connect-invalid-reserved.py

@@ -19,6 +19,8 @@ except socket.error as e:
     if e.errno == errno.ECONNRESET:
         # Connection has been closed by peer, this is the expected behaviour
         rc = 0
+except mosq_test.TestError:
+    pass
 finally:
     broker.terminate()
     broker.wait()

test/broker/01-connect-success.py

@@ -17,6 +17,8 @@ def do_test(proto_ver):
         sock = mosq_test.do_client_connect(connect_packet, connack_packet, port=port)
         sock.close()
         rc = 0
+    except mosq_test.TestError:
+        pass
     finally:
         broker.terminate()
         broker.wait()

test/broker/01-connect-uname-invalid-utf8.py

@@ -22,6 +22,8 @@ def do_test(proto_ver):
         # Exception occurs if connack packet returned
         rc = 0
         sock.close()
+    except mosq_test.TestError:
+        pass
     finally:
         broker.terminate()
         broker.wait()

test/broker/01-connect-uname-no-flag.py

@@ -22,6 +22,8 @@ def do_test(proto_ver):
         sock = mosq_test.do_client_connect(connect_packet, b"", port=port)
         sock.close()
         rc = 0
+    except mosq_test.TestError:
+        pass
     finally:
         broker.terminate()
         broker.wait()

test/broker/01-connect-uname-no-password-denied.py

@@ -31,6 +31,8 @@ def do_test(proto_ver):
         sock = mosq_test.do_client_connect(connect_packet, connack_packet, port=port)
         sock.close()
         rc = 0
+    except mosq_test.TestError:
+        pass
     finally:
         os.remove(conf_file)
         broker.terminate()

test/broker/01-connect-uname-password-denied-no-will.py

@@ -53,6 +53,8 @@ def do_test(proto_ver):
         sock1.close()
         rc = 0
 
+    except mosq_test.TestError:
+        pass
     finally:
         os.remove(conf_file)
         os.remove(pw_file)

test/broker/01-connect-uname-password-denied.py

@@ -33,6 +33,8 @@ def do_test(proto_ver):
         sock.close()
         rc = 0
 
+    except mosq_test.TestError:
+        pass
     finally:
         os.remove(conf_file)
         broker.terminate()

test/broker/01-connect-uname-password-success-no-tls.py

@@ -29,6 +29,8 @@ def do_test(proto_ver):
         sock.close()
         rc = 0
 
+    except mosq_test.TestError:
+        pass
     finally:
         os.remove(conf_file)
         broker.terminate()

test/broker/01-connect-uname-password-success.py

@@ -29,6 +29,8 @@ def do_test(proto_ver):
         sock.close()
         rc = 0
 
+    except mosq_test.TestError:
+        pass
     finally:
         os.remove(conf_file)
         broker.terminate()

test/broker/01-connect-uname-pwd-no-flag.py

@@ -23,6 +23,8 @@ def do_test(proto_ver):
         sock = mosq_test.do_client_connect(connect_packet, b"", port=port)
         sock.close()
         rc = 0
+    except mosq_test.TestError:
+        pass
     finally:
         broker.terminate()
         broker.wait()

test/broker/01-connect-zero-length-id.py

@@ -47,6 +47,8 @@ def do_test(per_listener, proto_ver, clean_start, allow_zero, client_port, expec
         sock = mosq_test.do_client_connect(connect_packet, connack_packet, port=client_port)
         sock.close()
         rc = 0
+    except mosq_test.TestError:
+        pass
     finally:
         broker.terminate()
         broker.wait()

test/broker/02-shared-qos0-v5.py

@@ -94,33 +94,35 @@ try:
     mosq_test.do_send_receive(sock5, subscribe5_packet, suback5_packet, "suback5")
 
     sock1.send(publish1_packet)
-    if mosq_test.expect_packet(sock1, "publish1 1", publish1_packet):
-        if mosq_test.expect_packet(sock2, "publish1 2", publish1_packet):
-            if mosq_test.expect_packet(sock3, "publish1 3", publish1_packet):
+    mosq_test.expect_packet(sock1, "publish1 1", publish1_packet)
+    mosq_test.expect_packet(sock2, "publish1 2", publish1_packet)
+    mosq_test.expect_packet(sock3, "publish1 3", publish1_packet)
 
-                sock1.send(publish2_packet)
-                if mosq_test.expect_packet(sock1, "publish2 1", publish2_packet):
-                    if mosq_test.expect_packet(sock3, "publish2 3", publish2_packet):
-                        if mosq_test.expect_packet(sock4, "publish2 4", publish2_packet):
+    sock1.send(publish2_packet)
+    mosq_test.expect_packet(sock1, "publish2 1", publish2_packet)
+    mosq_test.expect_packet(sock3, "publish2 3", publish2_packet)
+    mosq_test.expect_packet(sock4, "publish2 4", publish2_packet)
 
-                            sock1.send(publish3_packet)
-                            if mosq_test.expect_packet(sock1, "publish3 1", publish3_packet):
-                                if mosq_test.expect_packet(sock3, "publish3 3", publish3_packet):
-                                    if mosq_test.expect_packet(sock5, "publish3 5", publish3_packet):
-                                        mosq_test.do_send_receive(sock1, unsubscribe1_packet, unsuback1_packet, "unsuback1")
-                                        mosq_test.do_send_receive(sock2, unsubscribe2_packet, unsuback2_packet, "unsuback2")
-                                        mosq_test.do_send_receive(sock3, unsubscribe3a_packet, unsuback3a_packet, "unsuback3a")
-                                        mosq_test.do_send_receive(sock3, unsubscribe3b_packet, unsuback3b_packet, "unsuback3b")
-                                        mosq_test.do_send_receive(sock4, unsubscribe4_packet, unsuback4_packet, "unsuback4")
-                                        mosq_test.do_send_receive(sock5, unsubscribe5_packet, unsuback5_packet, "unsuback5")
+    sock1.send(publish3_packet)
+    mosq_test.expect_packet(sock1, "publish3 1", publish3_packet)
+    mosq_test.expect_packet(sock3, "publish3 3", publish3_packet)
+    mosq_test.expect_packet(sock5, "publish3 5", publish3_packet)
+    mosq_test.do_send_receive(sock1, unsubscribe1_packet, unsuback1_packet, "unsuback1")
+    mosq_test.do_send_receive(sock2, unsubscribe2_packet, unsuback2_packet, "unsuback2")
+    mosq_test.do_send_receive(sock3, unsubscribe3a_packet, unsuback3a_packet, "unsuback3a")
+    mosq_test.do_send_receive(sock3, unsubscribe3b_packet, unsuback3b_packet, "unsuback3b")
+    mosq_test.do_send_receive(sock4, unsubscribe4_packet, unsuback4_packet, "unsuback4")
+    mosq_test.do_send_receive(sock5, unsubscribe5_packet, unsuback5_packet, "unsuback5")
 
-                                        rc = 0
+    rc = 0
 
     sock1.close()
     sock2.close()
     sock3.close()
     sock4.close()
     sock5.close()
+except mosq_test.TestError:
+    pass
 finally:
     broker.terminate()
     broker.wait()

test/broker/02-subhier-crash.py

@@ -46,6 +46,8 @@ try:
 
     rc = 0
 
+except mosq_test.TestError:
+    pass
 finally:
     broker.terminate()
     broker.wait()

test/broker/02-subpub-qos0-long-topic.py

@@ -31,6 +31,8 @@ def do_test(topic, succeeds):
         rc = 0
 
         sock.close()
+    except mosq_test.TestError:
+        pass
     finally:
         broker.terminate()
         broker.wait()

test/broker/02-subpub-qos0-retain-as-publish.py

@@ -43,6 +43,8 @@ def do_test():
         rc = 0
 
         sock.close()
+    except mosq_test.TestError:
+        pass
     finally:
         broker.terminate()
         broker.wait()

test/broker/02-subpub-qos0-send-retain.py

@@ -53,19 +53,21 @@ def do_test():
 
         # Expect a message after this, because it is the first subscribe
         mosq_test.do_send_receive(sock, subscribe2_packet, suback2_packet, "suback2")
-        if mosq_test.expect_packet(sock, "publish2r1", publish2r1_packet):
-            # Don't expect a message after this, it is the second subscribe
-            mosq_test.do_send_receive(sock, subscribe2_packet, suback2_packet, "suback2")
+        mosq_test.expect_packet(sock, "publish2r1", publish2r1_packet)
+        # Don't expect a message after this, it is the second subscribe
+        mosq_test.do_send_receive(sock, subscribe2_packet, suback2_packet, "suback2")
 
-            # Always expect a message after this
-            mosq_test.do_send_receive(sock, subscribe1_packet, suback1_packet, "suback1")
-            if mosq_test.expect_packet(sock, "publish1r1", publish1r1_packet):
-                # Always expect a message after this
-                mosq_test.do_send_receive(sock, subscribe1_packet, suback1_packet, "suback1")
-                if mosq_test.expect_packet(sock, "publish1r1", publish1r2_packet):
-                    rc = 0
+        # Always expect a message after this
+        mosq_test.do_send_receive(sock, subscribe1_packet, suback1_packet, "suback1")
+        mosq_test.expect_packet(sock, "publish1r1", publish1r1_packet)
+        # Always expect a message after this
+        mosq_test.do_send_receive(sock, subscribe1_packet, suback1_packet, "suback1")
+        mosq_test.expect_packet(sock, "publish1r1", publish1r2_packet)
+        rc = 0
 
         sock.close()
+    except mosq_test.TestError:
+        pass
     finally:
         broker.terminate()
         broker.wait()

test/broker/02-subpub-qos0-subscription-id.py

@@ -93,6 +93,8 @@ def do_test(proto_ver):
         rc = 0
 
         sock.close()
+    except mosq_test.TestError:
+        pass
     finally:
         broker.terminate()
         broker.wait()

test/broker/02-subpub-qos0-topic-alias-unknown.py

@@ -23,10 +23,12 @@ def do_test():
         sock = mosq_test.do_client_connect(connect_packet, connack_packet, timeout=5, port=port)
         sock.send(publish1_packet)
 
-        if mosq_test.expect_packet(sock, "disconnect", disconnect_packet):
-            rc = 0
+        mosq_test.expect_packet(sock, "disconnect", disconnect_packet)
+        rc = 0
 
         sock.close()
+    except mosq_test.TestError:
+        pass
     finally:
         broker.terminate()
         broker.wait()

test/broker/02-subpub-qos0-topic-alias.py

@@ -39,11 +39,13 @@ def do_test():
 
         sock1.send(publish2s_packet)
 
-        if mosq_test.expect_packet(sock2, "publish2r", publish2r_packet):
-            rc = 0
+        mosq_test.expect_packet(sock2, "publish2r", publish2r_packet)
+        rc = 0
 
         sock1.close()
         sock2.close()
+    except mosq_test.TestError:
+        pass
     finally:
         broker.terminate()
         broker.wait()

test/broker/02-subpub-qos0.py

@@ -28,6 +28,8 @@ def do_test(proto_ver):
         rc = 0
 
         sock.close()
+    except mosq_test.TestError:
+        pass
     finally:
         broker.terminate()
         broker.wait()

test/broker/02-subpub-qos1-bad-pubcomp.py

@@ -47,18 +47,20 @@ def do_test(proto_ver):
 
         helper(port, proto_ver)
 
-        if mosq_test.expect_packet(sock, "publish 1r", publish1r_packet):
-            sock.send(pubcomp1r_packet)
-            sock.send(pingreq_packet)
-            p = sock.recv(len(pingresp_packet))
-            if len(p) == 0:
-                rc = 0
+        mosq_test.expect_packet(sock, "publish 1r", publish1r_packet)
+        sock.send(pubcomp1r_packet)
+        sock.send(pingreq_packet)
+        p = sock.recv(len(pingresp_packet))
+        if len(p) == 0:
+            rc = 0
 
         sock.close()
     except socket.error as e:
         if e.errno == errno.ECONNRESET:
             # Connection has been closed by peer, this is the expected behaviour
             rc = 0
+    except mosq_test.TestError:
+        pass
     finally:
         broker.terminate()
         broker.wait()

test/broker/02-subpub-qos1-bad-pubrec.py

@@ -44,18 +44,20 @@ def do_test(proto_ver):
 
         helper(port, proto_ver)
 
-        if mosq_test.expect_packet(sock, "publish 1r", publish1r_packet):
-            sock.send(pubrec1r_packet)
-            sock.send(pingreq_packet)
-            p = sock.recv(len(pingresp_packet))
-            if len(p) == 0:
-                rc = 0
+        mosq_test.expect_packet(sock, "publish 1r", publish1r_packet)
+        sock.send(pubrec1r_packet)
+        sock.send(pingreq_packet)
+        p = sock.recv(len(pingresp_packet))
+        if len(p) == 0:
+            rc = 0
 
         sock.close()
     except socket.error as e:
         if e.errno == errno.ECONNRESET:
             # Connection has been closed by peer, this is the expected behaviour
             rc = 0
+    except mosq_test.TestError:
+        pass
     finally:
         broker.terminate()
         broker.wait()

test/broker/02-subpub-qos1-message-expiry-retain.py

@@ -56,26 +56,27 @@ def do_test():
         sock = mosq_test.do_client_connect(connect_packet, connack_packet, timeout=20, port=port)
         mosq_test.do_send_receive(sock, subscribe1_packet, suback1_packet, "suback 1-1")
 
-        if mosq_test.expect_packet(sock, "publish 1", publish1_packet):
-            sock.send(puback1_packet)
+        mosq_test.expect_packet(sock, "publish 1", publish1_packet)
+        sock.send(puback1_packet)
 
-            mosq_test.do_send_receive(sock, subscribe2_packet, suback2_packet, "suback 2-1")
-            if mosq_test.expect_packet(sock, "publish 2", publish2s_packet):
-                sock.send(puback2s_packet)
+        mosq_test.do_send_receive(sock, subscribe2_packet, suback2_packet, "suback 2-1")
+        mosq_test.expect_packet(sock, "publish 2", publish2s_packet)
+        sock.send(puback2s_packet)
+        sock.close()
 
-                sock.close()
-
-            time.sleep(5)
-            sock = mosq_test.do_client_connect(connect_packet, connack_packet, timeout=20, port=port)
-            mosq_test.do_send_receive(sock, subscribe1_packet, suback1_packet, "suback 1-2")
-            # We shouldn't receive a publish here
-            # This will fail if we do receive a publish
-            mosq_test.do_send_receive(sock, subscribe2_packet, suback2_packet, "suback 2-2")
-            if mosq_test.expect_packet(sock, "publish 2", publish2r_packet):
-                sock.send(puback2r_packet)
-                sock.close()
-                rc = 0
+        time.sleep(5)
+        sock = mosq_test.do_client_connect(connect_packet, connack_packet, timeout=20, port=port)
+        mosq_test.do_send_receive(sock, subscribe1_packet, suback1_packet, "suback 1-2")
+        # We shouldn't receive a publish here
+        # This will fail if we do receive a publish
+        mosq_test.do_send_receive(sock, subscribe2_packet, suback2_packet, "suback 2-2")
+        mosq_test.expect_packet(sock, "publish 2", publish2r_packet)
+        sock.send(puback2r_packet)
+        sock.close()
+        rc = 0
 
+    except mosq_test.TestError:
+        pass
     finally:
         broker.terminate()
         broker.wait()

test/broker/02-subpub-qos1-message-expiry-will.py

@@ -56,6 +56,8 @@ def do_test():
                 break
 
         sock.close()
+    except mosq_test.TestError:
+        pass
     finally:
         broker.terminate()
         broker.wait()

test/broker/02-subpub-qos1-message-expiry.py

@@ -63,6 +63,8 @@ def do_test():
                 break
 
         sock.close()
+    except mosq_test.TestError:
+        pass
     finally:
         broker.terminate()
         broker.wait()

test/broker/02-subpub-qos1-nolocal.py

@@ -44,10 +44,12 @@ def do_test():
         mosq_test.do_send_receive(sock, publish_packet, puback_packet, "puback")
         mosq_test.do_send_receive(sock, publish2_packet, puback2_packet, "puback2")
 
-        if mosq_test.expect_packet(sock, "publish3", publish3_packet):
-            rc = 0
+        mosq_test.expect_packet(sock, "publish3", publish3_packet)
+        rc = 0
 
         sock.close()
+    except mosq_test.TestError:
+        pass
     finally:
         broker.terminate()
         broker.wait()

test/broker/02-subpub-qos1.py

@@ -32,10 +32,12 @@ def do_test(proto_ver):
 
         mosq_test.do_send_receive(sock, publish_packet, puback_packet, "puback")
 
-        if mosq_test.expect_packet(sock, "publish2", publish_packet2):
-            rc = 0
+        mosq_test.expect_packet(sock, "publish2", publish_packet2)
+        rc = 0
 
         sock.close()
+    except mosq_test.TestError:
+        pass
     finally:
         broker.terminate()
         broker.wait()

test/broker/02-subpub-qos2-1322.py

@@ -87,46 +87,48 @@ def do_test(proto_ver):
         mosq_test.do_send_receive(pub, pubrel_packet, pubcomp_packet, "pubcomp1")
         pub.close()
 
-        if mosq_test.expect_packet(sub1, "publish1", publish1r_packet):
-            pub = mosq_test.do_client_connect(pub_connect_packet, pub_connack2_packet, timeout=10, port=port)
-            mosq_test.do_send_receive(pub, publish2s_packet, pubrec_packet, "pubrec2")
-            mosq_test.do_send_receive(pub, pubrel_packet, pubcomp_packet, "pubcomp2")
-            pub.close()
+        mosq_test.expect_packet(sub1, "publish1", publish1r_packet)
+        pub = mosq_test.do_client_connect(pub_connect_packet, pub_connack2_packet, timeout=10, port=port)
+        mosq_test.do_send_receive(pub, publish2s_packet, pubrec_packet, "pubrec2")
+        mosq_test.do_send_receive(pub, pubrel_packet, pubcomp_packet, "pubcomp2")
+        pub.close()
 
-            # We expect nothing on sub1
-            mosq_test.do_ping(sub1, error_string="pingresp1")
+        # We expect nothing on sub1
+        mosq_test.do_ping(sub1, error_string="pingresp1")
 
-            pub = mosq_test.do_client_connect(pub_connect_packet, pub_connack2_packet, timeout=10, port=port)
-            mosq_test.do_send_receive(pub, publish3s_packet, pubrec_packet, "pubrec3")
-            mosq_test.do_send_receive(pub, pubrel_packet, pubcomp_packet, "pubcomp3")
-            pub.close()
+        pub = mosq_test.do_client_connect(pub_connect_packet, pub_connack2_packet, timeout=10, port=port)
+        mosq_test.do_send_receive(pub, publish3s_packet, pubrec_packet, "pubrec3")
+        mosq_test.do_send_receive(pub, pubrel_packet, pubcomp_packet, "pubcomp3")
+        pub.close()
 
-            if mosq_test.expect_packet(sub1, "publish3", publish3r_packet):
-                sub2 = mosq_test.do_client_connect(sub2_connect_packet, sub2_connack_packet, timeout=10, port=port)
-                mosq_test.do_send_receive(sub2, subscribe2_packet, suback2_packet, "suback2")
+        mosq_test.expect_packet(sub1, "publish3", publish3r_packet)
+        sub2 = mosq_test.do_client_connect(sub2_connect_packet, sub2_connack_packet, timeout=10, port=port)
+        mosq_test.do_send_receive(sub2, subscribe2_packet, suback2_packet, "suback2")
 
-                pub = mosq_test.do_client_connect(pub_connect_packet, pub_connack2_packet, timeout=10, port=port)
-                mosq_test.do_send_receive(pub, publish4s_packet, pubrec_packet, "pubrec4")
-                mosq_test.do_send_receive(pub, pubrel_packet, pubcomp_packet, "pubcomp4")
-                pub.close()
+        pub = mosq_test.do_client_connect(pub_connect_packet, pub_connack2_packet, timeout=10, port=port)
+        mosq_test.do_send_receive(pub, publish4s_packet, pubrec_packet, "pubrec4")
+        mosq_test.do_send_receive(pub, pubrel_packet, pubcomp_packet, "pubcomp4")
+        pub.close()
 
-                # We expect nothing on sub2
-                mosq_test.do_ping(sub2, error_string="pingresp2")
+        # We expect nothing on sub2
+        mosq_test.do_ping(sub2, error_string="pingresp2")
+    
+        mosq_test.expect_packet(sub1, "publish4", publish4r_packet)
+        pub = mosq_test.do_client_connect(pub_connect_packet, pub_connack2_packet, timeout=10, port=port)
+        mosq_test.do_send_receive(pub, publish5s_packet, pubrec_packet, "pubrec5")
+        mosq_test.do_send_receive(pub, pubrel_packet, pubcomp_packet, "pubcomp5")
+        pub.close()
+
+        # We expect nothing on sub2
+        mosq_test.do_ping(sub2, error_string="pingresp2")
             
-                if mosq_test.expect_packet(sub1, "publish4", publish4r_packet):
-                    pub = mosq_test.do_client_connect(pub_connect_packet, pub_connack2_packet, timeout=10, port=port)
-                    mosq_test.do_send_receive(pub, publish5s_packet, pubrec_packet, "pubrec5")
-                    mosq_test.do_send_receive(pub, pubrel_packet, pubcomp_packet, "pubcomp5")
-                    pub.close()
+        mosq_test.expect_packet(sub1, "publish5", publish5r_packet)
+        rc = 0
 
-                    # We expect nothing on sub2
-                    mosq_test.do_ping(sub2, error_string="pingresp2")
-            
-                    if mosq_test.expect_packet(sub1, "publish5", publish5r_packet):
-                        rc = 0
-
-                sub2.close()
+        sub2.close()
         sub1.close()
+    except mosq_test.TestError:
+        pass
     finally:
         broker.terminate()
         broker.wait()

test/broker/02-subpub-qos2-bad-puback-1.py

@@ -47,18 +47,20 @@ def do_test(proto_ver):
 
         helper(port, proto_ver)
 
-        if mosq_test.expect_packet(sock, "publish 1r", publish1r_packet):
-            sock.send(puback1r_packet)
-            sock.send(pingreq_packet)
-            p = sock.recv(len(pingresp_packet))
-            if len(p) == 0:
-                rc = 0
+        mosq_test.expect_packet(sock, "publish 1r", publish1r_packet)
+        sock.send(puback1r_packet)
+        sock.send(pingreq_packet)
+        p = sock.recv(len(pingresp_packet))
+        if len(p) == 0:
+            rc = 0
 
         sock.close()
     except socket.error as e:
         if e.errno == errno.ECONNRESET:
             # Connection has been closed by peer, this is the expected behaviour
             rc = 0
+    except mosq_test.TestError:
+        pass
     finally:
         broker.terminate()
         broker.wait()

test/broker/02-subpub-qos2-bad-puback-2.py

@@ -45,19 +45,21 @@ def do_test(proto_ver):
         mosq_test.do_send_receive(helper, pubrel1s_packet, pubcomp1s_packet, "pubcomp 1s")
         helper.close()
 
-        if mosq_test.expect_packet(sock, "publish 1r", publish1r_packet):
-            mosq_test.do_send_receive(sock, pubrec1s_packet, pubrel1s_packet, "pubrel 1r")
-            sock.send(puback1r_packet)
-            sock.send(pingreq_packet)
-            p = sock.recv(len(pingresp_packet))
-            if len(p) == 0:
-                rc = 0
+        mosq_test.expect_packet(sock, "publish 1r", publish1r_packet)
+        mosq_test.do_send_receive(sock, pubrec1s_packet, pubrel1s_packet, "pubrel 1r")
+        sock.send(puback1r_packet)
+        sock.send(pingreq_packet)
+        p = sock.recv(len(pingresp_packet))
+        if len(p) == 0:
+            rc = 0
 
         sock.close()
     except socket.error as e:
         if e.errno == errno.ECONNRESET:
             # Connection has been closed by peer, this is the expected behaviour
             rc = 0
+    except mosq_test.TestError:
+        pass
     finally:
         broker.terminate()
         broker.wait()

test/broker/02-subpub-qos2-bad-pubcomp.py

@@ -47,18 +47,20 @@ def do_test(proto_ver):
 
         helper(port, proto_ver)
 
-        if mosq_test.expect_packet(sock, "publish 1r", publish1r_packet):
-            sock.send(pubcomp1r_packet)
-            sock.send(pingreq_packet)
-            p = sock.recv(len(pingresp_packet))
-            if len(p) == 0:
-                rc = 0
+        mosq_test.expect_packet(sock, "publish 1r", publish1r_packet)
+        sock.send(pubcomp1r_packet)
+        sock.send(pingreq_packet)
+        p = sock.recv(len(pingresp_packet))
+        if len(p) == 0:
+            rc = 0
 
         sock.close()
     except socket.error as e:
         if e.errno == errno.ECONNRESET:
             # Connection has been closed by peer, this is the expected behaviour
             rc = 0
+    except mosq_test.TestError:
+        pass
     finally:
         broker.terminate()
         broker.wait()

test/broker/02-subpub-qos2-pubrec-error.py

@@ -60,15 +60,17 @@ def do_test():
         helper(port)
 
         # Should have now received a publish command
-        if mosq_test.expect_packet(sock, "publish 1", publish_1_packet):
-            sock.send(pubrec_1_packet)
+        mosq_test.expect_packet(sock, "publish 1", publish_1_packet)
+        sock.send(pubrec_1_packet)
 
-            if mosq_test.expect_packet(sock, "publish 2", publish_2_packet):
-                mosq_test.do_send_receive(sock, pubrec_2_packet, pubrel_2_packet, "pubrel 2")
-                sock.send(pubcomp_2_packet)
-                rc = 0
+        mosq_test.expect_packet(sock, "publish 2", publish_2_packet)
+        mosq_test.do_send_receive(sock, pubrec_2_packet, pubrel_2_packet, "pubrel 2")
+        sock.send(pubcomp_2_packet)
+        rc = 0
 
         sock.close()
+    except mosq_test.TestError:
+        pass
     finally:
         broker.terminate()
         broker.wait()

test/broker/02-subpub-qos2-receive-maximum-1.py

@@ -47,21 +47,23 @@ def do_test():
         pub.wait()
         (stdo, stde) = pub.communicate()
 
-        if mosq_test.expect_packet(sock, "publish1", publish_packet1):
-            mosq_test.do_send_receive(sock, pubrec_packet1, pubrel_packet1, "pubrel1")
-            sock.send(pubcomp_packet1)
+        mosq_test.expect_packet(sock, "publish1", publish_packet1)
+        mosq_test.do_send_receive(sock, pubrec_packet1, pubrel_packet1, "pubrel1")
+        sock.send(pubcomp_packet1)
 
-            if mosq_test.expect_packet(sock, "publish2", publish_packet2):
-                mosq_test.do_send_receive(sock, pubrec_packet2, pubrel_packet2, "pubrel2")
-                sock.send(pubcomp_packet2)
+        mosq_test.expect_packet(sock, "publish2", publish_packet2)
+        mosq_test.do_send_receive(sock, pubrec_packet2, pubrel_packet2, "pubrel2")
+        sock.send(pubcomp_packet2)
 
-                if mosq_test.expect_packet(sock, "publish3", publish_packet3):
-                    mosq_test.do_send_receive(sock, pubrec_packet3, pubrel_packet3, "pubrel3")
-                    sock.send(pubcomp_packet3)
+        mosq_test.expect_packet(sock, "publish3", publish_packet3)
+        mosq_test.do_send_receive(sock, pubrec_packet3, pubrel_packet3, "pubrel3")
+        sock.send(pubcomp_packet3)
 
-                    rc = 0
+        rc = 0
 
         sock.close()
+    except mosq_test.TestError:
+        pass
     finally:
         broker.terminate()
         broker.wait()

test/broker/02-subpub-qos2-receive-maximum-2.py

@@ -50,21 +50,23 @@ def do_test(proto_ver):
         pub.wait()
         (stdo, stde) = pub.communicate()
 
-        if mosq_test.expect_packet(sock, "publish1", publish_packet1):
-            if mosq_test.expect_packet(sock, "publish2", publish_packet2):
-                mosq_test.do_send_receive(sock, pubrec_packet1, pubrel_packet1, "pubrel1")
-                sock.send(pubcomp_packet1)
+        mosq_test.expect_packet(sock, "publish1", publish_packet1)
+        mosq_test.expect_packet(sock, "publish2", publish_packet2)
+        mosq_test.do_send_receive(sock, pubrec_packet1, pubrel_packet1, "pubrel1")
+        sock.send(pubcomp_packet1)
 
-                if mosq_test.expect_packet(sock, "publish3", publish_packet3):
-                    mosq_test.do_send_receive(sock, pubrec_packet2, pubrel_packet2, "pubrel2")
-                    sock.send(pubcomp_packet2)
+        mosq_test.expect_packet(sock, "publish3", publish_packet3)
+        mosq_test.do_send_receive(sock, pubrec_packet2, pubrel_packet2, "pubrel2")
+        sock.send(pubcomp_packet2)
 
-                    mosq_test.do_send_receive(sock, pubrec_packet3, pubrel_packet3, "pubrel3")
-                    sock.send(pubcomp_packet3)
+        mosq_test.do_send_receive(sock, pubrec_packet3, pubrel_packet3, "pubrel3")
+        sock.send(pubcomp_packet3)
 
-                    rc = 0
+        rc = 0
 
         sock.close()
+    except mosq_test.TestError:
+        pass
     finally:
         broker.terminate()
         broker.wait()

test/broker/02-subpub-qos2-receive-maximum-helper.py

@@ -49,6 +49,8 @@ def do_test(proto_ver):
         rc = 0
 
         sock.close()
+    except mosq_test.TestError:
+        pass
     finally:
         if rc:
             print(stde.decode('utf-8'))

test/broker/02-subpub-qos2.py

@@ -37,13 +37,15 @@ def do_test(proto_ver):
         mosq_test.do_send_receive(sock, publish_packet, pubrec_packet, "pubrec")
         mosq_test.do_send_receive(sock, pubrel_packet, pubcomp_packet, "pubcomp")
 
-        if mosq_test.expect_packet(sock, "publish2", publish_packet2):
-            mosq_test.do_send_receive(sock, pubrec_packet2, pubrel_packet2, "pubrel2")
-            sock.send(pubcomp_packet2)
-            # Broker side of flow complete so can quit here.
-            rc = 0
+        mosq_test.expect_packet(sock, "publish2", publish_packet2)
+        mosq_test.do_send_receive(sock, pubrec_packet2, pubrel_packet2, "pubrel2")
+        sock.send(pubcomp_packet2)
+        # Broker side of flow complete so can quit here.
+        rc = 0
 
         sock.close()
+    except mosq_test.TestError:
+        pass
     finally:
         broker.terminate()
         broker.wait()

test/broker/02-subscribe-dollar-v5.py

@@ -29,6 +29,8 @@ def do_test(proto_ver):
         rc = 0
 
         sock.close()
+    except mosq_test.TestError:
+        pass
     finally:
         broker.terminate()
         broker.wait()

test/broker/02-subscribe-invalid-utf8.py

@@ -34,6 +34,8 @@ def do_test(proto_ver):
         rc = 0
 
         sock.close()
+    except mosq_test.TestError:
+        pass
     finally:
         broker.terminate()
         broker.wait()

test/broker/02-subscribe-long-topic.py

@@ -30,6 +30,8 @@ def do_test(proto_ver):
         rc = 0
 
         sock.close()
+    except mosq_test.TestError:
+        pass
     finally:
         broker.terminate()
         broker.wait()

test/broker/02-subscribe-persistence-flipflop.py

@@ -69,10 +69,12 @@ def do_test(proto_ver):
         pub_sock = mosq_test.do_client_connect(connect_packet_pub, connack_packet_pub, port=port)
         mosq_test.do_send_receive(pub_sock, publish_packet, puback_packet, "publish")
 
-        if mosq_test.expect_packet(sub_sock, "publish receive", publish_packet):
-            rc = 0
+        mosq_test.expect_packet(sub_sock, "publish receive", publish_packet)
+        rc = 0
 
         sub_sock.close()
+    except mosq_test.TestError:
+        pass
     finally:
         broker.terminate()
         broker.wait()

test/broker/02-subscribe-qos0.py

@@ -26,6 +26,8 @@ def do_test(proto_ver):
         rc = 0
 
         sock.close()
+    except mosq_test.TestError:
+        pass
     finally:
         broker.terminate()
         broker.wait()

test/broker/02-subscribe-qos1.py

@@ -24,6 +24,8 @@ def do_test(proto_ver):
         rc = 0
 
         sock.close()
+    except mosq_test.TestError:
+        pass
     finally:
         broker.terminate()
         broker.wait()