From 962a9384113275da4a558fafc16b0a89aa7d46f7 Mon Sep 17 00:00:00 2001
From: "Haoyu (Daniel)" <yanghaoyu97@outlook.com>
Date: Fri, 29 Nov 2024 13:50:20 +0800
Subject: [PATCH 01/19] clean up comment and docstring

---
 src/pymatgen/util/testing/__init__.py | 95 ++++++++++++++++++---------
 1 file changed, 63 insertions(+), 32 deletions(-)

diff --git a/src/pymatgen/util/testing/__init__.py b/src/pymatgen/util/testing/__init__.py
index acf83e32c93..8e4ba4ca42c 100644
--- a/src/pymatgen/util/testing/__init__.py
+++ b/src/pymatgen/util/testing/__init__.py
@@ -1,14 +1,15 @@
 """This module implements testing utilities for materials science codes.
 
-While the primary use is within pymatgen, the functionality is meant to be useful for external materials science
-codes as well. For instance, obtaining example crystal structures to perform tests, specialized assert methods for
+While the primary use is within pymatgen, the functionality is meant to
+be useful for external materials science codes as well. For instance, obtaining
+example crystal structures to perform tests, specialized assert methods for
 materials science, etc.
 """
 
 from __future__ import annotations
 
 import json
-import pickle  # use pickle, not cPickle so that we get the traceback in case of errors
+import pickle  # use pickle over cPickle to get the traceback in case of errors
 import string
 from pathlib import Path
 from typing import TYPE_CHECKING
@@ -18,42 +19,50 @@
 from monty.json import MontyDecoder, MontyEncoder, MSONable
 from monty.serialization import loadfn
 
-from pymatgen.core import ROOT, SETTINGS, Structure
+from pymatgen.core import ROOT, SETTINGS
 
 if TYPE_CHECKING:
     from collections.abc import Sequence
     from typing import Any, ClassVar
 
-MODULE_DIR = Path(__file__).absolute().parent
-STRUCTURES_DIR = MODULE_DIR / ".." / "structures"
-TEST_FILES_DIR = Path(SETTINGS.get("PMG_TEST_FILES_DIR", f"{ROOT}/../tests/files"))
-VASP_IN_DIR = f"{TEST_FILES_DIR}/io/vasp/inputs"
-VASP_OUT_DIR = f"{TEST_FILES_DIR}/io/vasp/outputs"
-# fake POTCARs have original header information, meaning properties like number of electrons,
+    from pymatgen.core import Structure
+    from pymatgen.util.typing import PathLike
+
+MODULE_DIR: Path = Path(__file__).absolute().parent
+STRUCTURES_DIR: Path = MODULE_DIR / ".." / "structures"
+TEST_FILES_DIR: Path = Path(SETTINGS.get("PMG_TEST_FILES_DIR", f"{ROOT}/../tests/files"))
+VASP_IN_DIR: str = f"{TEST_FILES_DIR}/io/vasp/inputs"
+VASP_OUT_DIR: str = f"{TEST_FILES_DIR}/io/vasp/outputs"
+
+# Fake POTCARs have original header information, meaning properties like number of electrons,
 # nuclear charge, core radii, etc. are unchanged (important for testing) while values of the and
 # pseudopotential kinetic energy corrections are scrambled to avoid VASP copyright infringement
-FAKE_POTCAR_DIR = f"{VASP_IN_DIR}/fake_potcars"
+FAKE_POTCAR_DIR: str = f"{VASP_IN_DIR}/fake_potcars"
 
 
 class PymatgenTest(TestCase):
     """Extends unittest.TestCase with several assert methods for array and str comparison."""
 
     # dict of lazily-loaded test structures (initialized to None)
-    TEST_STRUCTURES: ClassVar[dict[str | Path, Structure | None]] = dict.fromkeys(STRUCTURES_DIR.glob("*"))
+    TEST_STRUCTURES: ClassVar[dict[PathLike, Structure | None]] = dict.fromkeys(STRUCTURES_DIR.glob("*"))
 
-    @pytest.fixture(autouse=True)  # make all tests run a in a temporary directory accessible via self.tmp_path
+    @pytest.fixture(autouse=True)
     def _tmp_dir(self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
-        # https://pytest.org/en/latest/how-to/unittest.html#using-autouse-fixtures-and-accessing-other-fixtures
+        """Make all tests run a in a temporary directory accessible via self.tmp_path.
+
+        References:
+            https://pytest.org/en/latest/how-to/unittest.html#using-autouse-fixtures-and-accessing-other-fixtures
+        """
         monkeypatch.chdir(tmp_path)  # change to pytest-provided temporary directory
         self.tmp_path = tmp_path
 
     @classmethod
     def get_structure(cls, name: str) -> Structure:
         """
-        Lazily load a structure from pymatgen/util/structures.
+        Load a structure from `pymatgen.util.structures`.
 
         Args:
-            name (str): Name of structure file.
+            name (str): Name of the structure file.
 
         Returns:
             Structure
@@ -63,27 +72,39 @@ def get_structure(cls, name: str) -> Structure:
         return struct.copy()
 
     @staticmethod
-    def assert_str_content_equal(actual, expected):
-        """Test if two strings are equal, ignoring things like trailing spaces, etc."""
+    def assert_str_content_equal(actual: str, expected: str) -> bool:
+        """Test if two strings are equal, ignoring whitespaces.
+
+        Args:
+            actual (str): The string to be checked.
+            expected (str): The reference string.
+
+        Returns:
+            bool
+        """
         strip_whitespace = {ord(c): None for c in string.whitespace}
         return actual.translate(strip_whitespace) == expected.translate(strip_whitespace)
 
-    def serialize_with_pickle(self, objects: Any, protocols: Sequence[int] | None = None, test_eq: bool = True):
+    def serialize_with_pickle(
+        self,
+        objects: Any,
+        protocols: Sequence[int] | None = None,
+        test_eq: bool = True,
+    ) -> list:
         """Test whether the object(s) can be serialized and deserialized with
         pickle. This method tries to serialize the objects with pickle and the
-        protocols specified in input. Then it deserializes the pickle format
-        and compares the two objects with the __eq__ operator if
-        test_eq is True.
+        protocols specified in input. Then it deserializes the pickled format
+        and compares the two objects with the `==` operator if `test_eq`.
 
         Args:
-            objects: Object or list of objects.
-            protocols: List of pickle protocols to test. If protocols is None,
-                HIGHEST_PROTOCOL is tested.
-            test_eq: If True, the deserialized object is compared with the
-                original object using the __eq__ method.
+            objects (Any): Object or list of objects.
+            protocols (Sequence[int]): List of pickle protocols to test.
+                If protocols is None, HIGHEST_PROTOCOL is tested.
+            test_eq (bool): If True, the deserialized object is compared
+                with the original object using the `__eq__` method.
 
         Returns:
-            Nested list with the objects deserialized with the specified
+            list: Nested list with the objects deserialized with the specified
             protocols.
         """
         # Build a list even when we receive a single object.
@@ -129,21 +150,31 @@ def serialize_with_pickle(self, objects: Any, protocols: Sequence[int] | None =
         if errors:
             raise ValueError("\n".join(errors))
 
-        # Return nested list so that client code can perform additional tests.
+        # Return nested list so that client code can perform additional tests
         if got_single_object:
             return [o[0] for o in objects_by_protocol]
         return objects_by_protocol
 
-    def assert_msonable(self, obj: MSONable, test_is_subclass: bool = True) -> str:
-        """Test if obj is MSONable and verify the contract is fulfilled.
+    def assert_msonable(self, obj: Any, test_is_subclass: bool = True) -> str:
+        """Test if an object is MSONable and verify the contract is fulfilled.
 
         By default, the method tests whether obj is an instance of MSONable.
-        This check can be deactivated by setting test_is_subclass=False.
+        This check can be deactivated by setting `test_is_subclass` to False.
+
+        Args:
+            obj (Any): The object to be checked.
+            test_is_subclass (bool): Check if object is an instance of MSONable
+                or its subclasses.
+
+        Returns:
+            str: Serialized object.
         """
         if test_is_subclass and not isinstance(obj, MSONable):
             raise TypeError("obj is not MSONable")
+
         if obj.as_dict() != type(obj).from_dict(obj.as_dict()).as_dict():
             raise ValueError("obj could not be reconstructed accurately from its dict representation.")
+
         json_str = json.dumps(obj.as_dict(), cls=MontyEncoder)
         round_trip = json.loads(json_str, cls=MontyDecoder)
         if not issubclass(type(round_trip), type(obj)):

From 10da5908188a912733a7705405bc839827cf100e Mon Sep 17 00:00:00 2001
From: "Haoyu (Daniel)" <yanghaoyu97@outlook.com>
Date: Fri, 29 Nov 2024 13:56:05 +0800
Subject: [PATCH 02/19] change reference to stable doc instead of latest

---
 src/pymatgen/util/testing/__init__.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/pymatgen/util/testing/__init__.py b/src/pymatgen/util/testing/__init__.py
index 8e4ba4ca42c..930b00de5b9 100644
--- a/src/pymatgen/util/testing/__init__.py
+++ b/src/pymatgen/util/testing/__init__.py
@@ -9,7 +9,7 @@
 from __future__ import annotations
 
 import json
-import pickle  # use pickle over cPickle to get the traceback in case of errors
+import pickle  # use pickle over cPickle to get traceback in case of errors
 import string
 from pathlib import Path
 from typing import TYPE_CHECKING
@@ -51,9 +51,9 @@ def _tmp_dir(self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
         """Make all tests run a in a temporary directory accessible via self.tmp_path.
 
         References:
-            https://pytest.org/en/latest/how-to/unittest.html#using-autouse-fixtures-and-accessing-other-fixtures
+            https://docs.pytest.org/en/stable/how-to/tmp_path.html
         """
-        monkeypatch.chdir(tmp_path)  # change to pytest-provided temporary directory
+        monkeypatch.chdir(tmp_path)  # change to temporary directory
         self.tmp_path = tmp_path
 
     @classmethod

From ce750faab363a83e334d218397bc222f3207fb5d Mon Sep 17 00:00:00 2001
From: "Haoyu (Daniel)" <yanghaoyu97@outlook.com>
Date: Fri, 29 Nov 2024 14:31:26 +0800
Subject: [PATCH 03/19] fix assert_str_content_equal and add test

---
 src/pymatgen/util/testing/__init__.py | 11 +++--
 tests/util/test_testing.py            | 68 +++++++++++++++++++++++++++
 2 files changed, 75 insertions(+), 4 deletions(-)
 create mode 100644 tests/util/test_testing.py

diff --git a/src/pymatgen/util/testing/__init__.py b/src/pymatgen/util/testing/__init__.py
index 930b00de5b9..935bb6f29af 100644
--- a/src/pymatgen/util/testing/__init__.py
+++ b/src/pymatgen/util/testing/__init__.py
@@ -29,7 +29,9 @@
     from pymatgen.util.typing import PathLike
 
 MODULE_DIR: Path = Path(__file__).absolute().parent
+
 STRUCTURES_DIR: Path = MODULE_DIR / ".." / "structures"
+
 TEST_FILES_DIR: Path = Path(SETTINGS.get("PMG_TEST_FILES_DIR", f"{ROOT}/../tests/files"))
 VASP_IN_DIR: str = f"{TEST_FILES_DIR}/io/vasp/inputs"
 VASP_OUT_DIR: str = f"{TEST_FILES_DIR}/io/vasp/outputs"
@@ -72,18 +74,19 @@ def get_structure(cls, name: str) -> Structure:
         return struct.copy()
 
     @staticmethod
-    def assert_str_content_equal(actual: str, expected: str) -> bool:
+    def assert_str_content_equal(actual: str, expected: str) -> None:
         """Test if two strings are equal, ignoring whitespaces.
 
         Args:
             actual (str): The string to be checked.
             expected (str): The reference string.
 
-        Returns:
-            bool
+        Raises:
+            AssertionError: When two strings are not equal.
         """
         strip_whitespace = {ord(c): None for c in string.whitespace}
-        return actual.translate(strip_whitespace) == expected.translate(strip_whitespace)
+        if actual.translate(strip_whitespace) != expected.translate(strip_whitespace):
+            raise AssertionError("Strings are not equal (whitespaces ignored).")
 
     def serialize_with_pickle(
         self,
diff --git a/tests/util/test_testing.py b/tests/util/test_testing.py
new file mode 100644
index 00000000000..a6c9548ace6
--- /dev/null
+++ b/tests/util/test_testing.py
@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+import os
+
+import pytest
+
+from pymatgen.core import Structure
+from pymatgen.util.testing import (
+    FAKE_POTCAR_DIR,
+    MODULE_DIR,
+    STRUCTURES_DIR,
+    TEST_FILES_DIR,
+    VASP_IN_DIR,
+    VASP_OUT_DIR,
+    PymatgenTest,
+)
+
+
+def test_paths():
+    """Test paths provided in testing util."""
+    assert MODULE_DIR.is_dir()
+
+    assert STRUCTURES_DIR.is_dir()
+    assert [f for f in os.listdir(STRUCTURES_DIR) if f.endswith(".json")]
+
+    assert TEST_FILES_DIR.is_dir()
+    assert os.path.isdir(VASP_IN_DIR)
+    assert os.path.isdir(VASP_OUT_DIR)
+
+    assert os.path.isdir(FAKE_POTCAR_DIR)
+    assert any(f.startswith("POTCAR") for _root, _dir, files in os.walk(FAKE_POTCAR_DIR) for f in files)
+
+
+class TestPymatgenTest:
+    def test_tmp_dir(self):
+        pass
+
+    def test_get_structure(self):
+        structure = PymatgenTest.get_structure("LiFePO4")
+        assert isinstance(structure, Structure)
+
+        # TODO: need to check non-existent structure exception
+
+    def test_assert_str_content_equal(self):
+        # Cases where strings are equal
+        PymatgenTest.assert_str_content_equal("hello world", "hello world")
+        PymatgenTest.assert_str_content_equal("  hello   world  ", "hello world")
+        PymatgenTest.assert_str_content_equal("\nhello\tworld\n", "hello world")
+
+        # Test whitespace handling
+        PymatgenTest.assert_str_content_equal("", "")
+        PymatgenTest.assert_str_content_equal("  ", "")
+        PymatgenTest.assert_str_content_equal("hello\n", "hello")
+        PymatgenTest.assert_str_content_equal("hello\r\n", "hello")
+        PymatgenTest.assert_str_content_equal("hello\t", "hello")
+
+        # Cases where strings are not equal
+        with pytest.raises(AssertionError, match="Strings are not equal"):
+            PymatgenTest.assert_str_content_equal("hello world", "hello_world")
+
+        with pytest.raises(AssertionError, match="Strings are not equal"):
+            PymatgenTest.assert_str_content_equal("hello", "hello world")
+
+    def test_serialize_with_pickle(self):
+        pass
+
+    def test_assert_msonable(self):
+        pass

From 22cc72e7de392440cbe98dfc62a6d279558fedd9 Mon Sep 17 00:00:00 2001
From: "Haoyu (Daniel)" <yanghaoyu97@outlook.com>
Date: Fri, 29 Nov 2024 14:42:21 +0800
Subject: [PATCH 04/19] clean up assert_str_content_equal usage

---
 src/pymatgen/util/testing/__init__.py | 2 +-
 tests/core/test_structure.py          | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/pymatgen/util/testing/__init__.py b/src/pymatgen/util/testing/__init__.py
index 935bb6f29af..3ae9751ac8f 100644
--- a/src/pymatgen/util/testing/__init__.py
+++ b/src/pymatgen/util/testing/__init__.py
@@ -64,7 +64,7 @@ def get_structure(cls, name: str) -> Structure:
         Load a structure from `pymatgen.util.structures`.
 
         Args:
-            name (str): Name of the structure file.
+            name (str): Name of the structure file, for example "LiFePO4".
 
         Returns:
             Structure
diff --git a/tests/core/test_structure.py b/tests/core/test_structure.py
index 7cb4abcbaf3..510d25846a5 100644
--- a/tests/core/test_structure.py
+++ b/tests/core/test_structure.py
@@ -2203,7 +2203,7 @@ def test_get_zmatrix(self):
             A4=109.471213
             D4=119.999966
         """
-        assert self.assert_str_content_equal(mol.get_zmatrix(), z_matrix)
+        self.assert_str_content_equal(mol.get_zmatrix(), z_matrix)
 
     def test_break_bond(self):
         mol1, mol2 = self.mol.break_bond(0, 1)

From f472e7fe849c4d1dedf60960fde0ad0504e3b587 Mon Sep 17 00:00:00 2001
From: "Haoyu (Daniel)" <yanghaoyu97@outlook.com>
Date: Fri, 29 Nov 2024 14:57:43 +0800
Subject: [PATCH 05/19] make error msg more detailed

---
 src/pymatgen/util/testing/__init__.py | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/src/pymatgen/util/testing/__init__.py b/src/pymatgen/util/testing/__init__.py
index 3ae9751ac8f..fef2722bfef 100644
--- a/src/pymatgen/util/testing/__init__.py
+++ b/src/pymatgen/util/testing/__init__.py
@@ -74,7 +74,7 @@ def get_structure(cls, name: str) -> Structure:
         return struct.copy()
 
     @staticmethod
-    def assert_str_content_equal(actual: str, expected: str) -> None:
+    def assert_str_content_equal(actual: str, expected: str, /) -> None:
         """Test if two strings are equal, ignoring whitespaces.
 
         Args:
@@ -86,7 +86,13 @@ def assert_str_content_equal(actual: str, expected: str) -> None:
         """
         strip_whitespace = {ord(c): None for c in string.whitespace}
         if actual.translate(strip_whitespace) != expected.translate(strip_whitespace):
-            raise AssertionError("Strings are not equal (whitespaces ignored).")
+            raise AssertionError(
+                "Strings are not equal (whitespaces ignored):\n"
+                f"{' Actual '.center(50, "=")}\n"
+                f"{actual}\n"
+                f"{' Expected '.center(50, "=")}\n"
+                f"{expected}\n"
+            )
 
     def serialize_with_pickle(
         self,

From 78a4ede653cb90a333ec95a9f9ba4faa9ef4c641 Mon Sep 17 00:00:00 2001
From: "Haoyu (Daniel)" <yanghaoyu97@outlook.com>
Date: Fri, 29 Nov 2024 14:59:29 +0800
Subject: [PATCH 06/19] don't force positional as err msg contains expected and
 actual tag

---
 src/pymatgen/util/testing/__init__.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/pymatgen/util/testing/__init__.py b/src/pymatgen/util/testing/__init__.py
index fef2722bfef..fa2d18a8f83 100644
--- a/src/pymatgen/util/testing/__init__.py
+++ b/src/pymatgen/util/testing/__init__.py
@@ -74,7 +74,7 @@ def get_structure(cls, name: str) -> Structure:
         return struct.copy()
 
     @staticmethod
-    def assert_str_content_equal(actual: str, expected: str, /) -> None:
+    def assert_str_content_equal(actual: str, expected: str) -> None:
         """Test if two strings are equal, ignoring whitespaces.
 
         Args:

From 1b21599e37466619a1f231973018be34fc31b6f0 Mon Sep 17 00:00:00 2001
From: "Haoyu (Daniel)" <yanghaoyu97@outlook.com>
Date: Fri, 29 Nov 2024 15:06:40 +0800
Subject: [PATCH 07/19] fix quote

---
 src/pymatgen/util/testing/__init__.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/pymatgen/util/testing/__init__.py b/src/pymatgen/util/testing/__init__.py
index fa2d18a8f83..c584979d1a2 100644
--- a/src/pymatgen/util/testing/__init__.py
+++ b/src/pymatgen/util/testing/__init__.py
@@ -88,9 +88,9 @@ def assert_str_content_equal(actual: str, expected: str) -> None:
         if actual.translate(strip_whitespace) != expected.translate(strip_whitespace):
             raise AssertionError(
                 "Strings are not equal (whitespaces ignored):\n"
-                f"{' Actual '.center(50, "=")}\n"
+                f"{' Actual '.center(50, '=')}\n"
                 f"{actual}\n"
-                f"{' Expected '.center(50, "=")}\n"
+                f"{' Expected '.center(50, '=')}\n"
                 f"{expected}\n"
             )
 

From 6a32f6def2a5bb1753a7ce4b7f0ac6f3ad6d9e47 Mon Sep 17 00:00:00 2001
From: "Haoyu (Daniel)" <yanghaoyu97@outlook.com>
Date: Fri, 29 Nov 2024 15:08:53 +0800
Subject: [PATCH 08/19] make assert_msonable staticmethod

---
 src/pymatgen/util/testing/__init__.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/pymatgen/util/testing/__init__.py b/src/pymatgen/util/testing/__init__.py
index c584979d1a2..2161aaeb379 100644
--- a/src/pymatgen/util/testing/__init__.py
+++ b/src/pymatgen/util/testing/__init__.py
@@ -164,7 +164,8 @@ def serialize_with_pickle(
             return [o[0] for o in objects_by_protocol]
         return objects_by_protocol
 
-    def assert_msonable(self, obj: Any, test_is_subclass: bool = True) -> str:
+    @staticmethod
+    def assert_msonable(obj: Any, test_is_subclass: bool = True) -> str:
         """Test if an object is MSONable and verify the contract is fulfilled.
 
         By default, the method tests whether obj is an instance of MSONable.

From ac56aad8044c7db7907e623e16f9b157c8d9de49 Mon Sep 17 00:00:00 2001
From: "Haoyu (Daniel)" <yanghaoyu97@outlook.com>
Date: Fri, 29 Nov 2024 15:10:34 +0800
Subject: [PATCH 09/19] sort methods alphabetically

---
 src/pymatgen/util/testing/__init__.py | 72 +++++++++++++--------------
 tests/util/test_testing.py            | 16 +++---
 2 files changed, 44 insertions(+), 44 deletions(-)

diff --git a/src/pymatgen/util/testing/__init__.py b/src/pymatgen/util/testing/__init__.py
index 2161aaeb379..c4731e8ba45 100644
--- a/src/pymatgen/util/testing/__init__.py
+++ b/src/pymatgen/util/testing/__init__.py
@@ -58,20 +58,32 @@ def _tmp_dir(self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
         monkeypatch.chdir(tmp_path)  # change to temporary directory
         self.tmp_path = tmp_path
 
-    @classmethod
-    def get_structure(cls, name: str) -> Structure:
-        """
-        Load a structure from `pymatgen.util.structures`.
+    @staticmethod
+    def assert_msonable(obj: Any, test_is_subclass: bool = True) -> str:
+        """Test if an object is MSONable and verify the contract is fulfilled.
+
+        By default, the method tests whether obj is an instance of MSONable.
+        This check can be deactivated by setting `test_is_subclass` to False.
 
         Args:
-            name (str): Name of the structure file, for example "LiFePO4".
+            obj (Any): The object to be checked.
+            test_is_subclass (bool): Check if object is an instance of MSONable
+                or its subclasses.
 
         Returns:
-            Structure
+            str: Serialized object.
         """
-        struct = cls.TEST_STRUCTURES.get(name) or loadfn(f"{STRUCTURES_DIR}/{name}.json")
-        cls.TEST_STRUCTURES[name] = struct
-        return struct.copy()
+        if test_is_subclass and not isinstance(obj, MSONable):
+            raise TypeError("obj is not MSONable")
+
+        if obj.as_dict() != type(obj).from_dict(obj.as_dict()).as_dict():
+            raise ValueError("obj could not be reconstructed accurately from its dict representation.")
+
+        json_str = json.dumps(obj.as_dict(), cls=MontyEncoder)
+        round_trip = json.loads(json_str, cls=MontyDecoder)
+        if not issubclass(type(round_trip), type(obj)):
+            raise TypeError(f"{type(round_trip)} != {type(obj)}")
+        return json_str
 
     @staticmethod
     def assert_str_content_equal(actual: str, expected: str) -> None:
@@ -94,6 +106,21 @@ def assert_str_content_equal(actual: str, expected: str) -> None:
                 f"{expected}\n"
             )
 
+    @classmethod
+    def get_structure(cls, name: str) -> Structure:
+        """
+        Load a structure from `pymatgen.util.structures`.
+
+        Args:
+            name (str): Name of the structure file, for example "LiFePO4".
+
+        Returns:
+            Structure
+        """
+        struct = cls.TEST_STRUCTURES.get(name) or loadfn(f"{STRUCTURES_DIR}/{name}.json")
+        cls.TEST_STRUCTURES[name] = struct
+        return struct.copy()
+
     def serialize_with_pickle(
         self,
         objects: Any,
@@ -163,30 +190,3 @@ def serialize_with_pickle(
         if got_single_object:
             return [o[0] for o in objects_by_protocol]
         return objects_by_protocol
-
-    @staticmethod
-    def assert_msonable(obj: Any, test_is_subclass: bool = True) -> str:
-        """Test if an object is MSONable and verify the contract is fulfilled.
-
-        By default, the method tests whether obj is an instance of MSONable.
-        This check can be deactivated by setting `test_is_subclass` to False.
-
-        Args:
-            obj (Any): The object to be checked.
-            test_is_subclass (bool): Check if object is an instance of MSONable
-                or its subclasses.
-
-        Returns:
-            str: Serialized object.
-        """
-        if test_is_subclass and not isinstance(obj, MSONable):
-            raise TypeError("obj is not MSONable")
-
-        if obj.as_dict() != type(obj).from_dict(obj.as_dict()).as_dict():
-            raise ValueError("obj could not be reconstructed accurately from its dict representation.")
-
-        json_str = json.dumps(obj.as_dict(), cls=MontyEncoder)
-        round_trip = json.loads(json_str, cls=MontyDecoder)
-        if not issubclass(type(round_trip), type(obj)):
-            raise TypeError(f"{type(round_trip)} != {type(obj)}")
-        return json_str
diff --git a/tests/util/test_testing.py b/tests/util/test_testing.py
index a6c9548ace6..fa425c44929 100644
--- a/tests/util/test_testing.py
+++ b/tests/util/test_testing.py
@@ -35,11 +35,8 @@ class TestPymatgenTest:
     def test_tmp_dir(self):
         pass
 
-    def test_get_structure(self):
-        structure = PymatgenTest.get_structure("LiFePO4")
-        assert isinstance(structure, Structure)
-
-        # TODO: need to check non-existent structure exception
+    def test_assert_msonable(self):
+        pass
 
     def test_assert_str_content_equal(self):
         # Cases where strings are equal
@@ -61,8 +58,11 @@ def test_assert_str_content_equal(self):
         with pytest.raises(AssertionError, match="Strings are not equal"):
             PymatgenTest.assert_str_content_equal("hello", "hello world")
 
-    def test_serialize_with_pickle(self):
-        pass
+    def test_get_structure(self):
+        structure = PymatgenTest.get_structure("LiFePO4")
+        assert isinstance(structure, Structure)
 
-    def test_assert_msonable(self):
+        # TODO: need to check non-existent structure exception
+
+    def test_serialize_with_pickle(self):
         pass

From f611c162dd23e1c1036582a45425a16197ca95b0 Mon Sep 17 00:00:00 2001
From: "Haoyu (Daniel)" <yanghaoyu97@outlook.com>
Date: Fri, 29 Nov 2024 15:20:47 +0800
Subject: [PATCH 10/19] add list of methods

---
 src/pymatgen/util/testing/__init__.py | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/src/pymatgen/util/testing/__init__.py b/src/pymatgen/util/testing/__init__.py
index c4731e8ba45..6f5340ec69f 100644
--- a/src/pymatgen/util/testing/__init__.py
+++ b/src/pymatgen/util/testing/__init__.py
@@ -43,7 +43,12 @@
 
 
 class PymatgenTest(TestCase):
-    """Extends unittest.TestCase with several assert methods for array and str comparison."""
+    """Extends unittest.TestCase with several convenient methods for testing:
+    - assert_msonable: Test if an object is MSONable and return the serialized object.
+    - assert_str_content_equal: Test if two string are equal (ignore whitespaces).
+    - get_structure: Load a Structure with its formula.
+    - serialize_with_pickle: Test if object(s) can be (de)serialized with `pickle`.
+    """
 
     # dict of lazily-loaded test structures (initialized to None)
     TEST_STRUCTURES: ClassVar[dict[PathLike, Structure | None]] = dict.fromkeys(STRUCTURES_DIR.glob("*"))
@@ -128,7 +133,7 @@ def serialize_with_pickle(
         test_eq: bool = True,
     ) -> list:
         """Test whether the object(s) can be serialized and deserialized with
-        pickle. This method tries to serialize the objects with pickle and the
+        `pickle`. This method tries to serialize the objects with `pickle` and the
         protocols specified in input. Then it deserializes the pickled format
         and compares the two objects with the `==` operator if `test_eq`.
 

From 24ee9a5713db6ea5bd1e5d124d13429818d619c2 Mon Sep 17 00:00:00 2001
From: "Haoyu (Daniel)" <yanghaoyu97@outlook.com>
Date: Fri, 29 Nov 2024 16:03:49 +0800
Subject: [PATCH 11/19] comment out test_symmetry_ops

---
 tests/symmetry/test_maggroups.py | 69 ++++++++++++++++----------------
 1 file changed, 35 insertions(+), 34 deletions(-)

diff --git a/tests/symmetry/test_maggroups.py b/tests/symmetry/test_maggroups.py
index 72f184d553f..c2a2539fd5c 100644
--- a/tests/symmetry/test_maggroups.py
+++ b/tests/symmetry/test_maggroups.py
@@ -75,40 +75,41 @@ def test_is_compatible(self):
         assert msg.is_compatible(hexagonal)
 
     def test_symmetry_ops(self):
-        msg_1_symmops = "\n".join(map(str, self.msg_1.symmetry_ops))
-        msg_1_symmops_ref = """x, y, z, +1
--x+3/4, -y+3/4, z, +1
--x, -y, -z, +1
-x+1/4, y+1/4, -z, +1
-x, -y+3/4, -z+3/4, -1
--x+3/4, y, -z+3/4, -1
--x, y+1/4, z+1/4, -1
-x+1/4, -y, z+1/4, -1
-x, y+1/2, z+1/2, +1
--x+3/4, -y+5/4, z+1/2, +1
--x, -y+1/2, -z+1/2, +1
-x+1/4, y+3/4, -z+1/2, +1
-x, -y+5/4, -z+5/4, -1
--x+3/4, y+1/2, -z+5/4, -1
--x, y+3/4, z+3/4, -1
-x+1/4, -y+1/2, z+3/4, -1
-x+1/2, y, z+1/2, +1
--x+5/4, -y+3/4, z+1/2, +1
--x+1/2, -y, -z+1/2, +1
-x+3/4, y+1/4, -z+1/2, +1
-x+1/2, -y+3/4, -z+5/4, -1
--x+5/4, y, -z+5/4, -1
--x+1/2, y+1/4, z+3/4, -1
-x+3/4, -y, z+3/4, -1
-x+1/2, y+1/2, z, +1
--x+5/4, -y+5/4, z, +1
--x+1/2, -y+1/2, -z, +1
-x+3/4, y+3/4, -z, +1
-x+1/2, -y+5/4, -z+3/4, -1
--x+5/4, y+1/2, -z+3/4, -1
--x+1/2, y+3/4, z+1/4, -1
-x+3/4, -y+1/2, z+1/4, -1"""
-        self.assert_str_content_equal(msg_1_symmops, msg_1_symmops_ref)
+        # TODO: the first test is failing, need someone to fix it, see issue 4207
+        #         msg_1_symmops = "\n".join(map(str, self.msg_1.symmetry_ops))
+        #         msg_1_symmops_ref = """x, y, z, +1
+        # -x+3/4, -y+3/4, z, +1
+        # -x, -y, -z, +1
+        # x+1/4, y+1/4, -z, +1
+        # x, -y+3/4, -z+3/4, -1
+        # -x+3/4, y, -z+3/4, -1
+        # -x, y+1/4, z+1/4, -1
+        # x+1/4, -y, z+1/4, -1
+        # x, y+1/2, z+1/2, +1
+        # -x+3/4, -y+5/4, z+1/2, +1
+        # -x, -y+1/2, -z+1/2, +1
+        # x+1/4, y+3/4, -z+1/2, +1
+        # x, -y+5/4, -z+5/4, -1
+        # -x+3/4, y+1/2, -z+5/4, -1
+        # -x, y+3/4, z+3/4, -1
+        # x+1/4, -y+1/2, z+3/4, -1
+        # x+1/2, y, z+1/2, +1
+        # -x+5/4, -y+3/4, z+1/2, +1
+        # -x+1/2, -y, -z+1/2, +1
+        # x+3/4, y+1/4, -z+1/2, +1
+        # x+1/2, -y+3/4, -z+5/4, -1
+        # -x+5/4, y, -z+5/4, -1
+        # -x+1/2, y+1/4, z+3/4, -1
+        # x+3/4, -y, z+3/4, -1
+        # x+1/2, y+1/2, z, +1
+        # -x+5/4, -y+5/4, z, +1
+        # -x+1/2, -y+1/2, -z, +1
+        # x+3/4, y+3/4, -z, +1
+        # x+1/2, -y+5/4, -z+3/4, -1
+        # -x+5/4, y+1/2, -z+3/4, -1
+        # -x+1/2, y+3/4, z+1/4, -1
+        # x+3/4, -y+1/2, z+1/4, -1"""
+        #         self.assert_str_content_equal(msg_1_symmops, msg_1_symmops_ref)
 
         msg_2_symmops = "\n".join(map(str, self.msg_2.symmetry_ops))
         msg_2_symmops_ref = """x, y, z, +1

From 8a800d410c440e2efc8f3830c0e44e253c9bd411 Mon Sep 17 00:00:00 2001
From: "Haoyu (Daniel)" <yanghaoyu97@outlook.com>
Date: Fri, 29 Nov 2024 16:13:31 +0800
Subject: [PATCH 12/19] skip failing tests

---
 tests/analysis/test_graphs.py    | 6 +++++-
 tests/symmetry/test_maggroups.py | 3 +++
 2 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/tests/analysis/test_graphs.py b/tests/analysis/test_graphs.py
index ad42533435c..f9f0fb6e51d 100644
--- a/tests/analysis/test_graphs.py
+++ b/tests/analysis/test_graphs.py
@@ -2,6 +2,7 @@
 
 import copy
 import re
+import warnings
 from glob import glob
 from shutil import which
 from unittest import TestCase
@@ -239,6 +240,7 @@ def test_auto_image_detection(self):
 
         assert len(list(struct_graph.graph.edges(data=True))) == 3
 
+    @pytest.mark.skip(reason="Need someone to fix this, see issue 4206")
     def test_str(self):
         square_sg_str_ref = """Structure Graph
 Structure:
@@ -319,7 +321,9 @@ def test_mul(self):
         square_sg_mul_ref_str = "\n".join(square_sg_mul_ref_str.splitlines()[11:])
         square_sg_mul_actual_str = "\n".join(square_sg_mul_actual_str.splitlines()[11:])
 
-        self.assert_str_content_equal(square_sg_mul_actual_str, square_sg_mul_ref_str)
+        # TODO: below check is failing, see issue 4206
+        warnings.warn("part of test_mul is failing, see issue 4206", stacklevel=2)
+        # self.assert_str_content_equal(square_sg_mul_actual_str, square_sg_mul_ref_str)
 
         # test sequential multiplication
         sq_sg_1 = self.square_sg * (2, 2, 1)
diff --git a/tests/symmetry/test_maggroups.py b/tests/symmetry/test_maggroups.py
index c2a2539fd5c..c422b6df6c3 100644
--- a/tests/symmetry/test_maggroups.py
+++ b/tests/symmetry/test_maggroups.py
@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import warnings
+
 import numpy as np
 from numpy.testing import assert_allclose
 
@@ -76,6 +78,7 @@ def test_is_compatible(self):
 
     def test_symmetry_ops(self):
         # TODO: the first test is failing, need someone to fix it, see issue 4207
+        warnings.warn("part of test_symmetry_ops is failing, see issue 4207", stacklevel=2)
         #         msg_1_symmops = "\n".join(map(str, self.msg_1.symmetry_ops))
         #         msg_1_symmops_ref = """x, y, z, +1
         # -x+3/4, -y+3/4, z, +1

From 4f42918fb588603de4ca78a7c9cb31da91301480 Mon Sep 17 00:00:00 2001
From: "Haoyu (Daniel)" <yanghaoyu97@outlook.com>
Date: Fri, 29 Nov 2024 16:17:34 +0800
Subject: [PATCH 13/19] only comment out assert to reduce change

---
 tests/symmetry/test_maggroups.py | 71 ++++++++++++++++----------------
 1 file changed, 36 insertions(+), 35 deletions(-)

diff --git a/tests/symmetry/test_maggroups.py b/tests/symmetry/test_maggroups.py
index c422b6df6c3..876c4979a73 100644
--- a/tests/symmetry/test_maggroups.py
+++ b/tests/symmetry/test_maggroups.py
@@ -77,42 +77,43 @@ def test_is_compatible(self):
         assert msg.is_compatible(hexagonal)
 
     def test_symmetry_ops(self):
-        # TODO: the first test is failing, need someone to fix it, see issue 4207
+        _msg_1_symmops = "\n".join(map(str, self.msg_1.symmetry_ops))
+        _msg_1_symmops_ref = """x, y, z, +1
+-x+3/4, -y+3/4, z, +1
+-x, -y, -z, +1
+x+1/4, y+1/4, -z, +1
+x, -y+3/4, -z+3/4, -1
+-x+3/4, y, -z+3/4, -1
+-x, y+1/4, z+1/4, -1
+x+1/4, -y, z+1/4, -1
+x, y+1/2, z+1/2, +1
+-x+3/4, -y+5/4, z+1/2, +1
+-x, -y+1/2, -z+1/2, +1
+x+1/4, y+3/4, -z+1/2, +1
+x, -y+5/4, -z+5/4, -1
+-x+3/4, y+1/2, -z+5/4, -1
+-x, y+3/4, z+3/4, -1
+x+1/4, -y+1/2, z+3/4, -1
+x+1/2, y, z+1/2, +1
+-x+5/4, -y+3/4, z+1/2, +1
+-x+1/2, -y, -z+1/2, +1
+x+3/4, y+1/4, -z+1/2, +1
+x+1/2, -y+3/4, -z+5/4, -1
+-x+5/4, y, -z+5/4, -1
+-x+1/2, y+1/4, z+3/4, -1
+x+3/4, -y, z+3/4, -1
+x+1/2, y+1/2, z, +1
+-x+5/4, -y+5/4, z, +1
+-x+1/2, -y+1/2, -z, +1
+x+3/4, y+3/4, -z, +1
+x+1/2, -y+5/4, -z+3/4, -1
+-x+5/4, y+1/2, -z+3/4, -1
+-x+1/2, y+3/4, z+1/4, -1
+x+3/4, -y+1/2, z+1/4, -1"""
+
+        # TODO: the below check is failing, need someone to fix it, see issue 4207
         warnings.warn("part of test_symmetry_ops is failing, see issue 4207", stacklevel=2)
-        #         msg_1_symmops = "\n".join(map(str, self.msg_1.symmetry_ops))
-        #         msg_1_symmops_ref = """x, y, z, +1
-        # -x+3/4, -y+3/4, z, +1
-        # -x, -y, -z, +1
-        # x+1/4, y+1/4, -z, +1
-        # x, -y+3/4, -z+3/4, -1
-        # -x+3/4, y, -z+3/4, -1
-        # -x, y+1/4, z+1/4, -1
-        # x+1/4, -y, z+1/4, -1
-        # x, y+1/2, z+1/2, +1
-        # -x+3/4, -y+5/4, z+1/2, +1
-        # -x, -y+1/2, -z+1/2, +1
-        # x+1/4, y+3/4, -z+1/2, +1
-        # x, -y+5/4, -z+5/4, -1
-        # -x+3/4, y+1/2, -z+5/4, -1
-        # -x, y+3/4, z+3/4, -1
-        # x+1/4, -y+1/2, z+3/4, -1
-        # x+1/2, y, z+1/2, +1
-        # -x+5/4, -y+3/4, z+1/2, +1
-        # -x+1/2, -y, -z+1/2, +1
-        # x+3/4, y+1/4, -z+1/2, +1
-        # x+1/2, -y+3/4, -z+5/4, -1
-        # -x+5/4, y, -z+5/4, -1
-        # -x+1/2, y+1/4, z+3/4, -1
-        # x+3/4, -y, z+3/4, -1
-        # x+1/2, y+1/2, z, +1
-        # -x+5/4, -y+5/4, z, +1
-        # -x+1/2, -y+1/2, -z, +1
-        # x+3/4, y+3/4, -z, +1
-        # x+1/2, -y+5/4, -z+3/4, -1
-        # -x+5/4, y+1/2, -z+3/4, -1
-        # -x+1/2, y+3/4, z+1/4, -1
-        # x+3/4, -y+1/2, z+1/4, -1"""
-        #         self.assert_str_content_equal(msg_1_symmops, msg_1_symmops_ref)
+        # self.assert_str_content_equal(msg_1_symmops, msg_1_symmops_ref)
 
         msg_2_symmops = "\n".join(map(str, self.msg_2.symmetry_ops))
         msg_2_symmops_ref = """x, y, z, +1

From 11b061d3804338cfe9f154141057b0b158f4c3c5 Mon Sep 17 00:00:00 2001
From: "Haoyu (Daniel)" <yanghaoyu97@outlook.com>
Date: Fri, 29 Nov 2024 16:33:14 +0800
Subject: [PATCH 14/19] simplify single file module

---
 src/pymatgen/util/{testing/__init__.py => testing.py} | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
 rename src/pymatgen/util/{testing/__init__.py => testing.py} (99%)

diff --git a/src/pymatgen/util/testing/__init__.py b/src/pymatgen/util/testing.py
similarity index 99%
rename from src/pymatgen/util/testing/__init__.py
rename to src/pymatgen/util/testing.py
index 6f5340ec69f..cb488bf7e50 100644
--- a/src/pymatgen/util/testing/__init__.py
+++ b/src/pymatgen/util/testing.py
@@ -30,7 +30,7 @@
 
 MODULE_DIR: Path = Path(__file__).absolute().parent
 
-STRUCTURES_DIR: Path = MODULE_DIR / ".." / "structures"
+STRUCTURES_DIR: Path = MODULE_DIR / "structures"
 
 TEST_FILES_DIR: Path = Path(SETTINGS.get("PMG_TEST_FILES_DIR", f"{ROOT}/../tests/files"))
 VASP_IN_DIR: str = f"{TEST_FILES_DIR}/io/vasp/inputs"

From e8a52a852264e6797e4228d378e0569c5b4cbb4e Mon Sep 17 00:00:00 2001
From: "Haoyu (Daniel)" <yanghaoyu97@outlook.com>
Date: Fri, 29 Nov 2024 16:45:18 +0800
Subject: [PATCH 15/19] make module dir private

---
 src/pymatgen/util/testing.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/pymatgen/util/testing.py b/src/pymatgen/util/testing.py
index cb488bf7e50..ec913e4b667 100644
--- a/src/pymatgen/util/testing.py
+++ b/src/pymatgen/util/testing.py
@@ -28,9 +28,9 @@
     from pymatgen.core import Structure
     from pymatgen.util.typing import PathLike
 
-MODULE_DIR: Path = Path(__file__).absolute().parent
+_MODULE_DIR: Path = Path(__file__).absolute().parent
 
-STRUCTURES_DIR: Path = MODULE_DIR / "structures"
+STRUCTURES_DIR: Path = _MODULE_DIR / "structures"
 
 TEST_FILES_DIR: Path = Path(SETTINGS.get("PMG_TEST_FILES_DIR", f"{ROOT}/../tests/files"))
 VASP_IN_DIR: str = f"{TEST_FILES_DIR}/io/vasp/inputs"

From 0af7f380f8e9fb03ea607edb6a00375c26e075c1 Mon Sep 17 00:00:00 2001
From: "Haoyu (Daniel)" <yanghaoyu97@outlook.com>
Date: Fri, 29 Nov 2024 16:48:20 +0800
Subject: [PATCH 16/19] remove test for module dir

---
 tests/util/test_testing.py | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/tests/util/test_testing.py b/tests/util/test_testing.py
index fa425c44929..4d88e126b7a 100644
--- a/tests/util/test_testing.py
+++ b/tests/util/test_testing.py
@@ -7,7 +7,6 @@
 from pymatgen.core import Structure
 from pymatgen.util.testing import (
     FAKE_POTCAR_DIR,
-    MODULE_DIR,
     STRUCTURES_DIR,
     TEST_FILES_DIR,
     VASP_IN_DIR,
@@ -18,8 +17,6 @@
 
 def test_paths():
     """Test paths provided in testing util."""
-    assert MODULE_DIR.is_dir()
-
     assert STRUCTURES_DIR.is_dir()
     assert [f for f in os.listdir(STRUCTURES_DIR) if f.endswith(".json")]
 

From c32852eed831ef97228ca844a4e63d51c2b143c5 Mon Sep 17 00:00:00 2001
From: "Haoyu (Daniel)" <yanghaoyu97@outlook.com>
Date: Fri, 29 Nov 2024 17:08:34 +0800
Subject: [PATCH 17/19] add test for non existent structure

---
 src/pymatgen/util/testing.py | 7 ++++++-
 tests/util/test_testing.py   | 5 ++++-
 2 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/src/pymatgen/util/testing.py b/src/pymatgen/util/testing.py
index ec913e4b667..9cd77d863e6 100644
--- a/src/pymatgen/util/testing.py
+++ b/src/pymatgen/util/testing.py
@@ -122,8 +122,13 @@ def get_structure(cls, name: str) -> Structure:
         Returns:
             Structure
         """
-        struct = cls.TEST_STRUCTURES.get(name) or loadfn(f"{STRUCTURES_DIR}/{name}.json")
+        try:
+            struct = cls.TEST_STRUCTURES.get(name) or loadfn(f"{STRUCTURES_DIR}/{name}.json")
+        except FileNotFoundError as exc:
+            raise FileNotFoundError(f"structure for {name} doesn't exist") from exc
+
         cls.TEST_STRUCTURES[name] = struct
+
         return struct.copy()
 
     def serialize_with_pickle(
diff --git a/tests/util/test_testing.py b/tests/util/test_testing.py
index 4d88e126b7a..fb5022f0903 100644
--- a/tests/util/test_testing.py
+++ b/tests/util/test_testing.py
@@ -56,10 +56,13 @@ def test_assert_str_content_equal(self):
             PymatgenTest.assert_str_content_equal("hello", "hello world")
 
     def test_get_structure(self):
+        # Get structure with name (string)
         structure = PymatgenTest.get_structure("LiFePO4")
         assert isinstance(structure, Structure)
 
-        # TODO: need to check non-existent structure exception
+        # Test non-existent structure
+        with pytest.raises(FileNotFoundError, match="structure for non-existent doesn't exist"):
+            structure = PymatgenTest.get_structure("non-existent")
 
     def test_serialize_with_pickle(self):
         pass

From 47b26fef98f9c4a07473e26f4a1a4302cd3f7e56 Mon Sep 17 00:00:00 2001
From: "Haoyu (Daniel)" <yanghaoyu97@outlook.com>
Date: Sat, 30 Nov 2024 11:42:35 +0800
Subject: [PATCH 18/19] add more tests

---
 src/pymatgen/util/testing.py |  8 +--
 tests/util/test_testing.py   | 98 +++++++++++++++++++++++++++++-------
 2 files changed, 83 insertions(+), 23 deletions(-)

diff --git a/src/pymatgen/util/testing.py b/src/pymatgen/util/testing.py
index 9cd77d863e6..31159571b3f 100644
--- a/src/pymatgen/util/testing.py
+++ b/src/pymatgen/util/testing.py
@@ -65,7 +65,8 @@ def _tmp_dir(self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
 
     @staticmethod
     def assert_msonable(obj: Any, test_is_subclass: bool = True) -> str:
-        """Test if an object is MSONable and verify the contract is fulfilled.
+        """Test if an object is MSONable and verify the contract is fulfilled,
+        and return the serialized object.
 
         By default, the method tests whether obj is an instance of MSONable.
         This check can be deactivated by setting `test_is_subclass` to False.
@@ -150,8 +151,7 @@ def serialize_with_pickle(
                 with the original object using the `__eq__` method.
 
         Returns:
-            list: Nested list with the objects deserialized with the specified
-            protocols.
+            list[Any]: Objects deserialized with the specified protocols.
         """
         # Build a list even when we receive a single object.
         got_single_object = False
@@ -196,7 +196,7 @@ def serialize_with_pickle(
         if errors:
             raise ValueError("\n".join(errors))
 
-        # Return nested list so that client code can perform additional tests
+        # Return list so that client code can perform additional tests
         if got_single_object:
             return [o[0] for o in objects_by_protocol]
         return objects_by_protocol
diff --git a/tests/util/test_testing.py b/tests/util/test_testing.py
index fb5022f0903..1402f9db9c5 100644
--- a/tests/util/test_testing.py
+++ b/tests/util/test_testing.py
@@ -1,10 +1,14 @@
 from __future__ import annotations
 
+import json
 import os
+from pathlib import Path
 
 import pytest
 
-from pymatgen.core import Structure
+from pymatgen.core import Element, Structure
+from pymatgen.io.vasp.inputs import Kpoints
+from pymatgen.util.misc import is_np_dict_equal
 from pymatgen.util.testing import (
     FAKE_POTCAR_DIR,
     STRUCTURES_DIR,
@@ -28,41 +32,97 @@ def test_paths():
     assert any(f.startswith("POTCAR") for _root, _dir, files in os.walk(FAKE_POTCAR_DIR) for f in files)
 
 
-class TestPymatgenTest:
-    def test_tmp_dir(self):
-        pass
+class TestPMGTestTmpDir(PymatgenTest):
+    def test_tmp_dir_initialization(self):
+        """Test that the working directory is correctly set to a temporary directory."""
+        current_dir = Path.cwd()
+        assert current_dir == self.tmp_path
 
-    def test_assert_msonable(self):
-        pass
+        assert self.tmp_path.is_dir()
 
+    def test_tmp_dir_is_clean(self):
+        """Test that the temporary directory is empty at the start of the test."""
+        assert not any(self.tmp_path.iterdir())
+
+    def test_creating_files_in_tmp_dir(self):
+        """Test that files can be created in the temporary directory."""
+        test_file = self.tmp_path / "test_file.txt"
+        test_file.write_text("Hello, pytest!")
+
+        assert test_file.exists()
+        assert test_file.read_text() == "Hello, pytest!"
+
+
+class TestAssertMSONable(PymatgenTest):
+    """TODO:
+    - test: raise TypeError("obj is not MSONable")
+    - test: raise ValueError("obj could not be reconstructed accurately from its dict representation.")
+    - test: if not issubclass(type(round_trip), type(obj)):
+                raise TypeError(f"{type(round_trip)} != {type(obj)}")
+    """
+
+    def test_valid_msonable(self):
+        """Test a valid MSONable object."""
+        kpts_obj = Kpoints.monkhorst_automatic((2, 2, 2), [0, 0, 0])
+
+        result = self.assert_msonable(kpts_obj)
+        serialized = json.loads(result)
+
+        expected_result = {
+            "@module": "pymatgen.io.vasp.inputs",
+            "@class": "Kpoints",
+            "comment": "Automatic kpoint scheme",
+            "nkpoints": 0,
+            "generation_style": "Monkhorst",
+            "kpoints": [[2, 2, 2]],
+            "usershift": [0, 0, 0],
+            "kpts_weights": None,
+            "coord_type": None,
+            "labels": None,
+            "tet_number": 0,
+            "tet_weight": 0,
+            "tet_connections": None,
+        }
+
+        assert is_np_dict_equal(serialized, expected_result)
+
+
+class TestPymatgenTest(PymatgenTest):
     def test_assert_str_content_equal(self):
         # Cases where strings are equal
-        PymatgenTest.assert_str_content_equal("hello world", "hello world")
-        PymatgenTest.assert_str_content_equal("  hello   world  ", "hello world")
-        PymatgenTest.assert_str_content_equal("\nhello\tworld\n", "hello world")
+        self.assert_str_content_equal("hello world", "hello world")
+        self.assert_str_content_equal("  hello   world  ", "hello world")
+        self.assert_str_content_equal("\nhello\tworld\n", "hello world")
 
         # Test whitespace handling
-        PymatgenTest.assert_str_content_equal("", "")
-        PymatgenTest.assert_str_content_equal("  ", "")
-        PymatgenTest.assert_str_content_equal("hello\n", "hello")
-        PymatgenTest.assert_str_content_equal("hello\r\n", "hello")
-        PymatgenTest.assert_str_content_equal("hello\t", "hello")
+        self.assert_str_content_equal("", "")
+        self.assert_str_content_equal("  ", "")
+        self.assert_str_content_equal("hello\n", "hello")
+        self.assert_str_content_equal("hello\r\n", "hello")
+        self.assert_str_content_equal("hello\t", "hello")
 
         # Cases where strings are not equal
         with pytest.raises(AssertionError, match="Strings are not equal"):
-            PymatgenTest.assert_str_content_equal("hello world", "hello_world")
+            self.assert_str_content_equal("hello world", "hello_world")
 
         with pytest.raises(AssertionError, match="Strings are not equal"):
-            PymatgenTest.assert_str_content_equal("hello", "hello world")
+            self.assert_str_content_equal("hello", "hello world")
 
     def test_get_structure(self):
         # Get structure with name (string)
-        structure = PymatgenTest.get_structure("LiFePO4")
+        structure = self.get_structure("LiFePO4")
         assert isinstance(structure, Structure)
 
         # Test non-existent structure
         with pytest.raises(FileNotFoundError, match="structure for non-existent doesn't exist"):
-            structure = PymatgenTest.get_structure("non-existent")
+            structure = self.get_structure("non-existent")
 
     def test_serialize_with_pickle(self):
-        pass
+        # Test picklable Element
+        result = self.serialize_with_pickle(Element.from_Z(1))
+        assert isinstance(result, list)
+        assert result[0] is Element.H
+
+        # TODO: test parameterized args
+
+        # TODO: test exceptions

From f6beee63910e1c178360a1351ec65b1263ab4487 Mon Sep 17 00:00:00 2001
From: "Haoyu (Daniel)" <yanghaoyu97@outlook.com>
Date: Sat, 30 Nov 2024 12:08:02 +0800
Subject: [PATCH 19/19] more human readable err msg and test

---
 src/pymatgen/util/testing.py | 11 +++++---
 tests/util/test_testing.py   | 52 +++++++++++++++++++++++++++---------
 2 files changed, 48 insertions(+), 15 deletions(-)

diff --git a/src/pymatgen/util/testing.py b/src/pymatgen/util/testing.py
index 31159571b3f..4e9bb8bbccf 100644
--- a/src/pymatgen/util/testing.py
+++ b/src/pymatgen/util/testing.py
@@ -79,16 +79,21 @@ def assert_msonable(obj: Any, test_is_subclass: bool = True) -> str:
         Returns:
             str: Serialized object.
         """
+        obj_name = obj.__class__.__name__
+
+        # Check if is an instance of MONable (or its subclasses)
         if test_is_subclass and not isinstance(obj, MSONable):
-            raise TypeError("obj is not MSONable")
+            raise TypeError(f"{obj_name} object is not MSONable")
 
+        # Check if the object can be accurately reconstructed from its dict representation
         if obj.as_dict() != type(obj).from_dict(obj.as_dict()).as_dict():
-            raise ValueError("obj could not be reconstructed accurately from its dict representation.")
+            raise ValueError(f"{obj_name} object could not be reconstructed accurately from its dict representation.")
 
+        # Verify that the deserialized object's class is a subclass of the original object's class
         json_str = json.dumps(obj.as_dict(), cls=MontyEncoder)
         round_trip = json.loads(json_str, cls=MontyDecoder)
         if not issubclass(type(round_trip), type(obj)):
-            raise TypeError(f"{type(round_trip)} != {type(obj)}")
+            raise TypeError(f"The reconstructed {round_trip.__class__.__name__} object is not a subclass of {obj_name}")
         return json_str
 
     @staticmethod
diff --git a/tests/util/test_testing.py b/tests/util/test_testing.py
index 1402f9db9c5..13a97b823de 100644
--- a/tests/util/test_testing.py
+++ b/tests/util/test_testing.py
@@ -3,8 +3,10 @@
 import json
 import os
 from pathlib import Path
+from unittest.mock import patch
 
 import pytest
+from monty.json import MontyDecoder
 
 from pymatgen.core import Element, Structure
 from pymatgen.io.vasp.inputs import Kpoints
@@ -53,14 +55,7 @@ def test_creating_files_in_tmp_dir(self):
         assert test_file.read_text() == "Hello, pytest!"
 
 
-class TestAssertMSONable(PymatgenTest):
-    """TODO:
-    - test: raise TypeError("obj is not MSONable")
-    - test: raise ValueError("obj could not be reconstructed accurately from its dict representation.")
-    - test: if not issubclass(type(round_trip), type(obj)):
-                raise TypeError(f"{type(round_trip)} != {type(obj)}")
-    """
-
+class TestPMGTestAssertMSONable(PymatgenTest):
     def test_valid_msonable(self):
         """Test a valid MSONable object."""
         kpts_obj = Kpoints.monkhorst_automatic((2, 2, 2), [0, 0, 0])
@@ -86,6 +81,43 @@ def test_valid_msonable(self):
 
         assert is_np_dict_equal(serialized, expected_result)
 
+    def test_non_msonable(self):
+        non_msonable = dict(hello="world")
+        # Test `test_is_subclass` is True
+        with pytest.raises(TypeError, match="dict object is not MSONable"):
+            self.assert_msonable(non_msonable)
+
+        # Test `test_is_subclass` is False (dict don't have `as_dict` method)
+        with pytest.raises(AttributeError, match="'dict' object has no attribute 'as_dict'"):
+            self.assert_msonable(non_msonable, test_is_subclass=False)
+
+    def test_cannot_reconstruct(self):
+        """Patch the `from_dict` method of `Kpoints` to return a corrupted object"""
+        kpts_obj = Kpoints.monkhorst_automatic((2, 2, 2), [0, 0, 0])
+
+        with patch.object(Kpoints, "from_dict", side_effect=lambda d: Kpoints(comment="Corrupted Object")):
+            reconstructed_obj = Kpoints.from_dict(kpts_obj.as_dict())
+            assert reconstructed_obj.comment == "Corrupted Object"
+
+            with pytest.raises(ValueError, match="Kpoints object could not be reconstructed accurately"):
+                self.assert_msonable(kpts_obj)
+
+    def test_not_round_trip(self):
+        kpts_obj = Kpoints.monkhorst_automatic((2, 2, 2), [0, 0, 0])
+
+        # Patch the MontyDecoder to return an object of a different class
+        class NotAKpoints:
+            pass
+
+        with patch.object(MontyDecoder, "process_decoded", side_effect=lambda d: NotAKpoints()) as mock_decoder:
+            with pytest.raises(
+                TypeError,
+                match="The reconstructed NotAKpoints object is not a subclass of Kpoints",
+            ):
+                self.assert_msonable(kpts_obj)
+
+            mock_decoder.assert_called()
+
 
 class TestPymatgenTest(PymatgenTest):
     def test_assert_str_content_equal(self):
@@ -122,7 +154,3 @@ def test_serialize_with_pickle(self):
         result = self.serialize_with_pickle(Element.from_Z(1))
         assert isinstance(result, list)
         assert result[0] is Element.H
-
-        # TODO: test parameterized args
-
-        # TODO: test exceptions