mindstudio-probe 1.0.1__py3-none-any.whl

msprobe/test/core_ut/test_file_check.py

@@ -0,0 +1,218 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+# Copyright (C) 2024-2024. Huawei Technologies Co., Ltd. All rights reserved.
+# 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.
+"""
+import os
+
+from unittest import TestCase
+from unittest.mock import patch, MagicMock
+
+from msprobe.core.common.log import logger
+from msprobe.core.common.const import FileCheckConst
+from msprobe.core.common.exceptions import FileCheckException
+from msprobe.core.common.file_check import (check_link,
+                                         check_path_length,
+                                         check_path_exists,
+                                         check_path_readability,
+                                         check_path_writability,
+                                         check_path_executable,
+                                         check_other_user_writable,
+                                         check_path_owner_consistent,
+                                         check_path_pattern_vaild,
+                                         check_file_size,
+                                         check_common_file_size,
+                                         check_file_suffix,
+                                         check_path_type)
+
+
+class TestFileCheckUtil(TestCase):
+    @patch.object(logger, "error")
+    def test_check_link(self, mock_logger_error):
+        with patch("msprobe.core.common.file_check.os.path.islink", return_value=True):
+            with self.assertRaises(FileCheckException) as context:
+                check_link("link_path")
+            self.assertEqual(str(context.exception),
+                             FileCheckException.err_strs.get(FileCheckException.SOFT_LINK_ERROR))
+            mock_logger_error.assert_called_with("The file path link_path is a soft link.")
+
+    @patch.object(logger, "error")
+    def test_check_path_length(self, mock_logger_error):
+        path = "P" * (FileCheckConst.DIRECTORY_LENGTH + 1)
+        with self.assertRaises(FileCheckException) as context:
+            check_path_length(path)
+        self.assertEqual(str(context.exception),
+                         FileCheckException.err_strs.get(FileCheckException.ILLEGAL_PATH_ERROR))
+        mock_logger_error.assert_called_with("The file path length exceeds limit.")
+
+        path = "P" * (FileCheckConst.FILE_NAME_LENGTH + 1)
+        with self.assertRaises(FileCheckException) as context:
+            check_path_length(path)
+        self.assertEqual(str(context.exception),
+                         FileCheckException.err_strs.get(FileCheckException.ILLEGAL_PATH_ERROR))
+        mock_logger_error.assert_called_with("The file path length exceeds limit.")
+
+        path = "P" * (FileCheckConst.FILE_NAME_LENGTH - 5)
+        with self.assertRaises(FileCheckException) as context:
+            check_path_length(path, name_length=FileCheckConst.FILE_NAME_LENGTH - 6)
+        self.assertEqual(str(context.exception),
+                         FileCheckException.err_strs.get(FileCheckException.ILLEGAL_PATH_ERROR))
+        mock_logger_error.assert_called_with("The file path length exceeds limit.")
+
+    @patch.object(logger, "error")
+    def test_check_path_exists(self, mock_logger_error):
+        with patch("msprobe.core.common.file_check.os.path.exists", return_value=False):
+            with self.assertRaises(FileCheckException) as context:
+                check_path_exists("file_path")
+            self.assertEqual(str(context.exception),
+                             FileCheckException.err_strs.get(FileCheckException.ILLEGAL_PATH_ERROR))
+            mock_logger_error.assert_called_with("The file path file_path does not exist.")
+
+    @patch.object(logger, "error")
+    def test_check_path_readability(self, mock_logger_error):
+        path = "file_path"
+        with patch("msprobe.core.common.file_check.os.access", return_value=False):
+            with self.assertRaises(FileCheckException) as context:
+                check_path_readability(path)
+            self.assertEqual(str(context.exception),
+                             FileCheckException.err_strs.get(FileCheckException.FILE_PERMISSION_ERROR))
+            mock_logger_error.assert_called_with(f"The file path {path} is not readable.")
+
+        mock_access = MagicMock()
+        mock_access.return_value = True
+        with patch("msprobe.core.common.file_check.os.access", new=mock_access):
+            check_path_readability(path)
+        self.assertEqual(mock_access.call_args[0], (path, os.R_OK))
+
+    @patch.object(logger, "error")
+    def test_check_path_writability(self, mock_logger_error):
+        path = "file_path"
+        with patch("msprobe.core.common.file_check.os.access", return_value=False):
+            with self.assertRaises(FileCheckException) as context:
+                check_path_writability(path)
+            self.assertEqual(str(context.exception),
+                             FileCheckException.err_strs.get(FileCheckException.FILE_PERMISSION_ERROR))
+            mock_logger_error.assert_called_with(f"The file path {path} is not writable.")
+
+        mock_access = MagicMock()
+        mock_access.return_value = True
+        with patch("msprobe.core.common.file_check.os.access", new=mock_access):
+            check_path_writability(path)
+        self.assertEqual(mock_access.call_args[0], (path, os.W_OK))
+
+    @patch.object(logger, "error")
+    def test_check_path_executable(self, mock_logger_error):
+        path = "file_path"
+        with patch("msprobe.core.common.file_check.os.access", return_value=False):
+            with self.assertRaises(FileCheckException) as context:
+                check_path_executable(path)
+            self.assertEqual(str(context.exception),
+                             FileCheckException.err_strs.get(FileCheckException.FILE_PERMISSION_ERROR))
+            mock_logger_error.assert_called_with(f"The file path {path} is not executable.")
+
+        mock_access = MagicMock()
+        mock_access.return_value = True
+        with patch("msprobe.core.common.file_check.os.access", new=mock_access):
+            check_path_executable(path)
+        self.assertEqual(mock_access.call_args[0], (path, os.X_OK))
+
+    @patch.object(logger, "error")
+    def test_check_other_user_writable(self, mock_logger_error):
+        class TestStat:
+            def __init__(self, mode):
+                self.st_mode = mode
+
+        path = "file_path"
+        mock_stat = TestStat(0o002)
+        with patch("msprobe.core.common.file_check.os.stat", return_value=mock_stat):
+            with self.assertRaises(FileCheckException) as context:
+                check_other_user_writable(path)
+            self.assertEqual(str(context.exception),
+                             FileCheckException.err_strs.get(FileCheckException.FILE_PERMISSION_ERROR))
+            mock_logger_error.assert_called_with(f"The file path {path} may be insecure "
+                                                 "because other users have write permissions. ")
+
+    @patch.object(logger, "error")
+    def test_check_path_owner_consistent(self, mock_logger_error):
+        file_path = os.path.realpath(__file__)
+        file_owner = os.stat(file_path).st_uid
+        with patch("msprobe.core.common.file_check.os.getuid", return_value=file_owner+1):
+            with self.assertRaises(FileCheckException) as context:
+                check_path_owner_consistent(file_path)
+            self.assertEqual(str(context.exception),
+                             FileCheckException.err_strs.get(FileCheckException.FILE_PERMISSION_ERROR))
+        mock_logger_error.assert_called_with(f"The file path {file_path} may be insecure "
+                                             "because is does not belong to you.")
+
+    @patch.object(logger, "error")
+    def test_check_path_pattern_vaild(self, mock_logger_error):
+        path = "path"
+        mock_re_match = MagicMock()
+        mock_re_match.return_value = False
+        with patch("msprobe.core.common.file_check.re.match", new=mock_re_match):
+            with self.assertRaises(FileCheckException) as context:
+                check_path_pattern_vaild(path)
+            self.assertEqual(str(context.exception),
+                             FileCheckException.err_strs.get(FileCheckException.ILLEGAL_PATH_ERROR))
+        mock_logger_error.assert_called_with(f"The file path {path} contains special characters.")
+        mock_re_match.assert_called_with(FileCheckConst.FILE_VALID_PATTERN, path)
+
+    @patch.object(logger, "error")
+    def test_check_file_size(self, mock_logger_error):
+        file_path = os.path.realpath(__file__)
+        file_size = os.path.getsize(file_path)
+        max_size = file_size
+        with self.assertRaises(FileCheckException) as context:
+            check_file_size(file_path, max_size)
+        self.assertEqual(str(context.exception),
+                         FileCheckException.err_strs.get(FileCheckException.FILE_TOO_LARGE_ERROR))
+        mock_logger_error.assert_called_with(f"The size of file path {file_path} exceeds {max_size} bytes.")
+
+    def test_check_common_file_size(self):
+        mock_check_file_size = MagicMock()
+        with patch("msprobe.core.common.file_check.os.path.isfile", return_value=True), \
+             patch("msprobe.core.common.file_check.check_file_size", new=mock_check_file_size):
+            for suffix, max_size in FileCheckConst.FILE_SIZE_DICT.items():
+                check_common_file_size(suffix)
+                mock_check_file_size.assert_called_with(suffix, max_size)
+
+    @patch.object(logger, "error")
+    def test_check_file_suffix(self, mock_logger_error):
+        file_path = "file_path"
+        suffix = "suffix"
+        with self.assertRaises(FileCheckException) as context:
+            check_file_suffix(file_path, suffix)
+        self.assertEqual(str(context.exception),
+                         FileCheckException.err_strs.get(FileCheckException.INVALID_FILE_ERROR))
+        mock_logger_error.assert_called_with(f"The {file_path} should be a {suffix} file!")
+
+    @patch.object(logger, "error")
+    def test_check_path_type(self, mock_logger_error):
+        file_path = "file_path"
+
+        with patch("msprobe.core.common.file_check.os.path.isfile", return_value=False), \
+             patch("msprobe.core.common.file_check.os.path.isdir", return_value=True):
+            with self.assertRaises(FileCheckException) as context:
+                check_path_type(file_path, FileCheckConst.FILE)
+            self.assertEqual(str(context.exception),
+                             FileCheckException.err_strs.get(FileCheckException.INVALID_FILE_ERROR))
+        mock_logger_error.assert_called_with(f"The {file_path} should be a file!")
+
+        with patch("msprobe.core.common.file_check.os.path.isfile", return_value=True), \
+             patch("msprobe.core.common.file_check.os.path.isdir", return_value=False):
+            with self.assertRaises(FileCheckException) as context:
+                check_path_type(file_path, FileCheckConst.DIR)
+            self.assertEqual(str(context.exception),
+                             FileCheckException.err_strs.get(FileCheckException.INVALID_FILE_ERROR))
+        mock_logger_error.assert_called_with(f"The {file_path} should be a dictionary!")

msprobe/test/core_ut/test_log.py

@@ -0,0 +1,109 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+# Copyright (C) 2024-2024. Huawei Technologies Co., Ltd. All rights reserved.
+# 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 unittest import TestCase
+from unittest.mock import patch, MagicMock
+
+from msprobe.core.common.log import BaseLogger, logger
+
+
+class TestLog(TestCase):
+    @patch("msprobe.core.common.log.print")
+    def test__print_log(self, mock_print):
+        logger._print_log("level", "msg")
+        self.assertIn("[level] msg", mock_print.call_args[0][0])
+        self.assertEqual("\n", mock_print.call_args[1].get("end"))
+
+        logger._print_log("level", "msg", end="end")
+        self.assertIn("[level] msg", mock_print.call_args[0][0])
+        self.assertEqual("end", mock_print.call_args[1].get("end"))
+
+    @patch.object(BaseLogger, "_print_log")
+    def test_print_info_log(self, mock__print_log):
+        logger.info("info_msg")
+        mock__print_log.assert_called_with("INFO", "info_msg")
+
+    @patch.object(BaseLogger, "_print_log")
+    def test_print_warn_log(self, mock__print_log):
+        logger.warning("warn_msg")
+        mock__print_log.assert_called_with("WARNING", "warn_msg")
+
+    @patch.object(BaseLogger, "_print_log")
+    def test_print_error_log(self, mock__print_log):
+        logger.error("error_msg")
+        mock__print_log.assert_called_with("ERROR", "error_msg")
+
+    @patch.object(BaseLogger, "error")
+    def test_error_log_with_exp(self, mock_error):
+        with self.assertRaises(Exception) as context:
+            logger.error_log_with_exp("msg", Exception("Exception"))
+        self.assertEqual(str(context.exception), "Exception")
+        mock_error.assert_called_with("msg")
+
+    @patch.object(BaseLogger, "get_rank")
+    def test_on_rank_0(self, mock_get_rank):
+        mock_func = MagicMock()
+        func_rank_0 = logger.on_rank_0(mock_func)
+
+        mock_get_rank.return_value = 1
+        func_rank_0()
+        mock_func.assert_not_called()
+
+        mock_get_rank.return_value = 0
+        func_rank_0()
+        mock_func.assert_called()
+
+        mock_func = MagicMock()
+        func_rank_0 = logger.on_rank_0(mock_func)
+        mock_get_rank.return_value = None
+        func_rank_0()
+        mock_func.assert_called()
+
+    @patch.object(BaseLogger, "get_rank")
+    def test_info_on_rank_0(self, mock_get_rank):
+        mock_print = MagicMock()
+        with patch("msprobe.core.common.log.print", new=mock_print):
+            mock_get_rank.return_value = 0
+            logger.info_on_rank_0("msg")
+            self.assertIn("[INFO] msg", mock_print.call_args[0][0])
+
+            mock_get_rank.return_value = 1
+            logger.info_on_rank_0("msg")
+            mock_print.assert_called_once()
+
+    @patch.object(BaseLogger, "get_rank")
+    def test_error_on_rank_0(self, mock_get_rank):
+        mock_print = MagicMock()
+        with patch("msprobe.core.common.log.print", new=mock_print):
+            mock_get_rank.return_value = 0
+            logger.error_on_rank_0("msg")
+            self.assertIn("[ERROR] msg", mock_print.call_args[0][0])
+
+            mock_get_rank.return_value = 1
+            logger.error_on_rank_0("msg")
+            mock_print.assert_called_once()
+
+    @patch.object(BaseLogger, "get_rank")
+    def test_warning_on_rank_0(self, mock_get_rank):
+        mock_print = MagicMock()
+        with patch("msprobe.core.common.log.print", new=mock_print):
+            mock_get_rank.return_value = 0
+            logger.warning_on_rank_0("msg")
+            self.assertIn("[WARNING] msg", mock_print.call_args[0][0])
+
+            mock_get_rank.return_value = 1
+            logger.warning_on_rank_0("msg")
+            mock_print.assert_called_once()

msprobe/test/mindspore_ut/test_api_kbk_dump.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+# Copyright (C) 2024-2024. Huawei Technologies Co., Ltd. All rights reserved.
+# 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.
+"""
+import os
+
+from unittest import TestCase
+from unittest.mock import patch
+
+from msprobe.core.common_config import CommonConfig, BaseConfig
+from msprobe.mindspore.debugger.debugger_config import DebuggerConfig
+from msprobe.mindspore.dump.api_kbk_dump import ApiKbkDump
+
+
+class TestApiKbkDump(TestCase):
+
+    def test_handle(self):
+        json_config = {
+            "task": "statistics",
+            "dump_path": "/absolute_path",
+            "rank": [],
+            "step": [0, 2],
+            "level": "L1"
+        }
+
+        common_config = CommonConfig(json_config)
+        task_config = BaseConfig(json_config)
+        config = DebuggerConfig(common_config, task_config)
+        dumper = ApiKbkDump(config)
+        self.assertEqual(dumper.dump_json["common_dump_settings"]["iteration"], "0|2")
+
+        os.environ["MS_ACL_DUMP_CFG_PATH"] = "path"
+        with patch("msprobe.mindspore.dump.api_kbk_dump.make_dump_path_if_not_exists"), \
+             patch("msprobe.mindspore.dump.api_kbk_dump.FileOpen"), \
+             patch("msprobe.mindspore.dump.api_kbk_dump.json.dump"), \
+             patch("msprobe.mindspore.dump.api_kbk_dump.logger.info"):
+            dumper.handle()
+        self.assertEqual(os.environ.get("GRAPH_OP_RUN"), "1")
+        self.assertEqual(os.environ.get("MS_ACL_DUMP_CFG_PATH"), None)

msprobe/test/mindspore_ut/test_debugger_config.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+# Copyright (C) 2024-2024. Huawei Technologies Co., Ltd. All rights reserved.
+# 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 unittest import TestCase
+
+from msprobe.core.common.const import Const
+from msprobe.core.common_config import CommonConfig, BaseConfig
+from msprobe.mindspore.debugger.debugger_config import DebuggerConfig
+
+
+class TestDebuggerConfig(TestCase):
+    def test_init(self):
+        json_config = {
+            "dump_path": "/absolute_path",
+            "rank": [],
+            "step": [],
+            "level": "L1"
+        }
+        common_config = CommonConfig(json_config)
+        task_config = BaseConfig(json_config)
+        debugger_config = DebuggerConfig(common_config, task_config)
+        self.assertEqual(debugger_config.task, Const.STATISTICS)
+        self.assertEqual(debugger_config.file_format, "npy")
+        self.assertEqual(debugger_config.check_mode, "all")
+
+        common_config.dump_path = "./path"
+        with self.assertRaises(Exception) as context:
+            DebuggerConfig(common_config, task_config)
+        self.assertEqual(str(context.exception), "Dump path must be absolute path.")

msprobe/test/mindspore_ut/test_dump_tool_factory.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+# Copyright (C) 2024-2024. Huawei Technologies Co., Ltd. All rights reserved.
+# 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 unittest import TestCase
+
+from msprobe.core.common_config import CommonConfig, BaseConfig
+from msprobe.mindspore.debugger.debugger_config import DebuggerConfig
+from msprobe.mindspore.dump.dump_tool_factory import DumpToolFactory
+
+
+class TestDumpToolFactory(TestCase):
+
+    def test_create(self):
+        json_config = {
+            "task": "statistics",
+            "dump_path": "/absolute_path",
+            "rank": [],
+            "step": [0, 2],
+            "level": "L1"
+        }
+
+        common_config = CommonConfig(json_config)
+        task_config = BaseConfig(json_config)
+        config = DebuggerConfig(common_config, task_config)
+
+        config.level = "module"
+        with self.assertRaises(Exception) as context:
+            DumpToolFactory.create(config)
+        self.assertEqual(str(context.exception), "valid level is needed.")
+
+        config.level = "cell"
+        with self.assertRaises(Exception) as context:
+            DumpToolFactory.create(config)
+        self.assertEqual(str(context.exception), "Cell dump in not supported now.")
+
+        config.level = "kernel"
+        dumper = DumpToolFactory.create(config)
+        self.assertEqual(dumper.dump_json["common_dump_settings"]["net_name"], "Net")

msprobe/test/mindspore_ut/test_kernel_graph_dump.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+# Copyright (C) 2024-2024. Huawei Technologies Co., Ltd. All rights reserved.
+# 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.
+"""
+import os
+
+from unittest import TestCase
+from unittest.mock import patch
+
+from msprobe.core.common_config import CommonConfig, BaseConfig
+from msprobe.mindspore.debugger.debugger_config import DebuggerConfig
+from msprobe.mindspore.dump.kernel_graph_dump import KernelGraphDump
+
+
+class TestKernelGraphDump(TestCase):
+
+    def test_handle(self):
+        json_config = {
+            "task": "tensor",
+            "dump_path": "/absolute_path",
+            "rank": [],
+            "step": [0, 2],
+            "level": "L2"
+        }
+
+        common_config = CommonConfig(json_config)
+        task_config = BaseConfig(json_config)
+        task_config.data_mode = ["output"]
+        task_config.file_format = "bin"
+        config = DebuggerConfig(common_config, task_config)
+        dumper = KernelGraphDump(config)
+        self.assertEqual(dumper.dump_json["common_dump_settings"]["iteration"], "0|2")
+        self.assertEqual(dumper.dump_json["common_dump_settings"]["file_format"], "bin")
+        self.assertEqual(dumper.dump_json["common_dump_settings"]["input_output"], 2)
+
+        with patch("msprobe.mindspore.dump.kernel_graph_dump.make_dump_path_if_not_exists"), \
+             patch("msprobe.mindspore.dump.kernel_graph_dump.FileOpen"), \
+             patch("msprobe.mindspore.dump.kernel_graph_dump.json.dump"), \
+             patch("msprobe.mindspore.dump.kernel_graph_dump.logger.info"):
+
+            os.environ["GRAPH_OP_RUN"] = "1"
+            with self.assertRaises(Exception) as context:
+                dumper.handle()
+            self.assertEqual(str(context.exception), "Must run in graph mode, not kbk mode")
+            if "GRAPH_OP_RUN" in os.environ:
+                del os.environ["GRAPH_OP_RUN"]
+
+            dumper.handle()
+            self.assertIn("kernel_graph_dump.json", os.environ.get("MS_ACL_DUMP_CFG_PATH"))
+
+        if "MINDSPORE_DUMP_CONFIG" in os.environ:
+            del os.environ["MINDSPORE_DUMP_CONFIG"]
+        if "MS_ACL_DUMP_CFG_PATH" in os.environ:
+            del os.environ["MS_ACL_DUMP_CFG_PATH"]

msprobe/test/mindspore_ut/test_kernel_graph_overflow_check.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+# Copyright (C) 2024-2024. Huawei Technologies Co., Ltd. All rights reserved.
+# 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.
+"""
+import os
+
+from unittest import TestCase
+from unittest.mock import patch
+
+from msprobe.core.common_config import CommonConfig, BaseConfig
+from msprobe.mindspore.debugger.debugger_config import DebuggerConfig
+from msprobe.mindspore.overflow_check.kernel_graph_overflow_check import KernelGraphOverflowCheck
+
+
+class TestKernelGraphOverflowCheck(TestCase):
+
+    def test_handle(self):
+        json_config = {
+            "task": "overflow_check",
+            "dump_path": "/absolute_path",
+            "rank": [],
+            "step": [],
+            "level": "L2"
+        }
+
+        common_config = CommonConfig(json_config)
+        task_config = BaseConfig(json_config)
+        task_config.check_mode = "atomic"
+        config = DebuggerConfig(common_config, task_config)
+        checker = KernelGraphOverflowCheck(config)
+        self.assertEqual(checker.dump_json["common_dump_settings"]["op_debug_mode"], 2)
+
+        os.environ["MS_ACL_DUMP_CFG_PATH"] = "path"
+        with patch("msprobe.mindspore.overflow_check.kernel_graph_overflow_check.make_dump_path_if_not_exists"), \
+             patch("msprobe.mindspore.overflow_check.kernel_graph_overflow_check.FileOpen"), \
+             patch("msprobe.mindspore.overflow_check.kernel_graph_overflow_check.json.dump"), \
+             patch("msprobe.mindspore.overflow_check.kernel_graph_overflow_check.logger.info"):
+
+            os.environ["GRAPH_OP_RUN"] = "1"
+            with self.assertRaises(Exception) as context:
+                checker.handle()
+            self.assertEqual(str(context.exception), "Must run in graph mode, not kbk mode")
+            if "GRAPH_OP_RUN" in os.environ:
+                del os.environ["GRAPH_OP_RUN"]
+
+            checker.handle()
+            self.assertIn("kernel_graph_overflow_check.json", os.environ.get("MINDSPORE_DUMP_CONFIG"))
+            self.assertEqual(os.environ.get("MS_ACL_DUMP_CFG_PATH"), None)
+
+        if "MINDSPORE_DUMP_CONFIG" in os.environ:
+            del os.environ["MINDSPORE_DUMP_CONFIG"]

msprobe/test/mindspore_ut/test_ms_config.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+# Copyright (C) 2024-2024. Huawei Technologies Co., Ltd. All rights reserved.
+# 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 unittest import TestCase
+from unittest.mock import patch, mock_open
+
+from msprobe.core.common.const import Const
+from msprobe.mindspore.ms_config import (parse_json_config, parse_task_config,
+                                      TensorConfig, StatisticsConfig, OverflowCheck)
+
+
+class TestMsConfig(TestCase):
+    def test_parse_json_config(self):
+        mock_json_data = {
+            "dump_path": "./dump/",
+            "rank": [],
+            "step": [],
+            "level": "L1",
+            "seed": 1234,
+            "statistics": {
+                "scope": [],
+                "list": [],
+                "data_mode": ["all"],
+                "summary_mode": "statistics"
+            }
+        }
+        with patch("msprobe.mindspore.ms_config.FileOpen", mock_open(read_data='')), \
+             patch("msprobe.mindspore.ms_config.json.load", return_value=mock_json_data):
+            common_config, task_config = parse_json_config("./config.json")
+        self.assertEqual(common_config.task, Const.STATISTICS)
+        self.assertEqual(task_config.data_mode, ["all"])
+
+        with self.assertRaises(Exception) as context:
+            parse_json_config(None)
+        self.assertEqual(str(context.exception), "json file path is None")
+
+    def test_parse_task_config(self):
+        mock_json_config = {
+            "tensor": None,
+            "statistics": None,
+            "overflow_check": None,
+            "free_benchmark": None
+        }
+
+        task_config = parse_task_config("tensor", mock_json_config)
+        self.assertTrue(isinstance(task_config, TensorConfig))
+
+        task_config = parse_task_config("statistics", mock_json_config)
+        self.assertTrue(isinstance(task_config, StatisticsConfig))
+
+        task_config = parse_task_config("overflow_check", mock_json_config)
+        self.assertTrue(isinstance(task_config, OverflowCheck))
+
+        with self.assertRaises(Exception) as context:
+            parse_task_config("free_benchmark", mock_json_config)
+        self.assertEqual(str(context.exception), "task is invalid.")