mindstudio-probe 1.0.1__py3-none-any.whl → 1.0.3__py3-none-any.whl

msprobe/test/core_ut/data_dump/test_scope.py

@@ -1,151 +0,0 @@
-import unittest
-from unittest.mock import MagicMock
-
-from msprobe.core.common.exceptions import ScopeException
-from msprobe.core.data_dump.scope import (
-    build_scope,
-    build_range_scope_according_to_scope_name,
-    BaseScope,
-    ListScope,
-    RangeScope,
-    APIRangeScope,
-    ModuleRangeScope
-)
-
-
-class TestBuildScope(unittest.TestCase):
-    def test_build_scope(self):
-        scope_class = MagicMock()
-        result1 = build_scope(scope_class, None, None)
-        self.assertEqual(result1, None)
-
-        api_list = ['api1', 'api2']
-        result2 = build_scope(scope_class, None, api_list)
-        self.assertEqual(result2, scope_class.return_value)
-
-    def test_build_range_scope_according_to_scope_name(self):
-        result = build_range_scope_according_to_scope_name([], [])
-        self.assertIsInstance(result, APIRangeScope)
-
-
-class TestBaseScope(unittest.TestCase):
-    def test_rectify_args(self):
-        scope = []
-        api_list = "invalid_api_list"
-        with self.assertRaises(ScopeException) as context:
-            BaseScope.rectify_args(scope, api_list)
-        self.assertEqual(context.exception.code, ScopeException.InvalidApiStr)
-
-        api_list = [1, 2, 3]
-        with self.assertRaises(ScopeException) as context:
-            BaseScope.rectify_args(scope, api_list)
-        self.assertEqual(context.exception.code, ScopeException.InvalidApiStr)
-
-        scope = "module1"
-        api_list = []
-
-        expected_scope = ["module1"]
-        expected_api_list = []
-        result_scope, result_api_list = BaseScope.rectify_args(scope, api_list)
-        self.assertEqual(result_scope, expected_scope)
-        self.assertEqual(result_api_list, expected_api_list)
-
-        scope = 123
-        api_list = []
-        with self.assertRaises(ScopeException) as context:
-            BaseScope.rectify_args(scope, api_list)
-        self.assertEqual(context.exception.code, ScopeException.InvalidScope)
-
-        scope = ["module1", 2, "module3"]
-        api_list = []
-        with self.assertRaises(ScopeException) as context:
-            BaseScope.rectify_args(scope, api_list)
-        self.assertEqual(context.exception.code, ScopeException.InvalidScope)
-
-
-class TestListScope(unittest.TestCase):
-    def test_rectify_args(self):
-        scope = ["module1"]
-        api_list = ["api1"]
-        with self.assertRaises(ScopeException) as context:
-            ListScope.rectify_args(scope, api_list)
-        self.assertEqual(context.exception.code, ScopeException.ArgConflict)
-
-    def test_check(self):
-        list_scope = ListScope([], [])
-        module_name = "module1"
-        result = list_scope.check(module_name)
-        self.assertTrue(result)
-
-        list_scope = ListScope(["module1"], [])
-        module_name = "module1"
-        result = list_scope.check(module_name)
-        self.assertTrue(result)
-
-        list_scope = ListScope(["module1"], [])
-        module_name = "module2"
-        result = list_scope.check(module_name)
-        self.assertFalse(result)
-
-
-class TestRangeScope(unittest.TestCase):
-    def test_rectify_args(self):
-        scope = ["module1", "module2", "module3"]
-        with self.assertRaises(ScopeException) as context:
-            RangeScope.rectify_args(scope, [])
-        self.assertEqual(context.exception.code, ScopeException.InvalidScope)
-
-        scope = ["module1"]
-        expected_scope = ["module1", "module1"]
-        result_scope, result_api_list = RangeScope.rectify_args(scope, [])
-        self.assertEqual(result_scope, expected_scope)
-
-
-class TestAPIRangeScope(unittest.TestCase):
-    def test_check_scope_is_valid(self):
-        api_range_scope = APIRangeScope([], [])
-        result = api_range_scope.check_scope_is_valid()
-        self.assertTrue(result)
-
-    def test_check(self):
-        api_range_scope = APIRangeScope([], [])
-        api_name = "api1"
-        result = api_range_scope.check(api_name)
-        self.assertTrue(result)
-
-
-class TestModuleRangeScope(unittest.TestCase):
-    def test_check_scope_is_valid(self):
-        module_range_scope = ModuleRangeScope([], [])
-        result = module_range_scope.check_scope_is_valid()
-        self.assertTrue(result)
-
-    def test_begin_module(self):
-        module_range_scope = ModuleRangeScope(["module1", "module2"], [])
-        module_name = "module1"
-        module_range_scope.begin_module(module_name)
-        self.assertTrue(module_range_scope.in_scope)
-
-        module_range_scope = ModuleRangeScope(["module1", "module2"], [])
-        module_name = "module3"
-        module_range_scope.begin_module(module_name)
-        self.assertFalse(module_range_scope.in_scope)
-
-    def test_end_module(self):
-        module_range_scope = ModuleRangeScope(["module1", "module2"], [])
-        module_name = "module2"
-        module_range_scope.in_scope = True
-        module_range_scope.end_module(module_name)
-        self.assertFalse(module_range_scope.in_scope)
-
-        module_range_scope = ModuleRangeScope(["module1", "module2"], [])
-        module_name = "module3"
-        module_range_scope.in_scope = True
-        module_range_scope.end_module(module_name)
-        self.assertTrue(module_range_scope.in_scope)
-
-    def test_check(self):
-        module_range_scope = ModuleRangeScope([], [])
-        module_name = "module1"
-        result = module_range_scope.check(module_name)
-        self.assertTrue(result)

msprobe/test/core_ut/test_common_config.py

@@ -1,152 +0,0 @@
-#!/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
-
-from msprobe.core.common.log import logger
-from msprobe.core.common.const import Const
-from msprobe.core.common.exceptions import MsaccException
-from msprobe.core.common_config import CommonConfig, BaseConfig
-
-
-class TestCommonConfig(TestCase):
-    @patch.object(logger, "error_log_with_exp")
-    def test_common_config(self, mock_error_log_with_exp):
-        json_config = dict()
-
-        common_config = CommonConfig(json_config)
-        self.assertIsNone(common_config.task)
-        self.assertIsNone(common_config.dump_path)
-        self.assertIsNone(common_config.rank)
-        self.assertIsNone(common_config.step)
-        self.assertIsNone(common_config.level)
-        self.assertIsNone(common_config.seed)
-        self.assertIsNone(common_config.acl_config)
-        self.assertFalse(common_config.is_deterministic)
-        self.assertFalse(common_config.enable_dataloader)
-
-        json_config.update({"task": "md5"})
-        CommonConfig(json_config)
-        self.assertEqual(mock_error_log_with_exp.call_args[0][0],
-                         "task is invalid, it should be one of {}".format(Const.TASK_LIST))
-        self.assertEqual(str(mock_error_log_with_exp.call_args[0][1]),
-                         MsaccException.err_strs.get(MsaccException.INVALID_PARAM_ERROR))
-
-        json_config.update({"task": Const.TENSOR})
-        json_config.update({"rank": 0})
-        CommonConfig(json_config)
-        self.assertEqual(mock_error_log_with_exp.call_args[0][0],
-                         "rank is invalid, it should be a list")
-        self.assertEqual(str(mock_error_log_with_exp.call_args[0][1]),
-                         MsaccException.err_strs.get(MsaccException.INVALID_PARAM_ERROR))
-
-        json_config.update({"task": Const.TENSOR})
-        json_config.update({"rank": [0]})
-        json_config.update({"step": 0})
-        CommonConfig(json_config)
-        self.assertEqual(mock_error_log_with_exp.call_args[0][0],
-                         "step is invalid, it should be a list")
-        self.assertEqual(str(mock_error_log_with_exp.call_args[0][1]),
-                         MsaccException.err_strs.get(MsaccException.INVALID_PARAM_ERROR))
-
-        json_config.update({"task": Const.TENSOR})
-        json_config.update({"rank": [0]})
-        json_config.update({"step": [0]})
-        json_config.update({"level": "L3"})
-        CommonConfig(json_config)
-        self.assertEqual(mock_error_log_with_exp.call_args[0][0],
-                         "level is invalid, it should be one of {}".format(Const.LEVEL_LIST))
-        self.assertEqual(str(mock_error_log_with_exp.call_args[0][1]),
-                         MsaccException.err_strs.get(MsaccException.INVALID_PARAM_ERROR))
-
-        json_config.update({"task": Const.TENSOR})
-        json_config.update({"rank": [0]})
-        json_config.update({"step": [0]})
-        json_config.update({"level": "L0"})
-        json_config.update({"seed": "1234"})
-        CommonConfig(json_config)
-        self.assertEqual(mock_error_log_with_exp.call_args[0][0],
-                         "seed is invalid, it should be an integer")
-        self.assertEqual(str(mock_error_log_with_exp.call_args[0][1]),
-                         MsaccException.err_strs.get(MsaccException.INVALID_PARAM_ERROR))
-
-        json_config.update({"task": Const.TENSOR})
-        json_config.update({"rank": [0]})
-        json_config.update({"step": [0]})
-        json_config.update({"level": "L0"})
-        json_config.update({"seed": 1234})
-        json_config.update({"is_deterministic": "ENABLE"})
-        CommonConfig(json_config)
-        self.assertEqual(mock_error_log_with_exp.call_args[0][0],
-                         "is_deterministic is invalid, it should be a boolean")
-        self.assertEqual(str(mock_error_log_with_exp.call_args[0][1]),
-                         MsaccException.err_strs.get(MsaccException.INVALID_PARAM_ERROR))
-
-        json_config.update({"task": Const.TENSOR})
-        json_config.update({"rank": [0]})
-        json_config.update({"step": [0]})
-        json_config.update({"level": "L0"})
-        json_config.update({"seed": 1234})
-        json_config.update({"is_deterministic": True})
-        json_config.update({"enable_dataloader": "ENABLE"})
-        CommonConfig(json_config)
-        self.assertEqual(mock_error_log_with_exp.call_args[0][0],
-                         "enable_dataloader is invalid, it should be a boolean")
-        self.assertEqual(str(mock_error_log_with_exp.call_args[0][1]),
-                         MsaccException.err_strs.get(MsaccException.INVALID_PARAM_ERROR))
-
-    @patch.object(logger, "error_log_with_exp")
-    def test_base_config(self, mock_error_log_with_exp):
-        json_config = dict()
-
-        base_config = BaseConfig(json_config)
-        base_config.check_config()
-        self.assertIsNone(base_config.scope)
-        self.assertIsNone(base_config.list)
-        self.assertIsNone(base_config.data_mode)
-        self.assertIsNone(base_config.backward_input)
-        self.assertIsNone(base_config.file_format)
-        self.assertIsNone(base_config.summary_mode)
-        self.assertIsNone(base_config.overflow_num)
-        self.assertIsNone(base_config.check_mode)
-
-        json_config.update({"scope": "Tensor_Add"})
-        base_config = BaseConfig(json_config)
-        base_config.check_config()
-        self.assertEqual(mock_error_log_with_exp.call_args[0][0],
-                         "scope is invalid, it should be a list")
-        self.assertEqual(str(mock_error_log_with_exp.call_args[0][1]),
-                         MsaccException.err_strs.get(MsaccException.INVALID_PARAM_ERROR))
-
-        json_config.update({"scope": ["Tensor_Add"]})
-        json_config.update({"list": "Tensor_Add"})
-        base_config = BaseConfig(json_config)
-        base_config.check_config()
-        self.assertEqual(mock_error_log_with_exp.call_args[0][0],
-                         "list is invalid, it should be a list")
-        self.assertEqual(str(mock_error_log_with_exp.call_args[0][1]),
-                         MsaccException.err_strs.get(MsaccException.INVALID_PARAM_ERROR))
-
-        json_config.update({"scope": ["Tensor_Add"]})
-        json_config.update({"list": ["Tensor_Add"]})
-        json_config.update({"data_mode": "all"})
-        base_config = BaseConfig(json_config)
-        base_config.check_config()
-        self.assertEqual(mock_error_log_with_exp.call_args[0][0],
-                         "data_mode is invalid, it should be a list")
-        self.assertEqual(str(mock_error_log_with_exp.call_args[0][1]),
-                         MsaccException.err_strs.get(MsaccException.INVALID_PARAM_ERROR))

msprobe/test/core_ut/test_file_check.py

@@ -1,218 +0,0 @@
-#!/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

@@ -1,109 +0,0 @@
-#!/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

@@ -1,51 +0,0 @@
-#!/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)