monai-weekly 1.5.dev2505__py3-none-any.whl → 1.5.dev2507__py3-none-any.whl

tests/transforms/test_orientationd.py

@@ -0,0 +1,112 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import unittest
+
+import nibabel as nib
+import numpy as np
+import torch
+from parameterized import parameterized
+
+from monai.data.meta_obj import set_track_meta
+from monai.data.meta_tensor import MetaTensor
+from monai.transforms import Orientationd
+from tests.lazy_transforms_utils import test_resampler_lazy
+from tests.test_utils import TEST_DEVICES
+
+TESTS = []
+for device in TEST_DEVICES:
+    TESTS.append(
+        [{"keys": "seg", "axcodes": "RAS"}, torch.ones((2, 1, 2, 3)), torch.eye(4), (2, 1, 2, 3), "RAS", *device]
+    )
+    # 3d
+    TESTS.append(
+        [
+            {"keys": ["img", "seg"], "axcodes": "PLI"},
+            torch.ones((2, 1, 2, 3)),
+            torch.eye(4),
+            (2, 2, 1, 3),
+            "PLI",
+            *device,
+        ]
+    )
+    # 2d
+    TESTS.append(
+        [{"keys": ["img", "seg"], "axcodes": "PLI"}, torch.ones((2, 1, 3)), torch.eye(4), (2, 3, 1), "PLS", *device]
+    )
+    # 1d
+    TESTS.append([{"keys": ["img", "seg"], "axcodes": "L"}, torch.ones((2, 3)), torch.eye(4), (2, 3), "LAS", *device])
+    # canonical
+    TESTS.append(
+        [
+            {"keys": ["img", "seg"], "as_closest_canonical": True},
+            torch.ones((2, 1, 2, 3)),
+            torch.eye(4),
+            (2, 1, 2, 3),
+            "RAS",
+            *device,
+        ]
+    )
+
+TESTS_TORCH = []
+for track_meta in (False, True):
+    for device in TEST_DEVICES:
+        TESTS_TORCH.append([{"keys": "seg", "axcodes": "RAS"}, torch.ones(2, 1, 2, 3), track_meta, *device])
+
+
+class TestOrientationdCase(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_orntd(
+        self, init_param, img: torch.Tensor, affine: torch.Tensor | None, expected_shape, expected_code, device
+    ):
+        ornt = Orientationd(**init_param)
+        if affine is not None:
+            img = MetaTensor(img, affine=affine)
+        img = img.to(device)
+        call_param = {"data": {k: img.clone() for k in ornt.keys}}
+        res = ornt(**call_param)  # type: ignore[arg-type]
+        for k in ornt.keys:
+            if img.ndim in (3, 4):
+                test_resampler_lazy(ornt, res, init_param, call_param, output_key=k)
+            _im = res[k]
+            self.assertIsInstance(_im, MetaTensor)
+            np.testing.assert_allclose(_im.shape, expected_shape)
+            code = nib.aff2axcodes(_im.affine.cpu(), ornt.ornt_transform.labels)  # type: ignore
+            self.assertEqual("".join(code), expected_code)
+
+    @parameterized.expand(TESTS_TORCH)
+    def test_orntd_torch(self, init_param, img: torch.Tensor, track_meta: bool, device):
+        set_track_meta(track_meta)
+        ornt = Orientationd(**init_param)
+        img = img.to(device)
+        expected_shape = img.shape
+        expected_code = ornt.ornt_transform.axcodes
+        call_param = {"data": {k: img.clone() for k in ornt.keys}}
+        res = ornt(**call_param)  # type: ignore[arg-type]
+        for k in ornt.keys:
+            _im = res[k]
+            np.testing.assert_allclose(_im.shape, expected_shape)
+            if track_meta:
+                if img.ndim in (3, 4):
+                    test_resampler_lazy(ornt, res, init_param, call_param, output_key=k)
+                self.assertIsInstance(_im, MetaTensor)
+                assert isinstance(_im, MetaTensor)  # for mypy type narrowing
+                code = nib.aff2axcodes(_im.affine.cpu(), ornt.ornt_transform.labels)
+                self.assertEqual("".join(code), expected_code)
+            else:
+                self.assertIsInstance(_im, torch.Tensor)
+                self.assertNotIsInstance(_im, MetaTensor)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_rand_adjust_contrast.py

@@ -0,0 +1,45 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import unittest
+
+import numpy as np
+from parameterized import parameterized
+
+from monai.transforms import RandAdjustContrast
+from tests.test_utils import TEST_NDARRAYS, NumpyImageTestCase2D, assert_allclose
+
+TEST_CASE_1 = [(0.5, 4.5)]
+
+TEST_CASE_2 = [1.5]
+
+
+class TestRandAdjustContrast(NumpyImageTestCase2D):
+    @parameterized.expand([TEST_CASE_1, TEST_CASE_2])
+    def test_correct_results(self, gamma):
+        adjuster = RandAdjustContrast(prob=1.0, gamma=gamma)
+        for p in TEST_NDARRAYS:
+            im = p(self.imt)
+            result = adjuster(im)
+            epsilon = 1e-7
+            img_min = self.imt.min()
+            img_range = self.imt.max() - img_min
+            expected = (
+                np.power(((self.imt - img_min) / float(img_range + epsilon)), adjuster.gamma_value) * img_range
+                + img_min
+            )
+            assert_allclose(result, expected, rtol=1e-05, type_test=False)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_rand_adjust_contrastd.py

@@ -0,0 +1,44 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import unittest
+
+import numpy as np
+from parameterized import parameterized
+
+from monai.transforms import RandAdjustContrastd
+from tests.test_utils import TEST_NDARRAYS, NumpyImageTestCase2D, assert_allclose
+
+TEST_CASE_1 = [(0.5, 4.5)]
+
+TEST_CASE_2 = [1.5]
+
+
+class TestRandAdjustContrastd(NumpyImageTestCase2D):
+    @parameterized.expand([TEST_CASE_1, TEST_CASE_2])
+    def test_correct_results(self, gamma):
+        adjuster = RandAdjustContrastd("img", prob=1.0, gamma=gamma)
+        for p in TEST_NDARRAYS:
+            result = adjuster({"img": p(self.imt)})
+            epsilon = 1e-7
+            img_min = self.imt.min()
+            img_range = self.imt.max() - img_min
+            expected = (
+                np.power(((self.imt - img_min) / float(img_range + epsilon)), adjuster.adjuster.gamma_value) * img_range
+                + img_min
+            )
+            assert_allclose(result["img"], expected, rtol=1e-05, type_test="tensor")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_rand_affine.py

@@ -0,0 +1,201 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import unittest
+
+import numpy as np
+import torch
+from parameterized import parameterized
+
+from monai.transforms import RandAffine
+from monai.utils.type_conversion import convert_data_type
+from tests.lazy_transforms_utils import test_resampler_lazy
+from tests.test_utils import TEST_NDARRAYS_ALL, assert_allclose, is_tf32_env
+
+_rtol = 1e-3 if is_tf32_env() else 1e-4
+
+TESTS = []
+for p in TEST_NDARRAYS_ALL:
+    for device in [None, "cpu", "cuda"] if torch.cuda.is_available() else [None, "cpu"]:
+        TESTS.append(
+            [dict(device=device), {"img": p(torch.arange(27).reshape((3, 3, 3)))}, p(np.arange(27).reshape((3, 3, 3)))]
+        )
+        TESTS.append(
+            [
+                dict(device=device, spatial_size=-1),
+                {"img": p(torch.arange(27).reshape((3, 3, 3)))},
+                p(np.arange(27).reshape((3, 3, 3))),
+            ]
+        )
+        TESTS.append(
+            [
+                dict(device=device),
+                {"img": p(torch.arange(27).reshape((3, 3, 3))), "spatial_size": (2, 2)},
+                p(np.array([[[2.0, 3.0], [5.0, 6.0]], [[11.0, 12.0], [14.0, 15.0]], [[20.0, 21.0], [23.0, 24.0]]])),
+            ]
+        )
+        TESTS.append(
+            [
+                dict(device=device),
+                {"img": p(torch.ones((1, 3, 3, 3))), "spatial_size": (2, 2, 2)},
+                p(torch.ones((1, 2, 2, 2))),
+            ]
+        )
+        TESTS.append(
+            [
+                dict(device=device, spatial_size=(2, 2, 2), cache_grid=True),
+                {"img": p(torch.ones((1, 3, 3, 3)))},
+                p(torch.ones((1, 2, 2, 2))),
+            ]
+        )
+        TESTS.append(
+            [
+                dict(
+                    prob=0.9,
+                    rotate_range=(np.pi / 2,),
+                    shear_range=[1, 2],
+                    translate_range=[2, 1],
+                    padding_mode="zeros",
+                    spatial_size=(2, 2, 2),
+                    device=device,
+                ),
+                {"img": p(torch.ones((1, 3, 3, 3))), "mode": "bilinear"},
+                p(torch.tensor([[[[0.3658, 1.0000], [1.0000, 1.0000]], [[1.0000, 1.0000], [1.0000, 0.9333]]]])),
+            ]
+        )
+        TESTS.append(
+            [
+                dict(
+                    prob=0.9,
+                    rotate_range=(np.pi / 2,),
+                    shear_range=[1, 2],
+                    translate_range=[2, 1],
+                    padding_mode="zeros",
+                    spatial_size=(2, 2, 2),
+                    cache_grid=True,
+                    device=device,
+                ),
+                {"img": p(torch.ones((1, 3, 3, 3))), "mode": "bilinear"},
+                p(torch.tensor([[[[0.3658, 1.0000], [1.0000, 1.0000]], [[1.0000, 1.0000], [1.0000, 0.9333]]]])),
+            ]
+        )
+        TESTS.append(
+            [
+                dict(
+                    prob=0.9,
+                    rotate_range=(np.pi / 2,),
+                    shear_range=[1, 2],
+                    translate_range=[2, 1],
+                    scale_range=[0.1, 0.2],
+                    device=device,
+                ),
+                {"img": p(torch.arange(64).reshape((1, 8, 8))), "spatial_size": (3, 3)},
+                p(
+                    torch.tensor(
+                        [[[18.7362, 15.5820, 12.4278], [27.3988, 24.2446, 21.0904], [36.0614, 32.9072, 29.7530]]]
+                    )
+                ),
+            ]
+        )
+        TESTS.append(
+            [
+                dict(
+                    prob=0.9,
+                    rotate_range=(np.pi / 2,),
+                    shear_range=[1, 2],
+                    translate_range=[2, 1],
+                    scale_range=[0.1, 0.2],
+                    spatial_size=(3, 3),
+                    cache_grid=True,
+                    device=device,
+                ),
+                {"img": p(torch.arange(64).reshape((1, 8, 8)))},
+                p(
+                    torch.tensor(
+                        [[[18.7362, 15.5820, 12.4278], [27.3988, 24.2446, 21.0904], [36.0614, 32.9072, 29.7530]]]
+                    )
+                ),
+            ]
+        )
+
+TEST_CASES_SKIPPED_CONSISTENCY = []
+for p in TEST_NDARRAYS_ALL:
+    for in_dtype in (np.int32, np.float32):
+        TEST_CASES_SKIPPED_CONSISTENCY.append((p(np.arange(9 * 10).reshape(1, 9, 10)), in_dtype))
+
+TEST_RANDOMIZE = []
+for cache_grid in (False, True):
+    for initial_randomize in (False, True):
+        TEST_RANDOMIZE.append((initial_randomize, cache_grid))
+
+
+class TestRandAffine(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_rand_affine(self, input_param, input_data, expected_val):
+        g = RandAffine(**input_param)
+        g.set_random_state(123)
+        result = g(**input_data)
+        g.rand_affine_grid.affine = torch.eye(4, dtype=torch.float64)  # reset affine
+        test_resampler_lazy(g, result, input_param, input_data, seed=123, rtol=_rtol)
+        if input_param.get("cache_grid", False):
+            self.assertTrue(g._cached_grid is not None)
+        assert_allclose(result, expected_val, rtol=_rtol, atol=1e-4, type_test="tensor")
+
+    @parameterized.expand([(None,), ((1, 1, -1),)])
+    def test_ill_cache(self, spatial_size):
+        with self.assertWarns(UserWarning):
+            RandAffine(cache_grid=True, spatial_size=spatial_size)
+
+    @parameterized.expand(TEST_CASES_SKIPPED_CONSISTENCY)
+    def test_skipped_transform_consistency(self, im, in_dtype):
+        t1 = RandAffine(prob=0)
+        t2 = RandAffine(prob=1, spatial_size=(10, 11))
+
+        im, *_ = convert_data_type(im, dtype=in_dtype)
+
+        out1 = t1(im)
+        out2 = t2(im)
+
+        # check same type
+        self.assertEqual(type(out1), type(out2))
+        # check matching dtype
+        self.assertEqual(out1.dtype, out2.dtype)
+
+    @parameterized.expand(TEST_RANDOMIZE)
+    def test_no_randomize(self, initial_randomize, cache_grid):
+        rand_affine = RandAffine(
+            prob=1,
+            rotate_range=(np.pi / 6, 0, 0),
+            translate_range=((-2, 2), (-2, 2), (-2, 2)),
+            scale_range=((-0.1, 0.1), (-0.1, 0.1), (-0.1, 0.1)),
+            spatial_size=(16, 16, 16),
+            cache_grid=cache_grid,
+            padding_mode="zeros",
+        )
+        if initial_randomize:
+            rand_affine.randomize(None)
+
+        arr = torch.randn((1, 16, 16, 16)) * 100
+
+        arr1 = rand_affine(arr, randomize=False)
+        m1 = rand_affine.rand_affine_grid.get_transformation_matrix()
+
+        arr2 = rand_affine(arr, randomize=False)
+        m2 = rand_affine.rand_affine_grid.get_transformation_matrix()
+
+        assert_allclose(m1, m2)
+        assert_allclose(arr1, arr2)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_rand_affine_grid.py

@@ -0,0 +1,212 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import unittest
+
+import numpy as np
+import torch
+from parameterized import parameterized
+
+from monai.transforms import RandAffineGrid
+from tests.test_utils import TEST_NDARRAYS_ALL, assert_allclose, is_tf32_env
+
+_rtol = 1e-1 if is_tf32_env() else 1e-4
+
+TESTS = []
+for p in TEST_NDARRAYS_ALL:
+    for device in [None, "cpu", "cuda"] if torch.cuda.is_available() else [None, "cpu"]:
+        TESTS.append([{"device": device}, {"grid": p(torch.ones((3, 3, 3)))}, p(np.ones((3, 3, 3)))])
+        TESTS.append(
+            [
+                {"rotate_range": (1, 2), "translate_range": (3, 3, 3)},
+                {"grid": p(torch.arange(0, 27).reshape((3, 3, 3)))},
+                p(
+                    np.array(
+                        [
+                            [
+                                [-32.81998, -33.910976, -35.001972],
+                                [-36.092968, -37.183964, -38.27496],
+                                [-39.36596, -40.456955, -41.54795],
+                            ],
+                            [
+                                [2.1380205, 3.1015975, 4.0651755],
+                                [5.028752, 5.9923296, 6.955907],
+                                [7.919484, 8.883063, 9.84664],
+                            ],
+                            [[18.0, 19.0, 20.0], [21.0, 22.0, 23.0], [24.0, 25.0, 26.0]],
+                        ]
+                    )
+                ),
+            ]
+        )
+        TESTS.append(
+            [
+                {"translate_range": (3, 3, 3), "device": device},
+                {"spatial_size": (3, 3, 3)},
+                np.array(
+                    [
+                        [
+                            [
+                                [0.17881513, 0.17881513, 0.17881513],
+                                [0.17881513, 0.17881513, 0.17881513],
+                                [0.17881513, 0.17881513, 0.17881513],
+                            ],
+                            [
+                                [1.1788151, 1.1788151, 1.1788151],
+                                [1.1788151, 1.1788151, 1.1788151],
+                                [1.1788151, 1.1788151, 1.1788151],
+                            ],
+                            [
+                                [2.1788151, 2.1788151, 2.1788151],
+                                [2.1788151, 2.1788151, 2.1788151],
+                                [2.1788151, 2.1788151, 2.1788151],
+                            ],
+                        ],
+                        [
+                            [
+                                [-2.283164, -2.283164, -2.283164],
+                                [-1.283164, -1.283164, -1.283164],
+                                [-0.28316402, -0.28316402, -0.28316402],
+                            ],
+                            [
+                                [-2.283164, -2.283164, -2.283164],
+                                [-1.283164, -1.283164, -1.283164],
+                                [-0.28316402, -0.28316402, -0.28316402],
+                            ],
+                            [
+                                [-2.283164, -2.283164, -2.283164],
+                                [-1.283164, -1.283164, -1.283164],
+                                [-0.28316402, -0.28316402, -0.28316402],
+                            ],
+                        ],
+                        [
+                            [
+                                [-2.6388912, -1.6388912, -0.6388912],
+                                [-2.6388912, -1.6388912, -0.6388912],
+                                [-2.6388912, -1.6388912, -0.6388912],
+                            ],
+                            [
+                                [-2.6388912, -1.6388912, -0.6388912],
+                                [-2.6388912, -1.6388912, -0.6388912],
+                                [-2.6388912, -1.6388912, -0.6388912],
+                            ],
+                            [
+                                [-2.6388912, -1.6388912, -0.6388912],
+                                [-2.6388912, -1.6388912, -0.6388912],
+                                [-2.6388912, -1.6388912, -0.6388912],
+                            ],
+                        ],
+                        [
+                            [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+                            [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+                            [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+                        ],
+                    ]
+                ),
+            ]
+        )
+        TESTS.append(
+            [
+                {"device": device, "rotate_range": (1.0, 1.0, 1.0), "shear_range": (0.1,), "scale_range": (1.2,)},
+                {"grid": p(torch.arange(0, 108).reshape((4, 3, 3, 3)))},
+                p(
+                    np.array(
+                        [
+                            [
+                                [
+                                    [-9.4201e00, -8.1672e00, -6.9143e00],
+                                    [-5.6614e00, -4.4085e00, -3.1556e00],
+                                    [-1.9027e00, -6.4980e-01, 6.0310e-01],
+                                ],
+                                [
+                                    [1.8560e00, 3.1089e00, 4.3618e00],
+                                    [5.6147e00, 6.8676e00, 8.1205e00],
+                                    [9.3734e00, 1.0626e01, 1.1879e01],
+                                ],
+                                [
+                                    [1.3132e01, 1.4385e01, 1.5638e01],
+                                    [1.6891e01, 1.8144e01, 1.9397e01],
+                                    [2.0650e01, 2.1902e01, 2.3155e01],
+                                ],
+                            ],
+                            [
+                                [
+                                    [9.9383e-02, -4.8845e-01, -1.0763e00],
+                                    [-1.6641e00, -2.2519e00, -2.8398e00],
+                                    [-3.4276e00, -4.0154e00, -4.6032e00],
+                                ],
+                                [
+                                    [-5.1911e00, -5.7789e00, -6.3667e00],
+                                    [-6.9546e00, -7.5424e00, -8.1302e00],
+                                    [-8.7180e00, -9.3059e00, -9.8937e00],
+                                ],
+                                [
+                                    [-1.0482e01, -1.1069e01, -1.1657e01],
+                                    [-1.2245e01, -1.2833e01, -1.3421e01],
+                                    [-1.4009e01, -1.4596e01, -1.5184e01],
+                                ],
+                            ],
+                            [
+                                [
+                                    [5.9635e01, 6.1199e01, 6.2764e01],
+                                    [6.4328e01, 6.5892e01, 6.7456e01],
+                                    [6.9021e01, 7.0585e01, 7.2149e01],
+                                ],
+                                [
+                                    [7.3714e01, 7.5278e01, 7.6842e01],
+                                    [7.8407e01, 7.9971e01, 8.1535e01],
+                                    [8.3099e01, 8.4664e01, 8.6228e01],
+                                ],
+                                [
+                                    [8.7792e01, 8.9357e01, 9.0921e01],
+                                    [9.2485e01, 9.4049e01, 9.5614e01],
+                                    [9.7178e01, 9.8742e01, 1.0031e02],
+                                ],
+                            ],
+                            [
+                                [
+                                    [8.1000e01, 8.2000e01, 8.3000e01],
+                                    [8.4000e01, 8.5000e01, 8.6000e01],
+                                    [8.7000e01, 8.8000e01, 8.9000e01],
+                                ],
+                                [
+                                    [9.0000e01, 9.1000e01, 9.2000e01],
+                                    [9.3000e01, 9.4000e01, 9.5000e01],
+                                    [9.6000e01, 9.7000e01, 9.8000e01],
+                                ],
+                                [
+                                    [9.9000e01, 1.0000e02, 1.0100e02],
+                                    [1.0200e02, 1.0300e02, 1.0400e02],
+                                    [1.0500e02, 1.0600e02, 1.0700e02],
+                                ],
+                            ],
+                        ]
+                    )
+                ),
+            ]
+        )
+
+
+class TestRandAffineGrid(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_rand_affine_grid(self, input_param, input_data, expected_val):
+        g = RandAffineGrid(**input_param)
+        g.set_random_state(123)
+        result = g(**input_data)
+        if "device" in input_data:
+            self.assertEqual(result.device, input_data[device])
+        assert_allclose(result, expected_val, type_test=False, rtol=_rtol, atol=1e-4)
+
+
+if __name__ == "__main__":
+    unittest.main()