mindstudio-probe 1.0.1__py3-none-any.whl

msprobe/test/core_ut/data_dump/test_json_writer.py

@@ -0,0 +1,183 @@
+import unittest
+from msprobe.core.data_dump.json_writer import DataWriter
+
+import os
+import csv
+from msprobe.core.common.file_check import FileOpen
+from msprobe.core.common import utils
+from pathlib import Path
+import json
+
+class TestDataWriter(unittest.TestCase):
+    def test_write_data_to_csv(self):
+        cur_path = os.path.dirname(os.path.realpath(__file__))
+        file_path = os.path.join(cur_path, "test.csv")
+
+        if os.path.exists(file_path):
+            utils.remove_path(file_path)
+
+        data = {"A":"1", "B":"2", "C":"3"}
+        result = data.values()
+        header = data.keys()
+        DataWriter.write_data_to_csv(result, header, file_path)
+        with FileOpen(file_path, "r") as f:
+            reader = csv.DictReader(f)
+            column_first = [row for row in reader][0]
+        self.assertEqual(data, column_first)
+
+        
+        
+        
+        data = {"A":"4", "B":"5", "C":"6"}
+        result = data.values()
+        header = data.keys()
+        DataWriter.write_data_to_csv(result, header, file_path)
+        with FileOpen(file_path, "r") as f:
+            reader = csv.DictReader(f)
+            column_last = [row for row in reader][-1]
+        self.assertEqual(data, column_last)
+
+        utils.remove_path(file_path)
+
+    def test_initialize_json_file(self):
+        cur_path = os.path.dirname(os.path.realpath(__file__))
+        dump_tensor_data_dir = os.path.join(cur_path, "dump_tensor_data.json")
+        dump_file_path = os.path.join(cur_path, "dump_file.json")
+        stack_file_path = os.path.join(cur_path, "stack_file.json")
+        construct_file_path = os.path.join(cur_path, "construct_file.json")
+        if not os.path.exists(stack_file_path):
+            Path(stack_file_path).touch()
+        if not os.path.exists(construct_file_path):
+            Path(construct_file_path).touch()
+
+        test = DataWriter()
+        test.stack_file_path = stack_file_path
+        test.dump_file_path = dump_file_path
+        test.dump_tensor_data_dir = dump_tensor_data_dir
+        test.construct_file_path = construct_file_path
+
+        test.initialize_json_file()
+
+        with open(dump_file_path) as f:
+            load_data = json.load(f)
+        result = {"dump_data_dir": dump_tensor_data_dir, "data": {}}
+        self.assertEqual(result, load_data)
+        is_exist_1 = os.path.exists(test.stack_file_path)
+        self.assertTrue(is_exist_1)
+        os.access(test.stack_file_path, os.R_OK)
+        os.access(test.stack_file_path, os.W_OK)
+        is_exist_2 = os.path.exists(test.construct_file_path)
+        self.assertTrue(is_exist_2)
+        os.access(test.construct_file_path, os.R_OK)
+        os.access(test.construct_file_path, os.W_OK)
+
+        os.remove(construct_file_path)
+        os.remove(stack_file_path)
+        os.remove(dump_file_path)
+
+    def test_update_dump_paths(self):
+        test = DataWriter()
+        self.assertTrue(test.dump_file_path == None)
+
+        cur_path = os.path.dirname(os.path.realpath(__file__))
+        test_path = os.path.join(cur_path, "test1.json")
+
+        test.update_dump_paths(test_path, test_path, test_path, test_path, test_path)
+        self.assertTrue(test.dump_file_path == test_path)
+        self.assertTrue(test.stack_file_path == test_path)
+        self.assertTrue(test.construct_file_path == test_path)
+        self.assertTrue(test.dump_tensor_data_dir == test_path)
+        self.assertTrue(test.free_benchmark_file_path == test_path)
+
+    def test_update_data(self):
+        data = {"A":"1", "B":"2", "C":{"D":"2"}}
+        test = DataWriter()
+        test.cache_data["data"]["test_1"] = True
+        test.cache_data["data"]["test_2"] = False
+
+        test.update_data(data)
+        self.assertEqual(test.cache_data["data"]["A"], "1")
+
+        new_data = {"C":{"F":3}}
+        test.update_data(new_data)
+        self.assertEqual(test.cache_data["data"]["C"]["F"], 3)
+
+
+    def test_flush_data_when_buffer_is_full_and_test_write_data_json(self):
+        data = {"A":"1", "B":"2", "data":{}}
+        test = DataWriter()
+        test.buffer_size = 1
+        test.cache_data["data"] = {"A":"1", "B":"2", "C":"3"}
+
+        self.assertTrue(len(test.cache_data["data"]) >= test.buffer_size)
+        cur_path = os.path.dirname(os.path.realpath(__file__))
+        dump_tensor_data_dir = os.path.join(cur_path, "dump_tensor_data.json")
+        dump_file_path = os.path.join(cur_path, "dump_file.json")
+        stack_file_path = os.path.join(cur_path, "stack_file.json")
+        construct_file_path = os.path.join(cur_path, "construct_file.json")
+
+        test.dump_file_path = dump_file_path
+        test.dump_tensor_data_dir = dump_tensor_data_dir
+
+        with open(dump_file_path, "w") as f:
+            dump_data = json.dumps(data)
+            f.write(dump_data)
+
+        test.flush_data_when_buffer_is_full()
+
+        with open(dump_file_path, "r") as f:
+            new_data = json.load(f)
+        
+        data.update({"data": {"A":"1", "B":"2", "C":"3"}})
+        self.assertEqual(new_data, data)
+
+        self.assertTrue(test.cache_data["data"] == {})
+        os.remove(dump_file_path)
+
+
+    def test_update_stack(self):
+        data = {"A":"1", "B":"2", "data":{}}
+        test = DataWriter()
+        test.update_stack(data)
+        self.assertEqual(test.cache_stack, data)
+
+    def test_update_construct(self):
+        data = {"A":"1", "B":"2", "data":{}}
+        test = DataWriter()
+        test.update_construct(data)
+        self.assertEqual(test.cache_construct, data)
+
+    def test_write_stack_info_json(self):
+        test = DataWriter()
+        data = {"A":"1", "B":"2", "data":{}}
+        test.cache_stack = data
+
+        cur_path = os.path.dirname(os.path.realpath(__file__))
+        file_path = os.path.join(cur_path, "dump.json")
+
+        test.write_stack_info_json(file_path)
+
+        with open(file_path, "r") as f:
+            load_result = json.load(f)
+        try:
+            self.assertEqual(load_result, data)
+        finally:
+            os.remove(file_path)
+
+
+    def test_write_construct_info_json(self):
+        test = DataWriter()
+        data = {"A":"1", "B":"2", "data":{}}
+        test.cache_construct = data
+
+        cur_path = os.path.dirname(os.path.realpath(__file__))
+        file_path = os.path.join(cur_path, "dump.json")
+
+        test.write_construct_info_json(file_path)
+
+        with open(file_path, "r") as f:
+            load_result = json.load(f)
+        try:
+            self.assertEqual(load_result, data)
+        finally:
+            os.remove(file_path)

msprobe/test/core_ut/data_dump/test_scope.py

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

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