Add tests for rcs380 listen_ttf.

src/nfc/clf/rcs380.py

@@ -542,16 +542,20 @@ def listen_tta(self, target, timeout):
             info = "listening for type 1 tag activation is not supported"
             raise nfc.clf.UnsupportedTargetError(info)
 
-        try:
-            assert target.sens_res is not None, "sens_res is required"
-            assert target.sdd_res is not None, "sdd_res is required"
-            assert target.sel_res is not None, "sel_res is required"
-            assert len(target.sens_res) == 2, "sens_res must be 2 byte"
-            assert len(target.sdd_res) == 4, "sdd_res must be 4 byte"
-            assert len(target.sel_res) == 1, "sel_res must be 1 byte"
-            assert target.sdd_res[0] == 0x08, "sdd_res[0] must be 08h"
-        except AssertionError as error:
-            raise ValueError(str(error))
+        if target.sens_res is None:
+            raise ValueError("sens_res is required")
+        if target.sdd_res is None:
+            raise ValueError("sdd_res is required")
+        if target.sel_res is None:
+            raise ValueError("sel_res is required")
+        if len(target.sens_res) != 2:
+            raise ValueError("sens_res must be 2 byte")
+        if len(target.sdd_res) != 4:
+            raise ValueError("sdd_res must be 4 byte")
+        if len(target.sel_res) != 1:
+            raise ValueError("sel_res must be 1 byte")
+        if target.sdd_res[0] != 0x08:
+            raise ValueError("sdd_res[0] must be 08h")
 
         nfca_params = target.sens_res + target.sdd_res[1:4] + target.sel_res
         log.debug("nfca_params %s", hexlify(nfca_params))
@@ -665,13 +669,15 @@ def listen_ttb(self, target, timeout):
 
     def listen_ttf(self, target, timeout):
         """Listen as Type F Target is supported for either 212 or 424 kbps."""
-        assert target.sensf_res is not None
-        assert len(target.sensf_res) == 19
-
         if target.brty not in ('212F', '424F'):
             info = "unsupported target bitrate: %r" % target.brty
             raise nfc.clf.UnsupportedTargetError(info)
 
+        if target.sensf_res is None:
+            raise ValueError("sensf_res is required")
+        if len(target.sensf_res) != 19:
+            raise ValueError("sensf_res must be 19 byte")
+
         self.chipset.tg_set_rf(target.brty)
         self.chipset.tg_set_protocol(self.chipset.tg_set_protocol_defaults)
         self.chipset.tg_set_protocol(rf_off_error=False)

tests/test_clf_rcs380.py

@@ -1227,3 +1227,59 @@ def test_listen_ttb_is_not_supported(self, device):
             device.listen_ttb(nfc.clf.LocalTarget('106B'), 1.0)
         assert str(excinfo.value) == "NFC Port-100 v1.11 at usb:001:001 " \
             "does not support listen as Type A Target"
+
+    @pytest.mark.parametrize("target, errmsg", [
+        (nfc.clf.LocalTarget('106F'), "unsupported target bitrate: '106F'"),
+    ])
+    def test_listen_ttf_target_not_supported(self, device, target, errmsg):
+        with pytest.raises(nfc.clf.UnsupportedTargetError) as excinfo:
+            device.listen_ttf(target, 1.0)
+        assert str(excinfo.value) == errmsg
+
+    @pytest.mark.parametrize("target, errmsg", [
+        (nfc.clf.LocalTarget('212F'),
+         "sensf_res is required"),
+        (nfc.clf.LocalTarget('212F', sensf_res=b''),
+         "sensf_res must be 19 byte"),
+    ])
+    def test_listen_ttf_target_value_error(self, device, target, errmsg):
+        with pytest.raises(ValueError) as excinfo:
+            device.listen_ttf(target, 1.0)
+        assert str(excinfo.value) == errmsg
+
+    def test_listen_ttf_timeout_waiting_for_activation(self, device):
+        device.chipset.transport.read.side_effect = [
+            ACK(), RSP('4100'),
+            ACK(), RSP('4300'),
+            ACK(), RSP('4300'),
+            ACK(), RSP('490c000080000000'),
+        ]
+        target = nfc.clf.LocalTarget('212F')
+        target.sensf_res = HEX("01 0102030405060708 FFFFFFFFFFFFFFFF 12FC")
+        assert device.listen_ttf(target, 0.001) is None
+        assert device.chipset.transport.read.call_count == 8
+
+    @pytest.mark.parametrize("sensf_req", [
+        '00ffff0100', '00ffff0200', '0012fc0000',
+    ])
+    def test_listen_ttf_received_sensf_request(self, device, sensf_req):
+        sensf_res = '01 0102030405060708 FFFFFFFFFFFFFFFF 12FC'
+        device.chipset.transport.read.side_effect = [
+            ACK(), RSP('4100'),
+            ACK(), RSP('4300'),
+            ACK(), RSP('4300'),
+            ACK(), RSP('490c000000000000'),
+            ACK(), RSP('490c000000000000 060011220000'),
+            ACK(), RSP('490c000000000000 06' + sensf_req),
+            ACK(), RSP('490c000000000000 0a040102030405060708'),
+            ACK(), RSP('4300'),
+        ]
+        target = nfc.clf.LocalTarget('212F')
+        target.sensf_res = HEX(sensf_res)
+        target = device.listen_ttf(target, 1.0)
+        assert isinstance(target, nfc.clf.LocalTarget)
+        assert target.brty == '212F'
+        assert target.sensf_req == HEX(sensf_req)
+        assert target.sensf_res == HEX(sensf_res)
+        assert target.tt3_cmd == HEX('040102030405060708')
+        assert device.chipset.transport.read.call_count == 16