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

tests/apps/reconstruction/transforms/test_reference_based_spatial_cropd.py

@@ -0,0 +1,57 @@
+# 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.apps.reconstruction.transforms.dictionary import ReferenceBasedSpatialCropd
+from tests.test_utils import TEST_NDARRAYS
+
+# see test_spatial_cropd for typical tests (like roi_start,
+# roi_slices, etc.)
+# here, we test TargetBasedSpatialCropd's functionality
+# which focuses on automatic input crop based on target image's shape.
+
+TESTS = []
+for p in TEST_NDARRAYS:
+    # 2D
+    TESTS.append(
+        [
+            {"keys": ["kspace_masked_ifft"], "ref_key": "target"},
+            {"kspace_masked_ifft": p(np.ones([10, 20, 20])), "target": p(np.ones([5, 8, 8]))},
+            (8, 8),  # expected shape
+        ]
+    )
+
+    # 3D
+    TESTS.append(
+        [
+            {"keys": ["kspace_masked_ifft"], "ref_key": "target"},
+            {"kspace_masked_ifft": p(np.ones([10, 20, 20, 16])), "target": p(np.ones([5, 8, 8, 6]))},
+            (8, 8, 6),  # expected shape
+        ]
+    )
+
+
+class TestTargetBasedSpatialCropd(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_shape(self, args, data, expected_shape):
+        cropper = ReferenceBasedSpatialCropd(keys=args["keys"], ref_key=args["ref_key"])
+        res_data = cropper(data)
+        self.assertTupleEqual(res_data[args["keys"][0]].shape[1:], expected_shape)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/apps/test_auto3dseg_bundlegen.py

@@ -0,0 +1,156 @@
+# 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 os
+import shutil
+import sys
+import tempfile
+import unittest
+
+import nibabel as nib
+import numpy as np
+import torch
+
+from monai.apps.auto3dseg import BundleGen, DataAnalyzer
+from monai.apps.auto3dseg.utils import export_bundle_algo_history, import_bundle_algo_history
+from monai.bundle.config_parser import ConfigParser
+from monai.data import create_test_image_3d
+from monai.utils import set_determinism
+from tests.test_utils import (
+    SkipIfBeforePyTorchVersion,
+    get_testing_algo_template_path,
+    skip_if_downloading_fails,
+    skip_if_no_cuda,
+    skip_if_quick,
+)
+
+num_images_perfold = max(torch.cuda.device_count(), 4)
+num_images_per_batch = 2
+
+sim_datalist: dict[str, list[dict]] = {
+    "testing": [{"image": "val_001.fake.nii.gz"}, {"image": "val_002.fake.nii.gz"}],
+    "training": [
+        {
+            "fold": f,
+            "image": f"tr_image_{(f * num_images_perfold + idx):03d}.nii.gz",
+            "label": f"tr_label_{(f * num_images_perfold + idx):03d}.nii.gz",
+        }
+        for f in range(num_images_per_batch + 1)
+        for idx in range(num_images_perfold)
+    ],
+}
+
+
+def create_sim_data(dataroot, sim_datalist, sim_dim, **kwargs):
+    """
+    Create simulated data using create_test_image_3d.
+
+    Args:
+        dataroot: data directory path that hosts the "nii.gz" image files.
+        sim_datalist: a list of data to create.
+        sim_dim: the image sizes, e.g. a tuple of (64, 64, 64).
+    """
+    if not os.path.isdir(dataroot):
+        os.makedirs(dataroot)
+
+    # Generate a fake dataset
+    for d in sim_datalist["testing"] + sim_datalist["training"]:
+        im, seg = create_test_image_3d(sim_dim[0], sim_dim[1], sim_dim[2], **kwargs)
+        nib_image = nib.Nifti1Image(im, affine=np.eye(4))
+        image_fpath = os.path.join(dataroot, d["image"])
+        nib.save(nib_image, image_fpath)
+
+        if "label" in d:
+            nib_image = nib.Nifti1Image(seg, affine=np.eye(4))
+            label_fpath = os.path.join(dataroot, d["label"])
+            nib.save(nib_image, label_fpath)
+
+
+def run_auto3dseg_before_bundlegen(test_path, work_dir):
+    """
+    Run the Auto3DSeg modules before the BundleGen step.
+    Args:
+        test_path: a path to contain `sim_dataroot` which is for the simulated dataset file.
+        work_dir: working directory
+
+    Returns:
+        Paths of the outputs from the previous steps
+    """
+
+    if not os.path.isdir(work_dir):
+        os.makedirs(work_dir)
+
+    # write to a json file
+    dataroot_dir = os.path.join(test_path, "sim_dataroot")
+    datalist_file = os.path.join(work_dir, "sim_datalist.json")
+    ConfigParser.export_config_file(sim_datalist, datalist_file)
+    create_sim_data(dataroot_dir, sim_datalist, (24, 24, 24), rad_max=10, rad_min=1, num_seg_classes=1)
+
+    datastats_file = os.path.join(work_dir, "datastats.yaml")
+    analyser = DataAnalyzer(datalist_file, dataroot_dir, output_path=os.path.join(work_dir, "datastats.yaml"))
+    analyser.get_all_case_stats()
+
+    return dataroot_dir, datalist_file, datastats_file
+
+
+@skip_if_no_cuda
+@SkipIfBeforePyTorchVersion((1, 11, 1))
+@skip_if_quick
+class TestBundleGen(unittest.TestCase):
+    def setUp(self) -> None:
+        set_determinism(0)
+        self.test_dir = tempfile.TemporaryDirectory()
+
+    def test_move_bundle_gen_folder(self) -> None:
+        test_path = self.test_dir.name
+        work_dir = os.path.join(test_path, "workdir")
+        dataroot_dir, datalist_file, datastats_file = run_auto3dseg_before_bundlegen(test_path, work_dir)
+        data_src = {
+            "name": "fake_data",
+            "task": "segmentation",
+            "modality": "MRI",
+            "datalist": datalist_file,
+            "dataroot": dataroot_dir,
+            "multigpu": False,
+            "class_names": ["label_class"],
+        }
+        data_src_cfg = os.path.join(work_dir, "data_src_cfg.yaml")
+        ConfigParser.export_config_file(data_src, data_src_cfg)
+
+        sys_path = sys.path.copy()
+        with skip_if_downloading_fails():
+            bundle_generator = BundleGen(
+                algo_path=work_dir,
+                data_stats_filename=datastats_file,
+                data_src_cfg_name=data_src_cfg,
+                templates_path_or_url=get_testing_algo_template_path(),
+            )
+
+        bundle_generator.generate(work_dir, num_fold=1)
+        history_before = bundle_generator.get_history()
+        export_bundle_algo_history(history_before)
+
+        sys.path = sys_path  # prevent the import_bundle_algo_history from using the path "work_dir/algorithm_templates"
+        tempfile.TemporaryDirectory()
+        work_dir_new = os.path.join(test_path, "workdir_2")
+        shutil.move(work_dir, work_dir_new)
+        history_after = import_bundle_algo_history(work_dir_new, only_trained=False)
+        self.assertEqual(len(history_before), len(history_after))
+
+    def tearDown(self) -> None:
+        set_determinism(None)
+        self.test_dir.cleanup()
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/apps/test_check_hash.py

@@ -0,0 +1,53 @@
+# 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 os
+import tempfile
+import unittest
+
+import numpy as np
+from parameterized import parameterized
+
+from monai.apps import check_hash
+
+TEST_CASE_1 = ["b94716452086a054208395e8c9d1ae2a", "md5", True]
+
+TEST_CASE_2 = ["abcdefg", "md5", False]
+
+TEST_CASE_3 = [None, "md5", True]
+
+TEST_CASE_4 = [None, "sha1", True]
+
+TEST_CASE_5 = ["b4dc3c246b298eae37cefdfdd2a50b091ffd5e69", "sha1", True]
+
+
+class TestCheckMD5(unittest.TestCase):
+
+    @parameterized.expand([TEST_CASE_1, TEST_CASE_2, TEST_CASE_3, TEST_CASE_4, TEST_CASE_5])
+    def test_result(self, md5_value, t, expected_result):
+        test_image = np.ones((5, 5, 3))
+        with tempfile.TemporaryDirectory() as tempdir:
+            filename = os.path.join(tempdir, "test_file.png")
+            test_image.tofile(filename)
+
+            result = check_hash(filename, md5_value, hash_type=t)
+            self.assertTrue(result == expected_result)
+
+    def test_hash_type_error(self):
+        with self.assertRaises(ValueError):
+            with tempfile.TemporaryDirectory() as tempdir:
+                check_hash(tempdir, "test_hash", "test_type")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/apps/test_cross_validation.py

@@ -0,0 +1,74 @@
+# 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
+from pathlib import Path
+
+from monai.apps import CrossValidation, DecathlonDataset
+from monai.data import MetaTensor
+from monai.transforms import Compose, EnsureChannelFirstd, LoadImaged, ScaleIntensityd
+from tests.test_utils import skip_if_downloading_fails, skip_if_quick
+
+
+class TestCrossValidation(unittest.TestCase):
+    @skip_if_quick
+    def test_values(self):
+        testing_dir = Path(__file__).parents[1] / "testing_data"
+        train_transform = Compose(
+            [
+                LoadImaged(keys=["image", "label"]),
+                EnsureChannelFirstd(keys=["image", "label"], channel_dim="no_channel"),
+                ScaleIntensityd(keys="image"),
+            ]
+        )
+        val_transform = LoadImaged(keys=["image", "label"])
+
+        def _test_dataset(dataset):
+            self.assertEqual(len(dataset), 52)
+            self.assertTrue("image" in dataset[0])
+            self.assertTrue("label" in dataset[0])
+            self.assertTrue(isinstance(dataset[0]["image"], MetaTensor))
+            self.assertTupleEqual(dataset[0]["image"].shape, (1, 34, 49, 41))
+
+        cvdataset = CrossValidation(
+            dataset_cls=DecathlonDataset,
+            nfolds=5,
+            seed=12345,
+            root_dir=testing_dir,
+            task="Task04_Hippocampus",
+            section="validation",
+            transform=train_transform,
+            download=True,
+        )
+
+        with skip_if_downloading_fails():
+            data = cvdataset.get_dataset(folds=0)
+
+        _test_dataset(data)
+
+        # test training data for fold [1, 2, 3, 4] of 5 splits
+        data = cvdataset.get_dataset(folds=[1, 2, 3, 4])
+        self.assertTupleEqual(data[0]["image"].shape, (1, 35, 52, 33))
+        self.assertEqual(len(data), 208)
+        # test train / validation for fold 4 of 5 splits
+        data = cvdataset.get_dataset(folds=[4], transform=val_transform, download=False)
+        # val_transform doesn't add the channel dim to shape
+        self.assertTupleEqual(data[0]["image"].shape, (38, 53, 30))
+        self.assertEqual(len(data), 52)
+        data = cvdataset.get_dataset(folds=[0, 1, 2, 3])
+        self.assertTupleEqual(data[0]["image"].shape, (1, 34, 49, 41))
+        self.assertEqual(len(data), 208)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/apps/test_decathlondataset.py

@@ -0,0 +1,93 @@
+# 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 os
+import shutil
+import unittest
+from pathlib import Path
+
+from monai.apps import DecathlonDataset
+from monai.data import MetaTensor
+from monai.transforms import Compose, EnsureChannelFirstd, LoadImaged, ScaleIntensityd
+from tests.test_utils import skip_if_downloading_fails, skip_if_quick
+
+
+class TestDecathlonDataset(unittest.TestCase):
+    @skip_if_quick
+    def test_values(self):
+        testing_dir = Path(__file__).resolve().parents[1] / "testing_data"
+        transform = Compose(
+            [
+                LoadImaged(keys=["image", "label"]),
+                EnsureChannelFirstd(keys=["image", "label"], channel_dim="no_channel"),
+                ScaleIntensityd(keys="image"),
+            ]
+        )
+
+        def _test_dataset(dataset):
+            self.assertEqual(len(dataset), 52)
+            self.assertTrue("image" in dataset[0])
+            self.assertTrue("label" in dataset[0])
+            self.assertTrue(isinstance(dataset[0]["image"], MetaTensor))
+            self.assertTupleEqual(dataset[0]["image"].shape, (1, 36, 47, 44))
+
+        with skip_if_downloading_fails():
+            data = DecathlonDataset(
+                root_dir=testing_dir,
+                task="Task04_Hippocampus",
+                transform=transform,
+                section="validation",
+                download=True,
+                copy_cache=False,
+            )
+
+        _test_dataset(data)
+        data = DecathlonDataset(
+            root_dir=testing_dir,
+            task="Task04_Hippocampus",
+            transform=transform,
+            section="validation",
+            download=False,
+            runtime_cache=True,
+        )
+        _test_dataset(data)
+        self.assertTrue(data[0]["image"].meta["filename_or_obj"].endswith("hippocampus_163.nii.gz"))
+        self.assertTrue(data[0]["label"].meta["filename_or_obj"].endswith("hippocampus_163.nii.gz"))
+        # test validation without transforms
+        data = DecathlonDataset(root_dir=testing_dir, task="Task04_Hippocampus", section="validation", download=False)
+        self.assertTupleEqual(data[0]["image"].shape, (36, 47, 44))
+        self.assertEqual(len(data), 52)
+        data = DecathlonDataset(root_dir=testing_dir, task="Task04_Hippocampus", section="training", download=False)
+        self.assertTupleEqual(data[0]["image"].shape, (34, 56, 31))
+        self.assertEqual(len(data), 208)
+
+        # test dataset properties
+        data = DecathlonDataset(
+            root_dir=Path(testing_dir), task="Task04_Hippocampus", section="validation", download=False
+        )
+        properties = data.get_properties(keys="labels")
+        self.assertDictEqual(properties["labels"], {"0": "background", "1": "Anterior", "2": "Posterior"})
+
+        shutil.rmtree(os.path.join(testing_dir, "Task04_Hippocampus"))
+        with self.assertRaisesRegex(RuntimeError, "^Cannot find dataset directory"):
+            DecathlonDataset(
+                root_dir=testing_dir,
+                task="Task04_Hippocampus",
+                transform=transform,
+                section="validation",
+                download=False,
+            )
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/apps/test_download_and_extract.py

@@ -0,0 +1,70 @@
+# 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 tempfile
+import unittest
+from pathlib import Path
+from urllib.error import ContentTooShortError, HTTPError
+
+from parameterized import parameterized
+
+from monai.apps import download_and_extract, download_url, extractall
+from tests.test_utils import SkipIfNoModule, skip_if_downloading_fails, skip_if_quick, testing_data_config
+
+
+@SkipIfNoModule("requests")
+class TestDownloadAndExtract(unittest.TestCase):
+    @skip_if_quick
+    def test_actions(self):
+        testing_dir = Path(__file__).parents[1] / "testing_data"
+        config_dict = testing_data_config("images", "mednist")
+        url = config_dict["url"]
+        filepath = Path(testing_dir) / "MedNIST.tar.gz"
+        output_dir = Path(testing_dir)
+        hash_val, hash_type = config_dict["hash_val"], config_dict["hash_type"]
+        with skip_if_downloading_fails():
+            download_and_extract(url, filepath, output_dir, hash_val=hash_val, hash_type=hash_type)
+            download_and_extract(url, filepath, output_dir, hash_val=hash_val, hash_type=hash_type)
+
+        wrong_md5 = "0"
+        with self.assertLogs(logger="monai.apps", level="ERROR"):
+            try:
+                download_url(url, filepath, wrong_md5)
+            except (ContentTooShortError, HTTPError, RuntimeError) as e:
+                if isinstance(e, RuntimeError):
+                    # FIXME: skip MD5 check as current downloading method may fail
+                    self.assertTrue(str(e).startswith("md5 check"))
+                return  # skipping this test due the network connection errors
+
+        try:
+            extractall(filepath, output_dir, wrong_md5)
+        except RuntimeError as e:
+            self.assertTrue(str(e).startswith("md5 check"))
+
+    @skip_if_quick
+    @parameterized.expand((("icon", "tar"), ("favicon", "zip")))
+    def test_default(self, key, file_type):
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            with skip_if_downloading_fails():
+                img_spec = testing_data_config("images", key)
+                download_and_extract(
+                    img_spec["url"],
+                    output_dir=tmp_dir,
+                    hash_val=img_spec["hash_val"],
+                    hash_type=img_spec["hash_type"],
+                    file_type=file_type,
+                )
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/apps/test_download_url_yandex.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 os
+import tempfile
+import unittest
+from urllib.error import HTTPError
+
+from monai.apps.utils import download_url
+
+YANDEX_MODEL_URL = (
+    "https://cloud-api.yandex.net/v1/disk/public/resources/download?"
+    "public_key=https%3A%2F%2Fdisk.yandex.ru%2Fd%2Fxs0gzlj2_irgWA"
+)
+YANDEX_MODEL_FLAWED_URL = (
+    "https://cloud-api.yandex.net/v1/disk/public/resources/download?"
+    "public_key=https%3A%2F%2Fdisk.yandex.ru%2Fd%2Fxs0gzlj2_irgWA-url-with-error"
+)
+
+
+class TestDownloadUrlYandex(unittest.TestCase):
+
+    @unittest.skip("data source unstable")
+    def test_verify(self):
+        with tempfile.TemporaryDirectory() as tempdir:
+            download_url(url=YANDEX_MODEL_URL, filepath=os.path.join(tempdir, "model.pt"))
+
+    def test_verify_error(self):
+        with tempfile.TemporaryDirectory() as tempdir:
+            with self.assertRaises(HTTPError):
+                download_url(url=YANDEX_MODEL_FLAWED_URL, filepath=os.path.join(tempdir, "model.pt"))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/apps/test_mednistdataset.py

@@ -0,0 +1,72 @@
+# 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 os
+import shutil
+import unittest
+from pathlib import Path
+
+from monai.apps import MedNISTDataset
+from monai.data import MetaTensor
+from monai.transforms import Compose, EnsureChannelFirstd, LoadImaged, ScaleIntensityd
+from tests.test_utils import skip_if_downloading_fails, skip_if_quick
+
+MEDNIST_FULL_DATASET_LENGTH = 58954
+
+
+class TestMedNISTDataset(unittest.TestCase):
+    @skip_if_quick
+    def test_values(self):
+        testing_dir = Path(__file__).parents[1] / "testing_data"
+        transform = Compose(
+            [
+                LoadImaged(keys="image"),
+                EnsureChannelFirstd(keys="image", channel_dim="no_channel"),
+                ScaleIntensityd(keys="image"),
+            ]
+        )
+
+        def _test_dataset(dataset):
+            self.assertEqual(len(dataset), int(MEDNIST_FULL_DATASET_LENGTH * dataset.test_frac))
+            self.assertTrue("image" in dataset[0])
+            self.assertTrue("label" in dataset[0])
+            self.assertIsInstance(dataset[0]["image"], MetaTensor)
+            self.assertTupleEqual(dataset[0]["image"].shape, (1, 64, 64))
+
+        with skip_if_downloading_fails():
+            data = MedNISTDataset(
+                root_dir=testing_dir, transform=transform, section="test", download=True, copy_cache=False
+            )
+
+        _test_dataset(data)
+
+        # testing from
+        data = MedNISTDataset(
+            root_dir=Path(testing_dir), transform=transform, section="test", download=False, runtime_cache=True
+        )
+        self.assertEqual(data.get_num_classes(), 6)
+        _test_dataset(data)
+        data = MedNISTDataset(root_dir=testing_dir, section="test", download=False)
+        self.assertTupleEqual(data[0]["image"].shape, (64, 64))
+        # test same dataset length with different random seed
+        data = MedNISTDataset(root_dir=testing_dir, transform=transform, section="test", download=False, seed=42)
+        _test_dataset(data)
+        self.assertEqual(data[0]["class_name"], "AbdomenCT")
+        self.assertEqual(data[0]["label"], 0)
+        shutil.rmtree(os.path.join(testing_dir, "MedNIST"))
+        with self.assertRaisesRegex(RuntimeError, "^Cannot find dataset directory"):
+            MedNISTDataset(root_dir=testing_dir, transform=transform, section="test", download=False)
+
+
+if __name__ == "__main__":
+    unittest.main()