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

msprobe/test/mindspore_ut/test_debugger_config.py

@@ -1,42 +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 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

@@ -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.
-"""
-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

@@ -1,66 +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.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

@@ -1,63 +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.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

@@ -1,69 +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, 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.")

msprobe/test/mindspore_ut/test_overflow_check_tool_factory.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.
-"""
-from unittest import TestCase
-
-from msprobe.core.common_config import CommonConfig, BaseConfig
-from msprobe.mindspore.debugger.debugger_config import DebuggerConfig
-from msprobe.mindspore.overflow_check.overflow_check_tool_factory import OverflowCheckToolFactory
-
-
-class TestOverflowCheckToolFactory(TestCase):
-
-    def test_create(self):
-        json_config = {
-            "task": "overflow_check",
-            "dump_path": "/absolute_path",
-            "rank": [],
-            "step": [],
-            "level": "L2"
-        }
-
-        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:
-            OverflowCheckToolFactory.create(config)
-        self.assertEqual(str(context.exception), "valid level is needed.")
-
-        config.level = "cell"
-        with self.assertRaises(Exception) as context:
-            OverflowCheckToolFactory.create(config)
-        self.assertEqual(str(context.exception), "Overflow check in not supported in this mode.")
-
-        config.level = "kernel"
-        dumper = OverflowCheckToolFactory.create(config)
-        self.assertEqual(dumper.dump_json["common_dump_settings"]["file_format"], "npy")

msprobe/test/mindspore_ut/test_precision_debugger.py

@@ -1,56 +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_config import CommonConfig, BaseConfig
-from msprobe.mindspore.debugger.debugger_config import DebuggerConfig
-from msprobe.mindspore.debugger.precision_debugger import PrecisionDebugger
-
-
-class TestPrecisionDebugger(TestCase):
-    def test_start(self):
-        class Handler:
-            called = False
-
-            def handle(self):
-                Handler.called = True
-
-        json_config = {
-            "task": "statistics",
-            "dump_path": "/absolute_path",
-            "rank": [],
-            "step": [],
-            "level": "L1"
-        }
-
-        common_config = CommonConfig(json_config)
-        task_config = BaseConfig(json_config)
-        handler = Handler()
-
-        with patch("msprobe.mindspore.debugger.precision_debugger.parse_json_config",
-                   return_value=[common_config, task_config]), \
-             patch("msprobe.mindspore.debugger.precision_debugger.TaskHandlerFactory.create", return_value=handler):
-            debugger = PrecisionDebugger()
-            debugger.start()
-        self.assertTrue(isinstance(debugger.config, DebuggerConfig))
-        self.assertTrue(Handler.called)
-
-        PrecisionDebugger._instance = None
-        with self.assertRaises(Exception) as context:
-            debugger.start()
-        self.assertEqual(str(context.exception), "No instance of PrecisionDebugger found.")

msprobe/test/mindspore_ut/test_task_handler_factory.py

@@ -1,58 +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_config import CommonConfig, BaseConfig
-from msprobe.mindspore.debugger.debugger_config import DebuggerConfig
-from msprobe.mindspore.dump.kernel_graph_dump import KernelGraphDump
-from msprobe.mindspore.task_handler_factory import TaskHandlerFactory
-
-
-class TestTaskHandlerFactory(TestCase):
-
-    def test_create(self):
-        class HandlerFactory:
-            def create(self):
-                return None
-
-        tasks = {"statistics": HandlerFactory}
-
-        json_config = {
-            "task": "statistics",
-            "dump_path": "/absolute_path",
-            "rank": [],
-            "step": [],
-            "level": "L2"
-        }
-
-        common_config = CommonConfig(json_config)
-        task_config = BaseConfig(json_config)
-        config = DebuggerConfig(common_config, task_config)
-
-        handler = TaskHandlerFactory.create(config)
-        self.assertTrue(isinstance(handler, KernelGraphDump))
-
-        with patch("msprobe.mindspore.task_handler_factory.TaskHandlerFactory.tasks", new=tasks):
-            with self.assertRaises(Exception) as context:
-                TaskHandlerFactory.create(config)
-            self.assertEqual(str(context.exception), "Can not find task handler")
-
-        config.task = "free_benchmark"
-        with self.assertRaises(Exception) as context:
-            TaskHandlerFactory.create(config)
-        self.assertEqual(str(context.exception), "valid task is needed.")

msprobe/test/pytorch_ut/advisor/test_advisor.py

@@ -1,83 +0,0 @@
-import difflib
-import os
-import shutil
-import unittest
-import logging
-from unittest.mock import patch
-
-import pandas
-
-from msprobe.pytorch.advisor.advisor import Advisor
-from msprobe.pytorch.advisor.advisor_const import AdvisorConst
-
-
-class TestAdvisor(unittest.TestCase):
-
-    def setUp(self):
-        self.base_test_dir = os.path.dirname(os.path.dirname(os.path.dirname(os.path.realpath(__file__))))
-        self.input_dir = os.path.join(self.base_test_dir, 'resources')
-        self.output_path = os.path.abspath(os.path.join(self.base_test_dir, 'test_output'))
-
-        os.makedirs(self.output_path, mode=0o700, exist_ok=True)
-        self.has_error = False
-
-        self.input_data = pandas.read_csv(os.path.join(self.input_dir, 'compare_result_20230703104808.csv'))
-        self.advisor = Advisor(self.input_data, self.output_path)
-
-    def tearDown(self) -> None:
-        shutil.rmtree(self.output_path, ignore_errors=True)
-
-    @patch("os.path.realpath")
-    def test_init(self, mock_realpath):
-        mock_realpath.return_value = 'real_output_path'
-        adv = Advisor(self.input_data, self.output_path)
-        self.assertEqual(adv.out_path, 'real_output_path')
-
-    def test_deterministic_advisor_when_api_in_need_determ_api(self):
-        msg = self.advisor.deterministic_advisor('', 'Functional.layer_norm.0.forward_input.0')
-        self.assertEqual(msg, AdvisorConst.DETERMINISTIC_SUGGEST)
-
-    def test_deterministic_advisor_when_api_not_in_need_determ_api(self):
-        mock_message = 'mock message'
-        msg = self.advisor.deterministic_advisor(mock_message, 'Functional.linear.0.forward_input.0')
-        self.assertEqual(msg, mock_message)
-
-    def test_batch_norm_advisor(self):
-        mock_message = 'mocked batch norm advisor message'
-        msg1 = self.advisor.batch_norm_advisor(mock_message, AdvisorConst.FUNC_BATCH_NORM + '' +
-                                               AdvisorConst.FORWARD_INPUT_1)
-        msg2 = self.advisor.batch_norm_advisor(mock_message, 'Functional.linear.0.forward_output.1')
-        self.assertEqual(msg1, AdvisorConst.BATCH_NORM_SUGGEST)
-        self.assertEqual(msg2, mock_message)
-
-    def test_gen_advisor_message(self):
-        self.assertIn(AdvisorConst.FORWARD_OUTPUT_SUGGEST, self.advisor.gen_advisor_message(
-            'Functional.linear.0.forward_output.1'))
-        self.assertIn(AdvisorConst.BACKWARD_INPUT_SUGGEST, self.advisor.gen_advisor_message(
-            'Functional.linear.0.backward_input.1'))
-
-    def test_advisor_summary_file(self):
-        self.advisor.analysis()
-        filenames = os.listdir(self.output_path)
-        for filename in filenames:
-            filename = os.path.join(self.output_path, filename)
-            self.result_check(os.path.join(self.input_dir, 'advisor.txt'), filename)
-        self.assertFalse(self.has_error)
-
-    def result_check(self, standard_file, output_file):
-        with open(standard_file, 'r', encoding='utf-8') as st_file:
-            standard_content = st_file.read().splitlines()
-        with open(output_file, 'r', encoding='utf-8') as out_file:
-            output_content = out_file.read().splitlines()
-        result = list(difflib.unified_diff(standard_content, output_content, n=0))
-        if result:
-            logging.basicConfig(level=logging.INFO)
-            logging.info('\n\n-------------------------------------------------------------------------')
-            logging.error(f'[ERROR] {output_file.replace(self.output_path, "")} advisor summary are inconsistent.')
-            logging.error('\n'.join(result))
-            logging.info('\n\n-------------------------------------------------------------------------')
-            self.has_error = True
-
-
-if __name__ == '__main__':
-    unittest.main()

msprobe/test/pytorch_ut/api_accuracy_checker/common/test_common_utils.py

@@ -1,108 +0,0 @@
-import unittest
-from unittest.mock import patch
-
-from msprobe.pytorch.api_accuracy_checker.common.utils import *
-
-
-class TestUtils(unittest.TestCase):
-
-    @patch('msprobe.pytorch.api_accuracy_checker.common.utils.get_file_content_bytes')
-    def test_get_json_contents_should_raise_exception(self, mock_get_file_content_bytes):
-        mock_get_file_content_bytes.return_value = 'not a dict'
-        with self.assertRaises(CompareException) as ce:
-            get_json_contents('')
-        self.assertEqual(ce.exception.code, CompareException.INVALID_FILE_ERROR)
-
-    def test_get_json_contents_should_return_json_obj(self):
-        test_dict = {"key": "value"}
-        file_name = 'test.json'
-
-        fd = os.open(file_name, os.O_CREAT | os.O_WRONLY | os.O_TRUNC, 0o644)
-        with os.fdopen(fd, 'w') as f:
-            json.dump(test_dict, f)
-        self.assertEqual(get_json_contents(file_name), test_dict)
-        os.remove(file_name)
-
-    def test_write_csv(self):
-        test_file_name = 'test.csv'
-        test_data = [["name", "age"], ["Alice", "20"], ["Bob", "30"]]
-        write_csv(test_data, 'test.csv')
-        with open(test_file_name, 'r', encoding='utf-8-sig') as f:
-            reader = csv.reader(f)
-            for i, row in enumerate(reader):
-                self.assertEqual(row, test_data[i])
-        os.remove(test_file_name)
-
-    def test_check_need_convert(self):
-        self.assertEqual(check_need_convert('cross_entropy'), 'int32_to_int64')
-        self.assertIsNone(check_need_convert('linear'))
-
-    def test_check_object_type(self):
-        try:
-            check_object_type(123, int)
-        except Exception as e:
-            self.fail(f"check_object_type raised exception {e}")
-
-    def test_check_file_or_directory_path(self):
-        try:
-            check_file_or_directory_path(__file__)
-        except Exception as e:
-            self.fail(f"check_file_or_directory_path raised exception {e}")
-
-    def test_create_directory(self):
-        test_dir_name = 'test_dir'
-        create_directory(test_dir_name)
-        self.assertTrue(os.path.exists(test_dir_name))
-        os.rmdir(test_dir_name)
-
-    def test_get_file_content_bytes(self):
-        fd = os.open('test.txt', os.O_CREAT | os.O_WRONLY | os.O_TRUNC, 0o644)
-        with os.fdopen(fd, 'w') as f:
-            f.write("Hello, World!")
-        self.assertEqual(get_file_content_bytes('test.txt'), b"Hello, World!")
-        os.remove('test.txt')
-
-    @patch('os.path.exists')
-    def test_check_file_or_dir_path_should_raise_exe_when_dir_path_not_existed(self, mock_path_exists):
-        mock_path_exists.return_value = False
-        with self.assertRaises(CompareException) as ce:
-            check_file_or_directory_path('', isdir=True)
-        self.assertEqual(ce.exception.code, CompareException.INVALID_PATH_ERROR)
-
-    @patch('os.path.exists')
-    @patch('os.path.isdir')
-    @patch('os.access')
-    def test_check_file_or_dir_path_should_pass_when_path_is_dir(self, mock_os_access, mock_path_is_dir,
-                                                                 mock_path_exists):
-        mock_os_access.return_value = True
-        mock_path_is_dir.return_value = True
-        mock_path_exists.return_value = True
-        check_file_or_directory_path('', isdir=True)
-
-    @patch('os.path.isfile')
-    @patch('os.access')
-    def test_check_file_or_dir_path_should_raise_exe_when_file_not_access(self, mock_os_access, mock_path_is_file):
-        mock_os_access.return_value = False
-        mock_path_is_file.return_value = True
-        with self.assertRaises(CompareException) as ce:
-            check_file_or_directory_path('', isdir=False)
-        self.assertEqual(ce.exception.code, CompareException.INVALID_PATH_ERROR)
-
-    def test_check_file_or_dir_path_should_pass_when_path_is_file(self):
-        with unittest.mock.patch('os.path.isfile', return_value=True), \
-                unittest.mock.patch('os.access', return_value=True):
-            check_file_or_directory_path('', isdir=False)
-
-    def test_api_info_preprocess_no_conversion_needed(self):
-        api_name = 'linear'
-        original_api_info = {'key': 'value'}
-        convert_type, processed_api_info = api_info_preprocess(api_name, original_api_info.copy())
-        self.assertIsNone(convert_type)
-        self.assertEqual(original_api_info, processed_api_info)
-
-    def test_api_info_preprocess_cross_entropy_positive(self):
-        api_name = 'cross_entropy'
-        api_info = {'args': [{'Name': 'logit'}, {'Name': 'labels', 'Min': 1}]}
-        convert_type, processed_api_info = api_info_preprocess(api_name, api_info.copy())
-        self.assertEqual(convert_type, 'int32_to_int64')
-        self.assertEqual(processed_api_info, api_info)