Increase test coverage.

Author: yilei

test/test_numpy.py

@@ -1076,6 +1076,29 @@ def test_numpy_datetime_nat(self):
         with pytest.raises(orjson.JSONEncodeError):
             orjson.dumps([numpy.datetime64("NaT")], option=orjson.OPT_SERIALIZE_NUMPY)
 
+    def test_numpy_array_d0_float16(self):
+        array = numpy.array(numpy.float16(1.5))
+        assert orjson.dumps(array, option=orjson.OPT_SERIALIZE_NUMPY) == b'1.5'
+
+    def test_numpy_array_d0_nan_inf(self):
+        assert orjson.dumps(numpy.array(numpy.nan), option=orjson.OPT_SERIALIZE_NUMPY) == b'NaN'
+        assert orjson.dumps(numpy.array(numpy.inf), option=orjson.OPT_SERIALIZE_NUMPY) == b'Infinity'
+        assert orjson.dumps(numpy.array(-numpy.inf), option=orjson.OPT_SERIALIZE_NUMPY) == b'-Infinity'
+
+    def test_numpy_array_d0_unsigned(self):
+        for dtype in [numpy.uint8, numpy.uint16, numpy.uint32, numpy.uint64]:
+            array = numpy.array(42, dtype=dtype)
+            assert orjson.loads(orjson.dumps(array, option=orjson.OPT_SERIALIZE_NUMPY)) == 42
+
+    def test_numpy_array_d0_signed(self):
+        for dtype in [numpy.int8, numpy.int16, numpy.int32]:
+            array = numpy.array(-7, dtype=dtype)
+            assert orjson.loads(orjson.dumps(array, option=orjson.OPT_SERIALIZE_NUMPY)) == -7
+
+    def test_numpy_array_d0_datetime64(self):
+        array = numpy.array(numpy.datetime64("2021-01-01"))
+        assert orjson.dumps(array, option=orjson.OPT_SERIALIZE_NUMPY) == b'"2021-01-01T00:00:00"'
+
     def test_numpy_repeated(self):
         data = numpy.array([[[1, 2], [3, 4], [5, 6], [7, 8]]], numpy.int64)  # type: ignore
         for _ in range(3):

test/test_pytorch.py

@@ -1,4 +1,5 @@
 import unittest
+from unittest.mock import MagicMock
 
 import orjson
 import pytest
@@ -123,3 +124,67 @@ def test_tensor_special_values(self):
             orjson.dumps(data, option=orjson.OPT_SERIALIZE_NUMPY),
             b'{"nan":NaN,"inf":Infinity,"neg_inf":-Infinity,"mixed":[1.0,NaN,Infinity,-Infinity]}'
         )
+
+    def test_tensor_in_list(self):
+        """PyTorch tensor as element in a Python list"""
+        assert orjson.dumps([torch.tensor([1, 2])], option=orjson.OPT_SERIALIZE_NUMPY) == b'[[1,2]]'
+
+    def test_tensor_3d(self):
+        """3D tensor"""
+        tensor = torch.zeros(2, 3, 4)
+        result = orjson.loads(orjson.dumps(tensor, option=orjson.OPT_SERIALIZE_NUMPY))
+        assert len(result) == 2 and len(result[0]) == 3 and len(result[0][0]) == 4
+
+    def test_tensor_dtypes(self):
+        """Various tensor dtypes"""
+        for dtype in [torch.float16, torch.float64, torch.int8, torch.int16, torch.int32]:
+            tensor = torch.tensor([1, 2, 3], dtype=dtype)
+            result = orjson.loads(orjson.dumps(tensor, option=orjson.OPT_SERIALIZE_NUMPY))
+            for i, v in enumerate(result):
+                assert abs(v - [1, 2, 3][i]) < 0.01
+
+    def test_non_torch_duck_type(self):
+        """Object with numpy/cpu/detach but __module__ not 'torch' is not treated as tensor"""
+        class FakeTensor:
+            def numpy(self): return [1, 2]
+            def cpu(self): return self
+            def detach(self): return self
+        with self.assertRaises(orjson.JSONEncodeError):
+            orjson.dumps(FakeTensor(), option=orjson.OPT_SERIALIZE_NUMPY)
+
+    def test_magicmock_not_tensor(self):
+        """MagicMock not detected as PyTorch tensor (post4 fix)"""
+        with self.assertRaises(orjson.JSONEncodeError):
+            orjson.dumps(MagicMock(), option=orjson.OPT_SERIALIZE_NUMPY)
+
+    def test_tensor_pretty(self):
+        """PyTorch tensor with OPT_INDENT_2"""
+        tensor = torch.tensor([[1, 2], [3, 4]])
+        result = orjson.dumps(tensor, option=orjson.OPT_SERIALIZE_NUMPY | orjson.OPT_INDENT_2)
+        assert result == b'[\n  [\n    1,\n    2\n  ],\n  [\n    3,\n    4\n  ]\n]'
+
+    def test_tensor_conversion_failure(self):
+        """Sparse tensor fails numpy conversion - PyTorchTensorConversion error"""
+        t = torch.sparse_coo_tensor(torch.tensor([[0, 1]]), torch.tensor([1.0, 2.0]), (3,))
+        with self.assertRaises(orjson.JSONEncodeError) as cm:
+            orjson.dumps(t, option=orjson.OPT_SERIALIZE_NUMPY)
+        assert "failed to convert PyTorch tensor to numpy array" in str(cm.exception)
+
+    def test_tensor_conversion_failure_with_default(self):
+        """Sparse tensor with default callback falls back to default"""
+        t = torch.sparse_coo_tensor(torch.tensor([[0, 1]]), torch.tensor([1.0, 2.0]), (3,))
+        result = orjson.dumps(t, option=orjson.OPT_SERIALIZE_NUMPY, default=lambda x: "fallback")
+        assert result == b'"fallback"'
+
+    def test_tensor_unsupported_numpy_dtype(self):
+        """Complex tensor: numpy() succeeds but numpy dtype is unsupported"""
+        tensor = torch.tensor([1+2j, 3+4j])
+        with self.assertRaises(orjson.JSONEncodeError) as cm:
+            orjson.dumps(tensor, option=orjson.OPT_SERIALIZE_NUMPY)
+        assert "unsupported datatype in numpy array" in str(cm.exception)
+
+    def test_tensor_unsupported_numpy_dtype_with_default(self):
+        """Complex tensor with default: falls back to default via numpy unsupported path"""
+        tensor = torch.tensor([1+2j, 3+4j])
+        result = orjson.dumps(tensor, option=orjson.OPT_SERIALIZE_NUMPY, default=lambda x: str(x))
+        assert len(result) > 0

test/test_type.py

@@ -548,6 +548,46 @@ def test_tuple(self):
         assert orjson.dumps(obj) == ref.encode("utf-8")
         assert orjson.loads(ref) == list(obj)
 
+    def test_nan_inf_in_list(self):
+        """NaN/Infinity in a list"""
+        assert orjson.dumps([1.0, float("nan"), float("inf"), float("-inf")]) == b'[1.0,NaN,Infinity,-Infinity]'
+
+    def test_nan_inf_in_dict_value(self):
+        """NaN/Infinity as dict values"""
+        assert orjson.dumps({"a": float("nan")}) == b'{"a":NaN}'
+        assert orjson.dumps({"b": float("inf")}) == b'{"b":Infinity}'
+        assert orjson.dumps({"c": float("-inf")}) == b'{"c":-Infinity}'
+
+    def test_nan_inf_pretty(self):
+        """NaN/Infinity with OPT_INDENT_2"""
+        assert orjson.dumps({"val": float("nan"), "inf": float("inf")}, option=orjson.OPT_INDENT_2) == b'{\n  "val": NaN,\n  "inf": Infinity\n}'
+
+    def test_nan_inf_roundtrip(self):
+        """NaN/Infinity roundtrip through dumps/loads"""
+        assert math.isnan(orjson.loads(orjson.dumps(float("nan"))))
+        assert orjson.loads(orjson.dumps(float("inf"))) == float("inf")
+        assert orjson.loads(orjson.dumps(float("-inf"))) == float("-inf")
+
+    def test_nan_loads_top_level(self):
+        """NaN/Infinity as top-level JSON values"""
+        assert math.isnan(orjson.loads("NaN"))
+        assert orjson.loads("Infinity") == float("inf")
+        assert orjson.loads("-Infinity") == float("-inf")
+
+    def test_nan_loads_in_object(self):
+        """NaN/Infinity inside JSON objects"""
+        result = orjson.loads('{"a":NaN,"b":Infinity,"c":-Infinity}')
+        assert math.isnan(result["a"])
+        assert result["b"] == float("inf")
+        assert result["c"] == float("-inf")
+
+    def test_nan_loads_bytes(self):
+        """NaN/Infinity from bytes, bytearray, memoryview"""
+        for val in [b"[NaN]", bytearray(b"[NaN]"), memoryview(b"[NaN]")]:
+            assert math.isnan(orjson.loads(val)[0])
+        for val in [b"[Infinity]", bytearray(b"[Infinity]"), memoryview(b"[Infinity]")]:
+            assert orjson.loads(val)[0] == float("inf")
+
     def test_object(self):
         """
         object() dumps()