#! /usr/bin/env python3
# -*- coding: UTF-8 -*-
# ----------------------------------------------------------------------------------------------------------
# Copyright (c) 2025 Huawei Technologies Co., Ltd.
# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
# CANN Open Software License Agreement Version 2.0 (the "License").
# Please refer to the License for details. You may not use this file except in compliance with the License.
# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
# INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
# See LICENSE in the root of the software repository for the full text of the License.
# ----------------------------------------------------------------------------------------------------------
"""
Opc test case
"""
import unittest
import os
import sys
import json
from unittest.mock import patch

THIS_FILE_NAME = __file__
FILE_PATH = os.path.dirname(os.path.realpath(THIS_FILE_NAME))
TOP_PATH = os.path.join(FILE_PATH, "../../../")
FRAMEWORK_PATH = os.path.join(
    TOP_PATH, "tools/build/")
ASC_OPC_PATH = os.path.join(
    TOP_PATH, "tools/build/asc_opc/python/asc_opc_tool/")
OPC_STUB_PATH = os.path.join(
    TOP_PATH, "tests/python/asc_opc/stub/")
sys.path.insert(0, FRAMEWORK_PATH)
sys.path.insert(0, ASC_OPC_PATH)
sys.path.insert(0, OPC_STUB_PATH)

from opc import OpcOptionParser
import opc as opc
import opc_api as opc_api
from constant import (GraphDtype, OpcCompileMode, OpcOptions, CompileParam, SupportInfo)
from op_compilation import OpCompilation
from opc_common import get_int64_mode
from op_info_store import load_set_op_content
import asc_op_compile_base.common.utils.log as logger
from op_compile_info_check import check_op_optional_paramtype
import tempfile

class RequiredValidArgs:
    """
    基础的参数，能确保opt_parser的check通过.
    """

    def __enter__(self):
        self.temp_op_file = tempfile.NamedTemporaryFile()
        return list([self.temp_op_file.name,
                     "--soc_version", "Ascend910",
                     "--bin_filename", "test_bin"])

    def __exit__(self, *unused):
        # 由于是temp文件，在关闭时会自动删除
        self.temp_op_file.close()


class TestOpc01(unittest.TestCase):
    def set_up(self):
        pass

    def tear_down(self):
        pass

    def test_dir_01(self):
        parser = OpcOptionParser()
        ret = parser.check_dir_valid("xxx")
        self.assertEqual(ret, False)

    def test_dir_02(self):
        parser = OpcOptionParser()
        ret = parser.check_dir_valid("C:\\Program Files\\JetBrains\\PyCharm 2019.2\\helpers\\")
        self.assertEqual(ret, False)


current_dir = os.path.abspath(os.getcwd())
class TestOpc02(unittest.TestCase):
    def set_up(self):
        pass

    def tear_down(self):
        pass

    def check_options(self, options, expect_options):
        '''
        "ne" means not exsit.
        '''
        op_path = options.get("op_path", "")
        input_param = options.get("input_param", "not_exist")
        main_func = options.get("main_func", "not_exist")
        soc_version = options.get("soc_version", "not_exist")
        output = options.get("output", "not_exist")
        debug_dir = options.get("debug_dir", "not_exist")
        h = options.get("h", "not_exist")
        log = options.get("log", "not_exist")
        core_type = options.get("core_type", "AiCore")
        aicore_num = options.get("aicore_num", "not_exist")
        mdl_bank_path = options.get("mdl_bank_path", "not_exist")
        op_bank_path = options.get("op_bank_path", "not_exist")
        op_debug_level = options.get("op_debug_level", "not_exist")
        impl_mode = options.get("impl_mode", "not exist")

        self.assertEqual(expect_options["op_path"], op_path)
        self.assertEqual(expect_options["input_param"], input_param)
        self.assertEqual(expect_options["main_func"], main_func)
        self.assertEqual(expect_options["soc_version"], soc_version)
        logger.info("%s output %s", expect_options["output"], output)
        self.assertEqual(expect_options["output"], output)
        debug_dir_check = expect_options["debug_dir"] in debug_dir
        logger.info("%s output %s, debug_dir_check %s", expect_options["debug_dir"], debug_dir, debug_dir_check)
        self.assertEqual(debug_dir_check, True)
        logger.info("%s output %s", expect_options["h"], h)
        self.assertEqual(expect_options["h"], h)
        logger.info("%s output %s", expect_options["log"], log)
        self.assertEqual(expect_options["log"], log)
        logger.info("%s output %s", expect_options.get("core_type"), core_type)


    def test_options_parser_01(self):
        logger.info(current_dir)
        logger.info("Start to execute ==============test_options_parser_01==============")
        test_root_dir = os.path.abspath(os.path.dirname(__file__))
        input_param_path = test_root_dir + "/stub/files/matmul_test.json"

        sys.argv = ["xx", "--op_path=./op_impl/dynamic/mat_mul.py", "--main_func=mat_mul",
                    "--input_param=" + input_param_path, "--soc_version=Ascend910A",
                    "--output=./output"]
        ret, opt_parser = opc.parse_args()
        opc.op_compile_classify(opt_parser)
        options = opt_parser.get_all_options()
        expect_options = {
            "op_path" : "--op_path=./op_impl/dynamic/mat_mul.py",
            "input_param" : input_param_path,
            "main_func" : "mat_mul",
            "soc_version" : "Ascend910A",
            "output" : current_dir +"/output",
            "debug_dir" : current_dir,
            "h" : "False",
            "log" : "null",
            "core_type" : "AiCore",
        }
        self.assertEqual(opt_parser.check_input_params(), False)
        self.check_options(options, expect_options)


    def test_options_parser_02(self):
        '''
        op path use relative path, which does not exist
        :return:
        '''
        logger.info("Start to execute ==============test_options_parser_02==============")
        test_root_dir = os.path.abspath(os.path.dirname(__file__))
        input_param_path = test_root_dir + "/stub/files/matmul_test.json"

        sys.argv = ["xx", "../../stub/files/mat_mul.py", "--main_func=mat_mul",
                    "--input_param=" + input_param_path, "--soc_version=Ascend910A",
                    "--output=./output"]
        ret, opt_parser = opc.parse_args()
        opc.op_compile_classify(opt_parser)
        options = opt_parser.get_all_options()
        expect_options = {
            "op_path" : "../../stub/files/mat_mul.py",
            "input_param" : input_param_path,
            "main_func" : "mat_mul",
            "soc_version" : "Ascend910A",
            "output" : current_dir +"/output",
            "debug_dir" : current_dir,
            "h" : "False",
            "log" : "null",
            "core_type" : "AiCore",
        }
        self.assertEqual(opt_parser.check_input_params(), False)
        self.check_options(options, expect_options)


    def test_options_parser_03(self):
        '''
        input param: matmul_test_false.json does not exist
        :return:
        '''
        logger.info("Start to execute ==============test_options_parser_03==============")
        test_root_dir = os.path.abspath(os.path.dirname(__file__))
        input_param_path = test_root_dir + "/stub/files/matmul_test_false.json"
        op_path = test_root_dir + "/stub/files/mat_mul.py"
        sys.argv = ["xx", op_path, "--main_func=mat_mul",
                    "--input_param=" + input_param_path, "--soc_version=Ascend910A",
                    "--output=./output"]

        ret, opt_parser = opc.parse_args()
        opc.op_compile_classify(opt_parser)
        options = opt_parser.get_all_options()
        expect_options = {
            "op_path" : op_path,
            "input_param" : input_param_path,
            "main_func" : "mat_mul",
            "soc_version" : "Ascend910A",
            "output" : current_dir +"/output",
            "debug_dir" : current_dir,
            "h" : "False",
            "log" : "null",
            "core_type" : "AiCore",
        }
        self.assertEqual(opt_parser.check_input_params(), False)
        self.check_options(options, expect_options)


    def test_options_parser_04(self):
        '''
        op path is empty, --main_func=mat_mul will be
        considered as op path
        :return:
        '''
        logger.info("Start to execute ==============test_options_parser_04==============")
        test_root_dir = os.path.abspath(os.path.dirname(__file__))
        input_param_path = test_root_dir + "/stub/files/matmul_test.json"

        sys.argv = ["xx", "--main_func=mat_mul",
                    "--input_param=" + input_param_path, "--soc_version=Ascend910A",
                    "--output=./output"]
        ret, opt_parser = opc.parse_args()
        opc.op_compile_classify(opt_parser)
        options = opt_parser.get_all_options()
        expect_options = {
            "op_path" : "",
            "input_param" : input_param_path,
            "main_func" : "mat_mul",
            "soc_version" : "Ascend910A",
            "output" : current_dir +"/output",
            "debug_dir" : current_dir,
            "h" : "False",
            "log" : "null",
            "core_type" : None,
        }
        self.assertEqual(opt_parser.check_input_params(), True)
        self.check_options(options, expect_options)


    def test_options_parser_05(self):
        '''
        correct case
        :return:
        '''
        logger.info("Start to execute ==============test_options_parser_05==============")
        test_root_dir = os.path.abspath(os.path.dirname(__file__))
        input_param_path = test_root_dir + "/stub/files/matmul_test.json"
        op_path = test_root_dir + "/stub/files/mat_mul.py"

        sys.argv = ["xx", op_path, "--main_func=mat_mul",
                    "--input_param=" + input_param_path, "--soc_version=Ascend910A",
                    "--output=./output"]
        ret, opt_parser = opc.parse_args()
        opc.op_compile_classify(opt_parser)
        options = opt_parser.get_all_options()
        expect_options = {
            "op_path" : op_path,
            "input_param" : input_param_path,
            "main_func" : "mat_mul",
            "soc_version" : "Ascend910A",
            "output" : current_dir + "/output",
            "debug_dir" : current_dir,
            "h" : "False",
            "log" : "null",
            "core_type" : None,
        }
        self.assertEqual(opt_parser.check_input_params(), True)
        self.check_options(options, expect_options)


    def test_options_parser_06(self):
        '''
        soc version is empty
        :return:
        '''
        logger.info("Start to execute ==============test_options_parser_06==============")
        test_root_dir = os.path.abspath(os.path.dirname(__file__))
        input_param_path = test_root_dir + "/stub/files/matmul_test.json"
        op_path = test_root_dir + "/stub/files/mat_mul.py"

        sys.argv = ["xx", op_path, "--main_func=mat_mul",
                    "--input_param=" + input_param_path,
                    "--output=./output"]
        ret, opt_parser = opc.parse_args()
        opc.op_compile_classify(opt_parser)
        options = opt_parser.get_all_options()
        expect_options = {
            "op_path" : op_path,
            "input_param" : input_param_path,
            "main_func" : "mat_mul",
            "soc_version" : "",
            "output" : "./output",
            "debug_dir" : "./",
            "h" : "False",
            "log" : "null",
            "core_type" : "AiCore",
        }
        self.assertEqual(opt_parser.check_input_params(), False)
        self.check_options(options, expect_options)


    def test_options_parser_07(self):
        '''
        main_func is empty, which is allowed
        :return:
        '''
        logger.info("Start to execute ==============test_options_parser_07==============")
        test_root_dir = os.path.abspath(os.path.dirname(__file__))
        input_param_path = test_root_dir + "/stub/files/matmul_test.json"
        op_path = test_root_dir + "/stub/files/mat_mul.py"

        sys.argv = ["xx", op_path,
                    "--input_param=" + input_param_path, "--soc_version=Ascend910A",
                    "--output=./output"]
        ret, opt_parser = opc.parse_args()
        opc.op_compile_classify(opt_parser)
        options = opt_parser.get_all_options()
        expect_options = {
            "op_path" : op_path,
            "input_param" : input_param_path,
            "main_func" : None,
            "soc_version" : "Ascend910A",
            "output" : current_dir + "/output",
            "debug_dir" : current_dir,
            "h" : "False",
            "log" : "null",
            "core_type" : None,
        }
        self.assertEqual(opt_parser.check_input_params(), True)
        self.check_options(options, expect_options)


    def test_options_parser_08(self):
        '''
        output is empty, which will use current dir as output dir
        :return:
        '''
        logger.info("Start to execute ==============test_options_parser_08==============")
        test_root_dir = os.path.abspath(os.path.dirname(__file__))
        input_param_path = test_root_dir + "/stub/files/matmul_test.json"
        op_path = test_root_dir + "/stub/files/mat_mul.py"

        sys.argv = ["xx", op_path, "--main_func=mat_mul",
                    "--input_param=" + input_param_path, "--soc_version=Ascend910A",
                    "--output=./output"]
        ret, opt_parser = opc.parse_args()
        opc.op_compile_classify(opt_parser)
        options = opt_parser.get_all_options()
        expect_options = {
            "op_path" : op_path,
            "input_param" : input_param_path,
            "main_func" : "mat_mul",
            "soc_version" : "Ascend910A",
            "output" : current_dir + "/output",
            "debug_dir" : current_dir,
            "h" : "False",
            "log" : "null",
            "core_type" : None,
        }
        self.assertEqual(opt_parser.check_input_params(), True)
        self.check_options(options, expect_options)


    def test_options_parser_09(self):
        '''
        debug dir is empty, which will use current dir(./) as debug dir
        :return:
        '''
        logger.info("Start to execute ==============test_options_parser_09==============")
        test_root_dir = os.path.abspath(os.path.dirname(__file__))
        input_param_path = test_root_dir + "/stub/files/matmul_test.json"
        op_path = test_root_dir + "/stub/files/mat_mul.py"

        sys.argv = ["xx", op_path, "--main_func=mat_mul",
                    "--input_param=" + input_param_path, "--soc_version=Ascend910A",
                    "--output=./output"]
        ret, opt_parser = opc.parse_args()
        opc.op_compile_classify(opt_parser)
        options = opt_parser.get_all_options()
        expect_options = {
            "op_path" : op_path,
            "input_param" : input_param_path,
            "main_func" : "mat_mul",
            "soc_version" : "Ascend910A",
            "output" : current_dir + "/output",
            "debug_dir" : current_dir,
            "h" : "False",
            "log" : "null",
            "core_type" : None,
        }
        self.assertEqual(opt_parser.check_input_params(), True)
        self.check_options(options, expect_options)


    def test_options_parser_09_01(self):
        '''
        debug dir is not empty
        :return:
        '''
        logger.info("Start to execute ==============test_options_parser_09_01==============")
        test_root_dir = os.path.abspath(os.path.dirname(__file__))
        input_param_path = test_root_dir + "/stub/files/matmul_test.json"
        op_path = test_root_dir + "/stub/files/mat_mul.py"

        sys.argv = ["xx", op_path, "--main_func=mat_mul",
                    "--input_param=" + input_param_path, "--soc_version=Ascend910A",
                     "--op_debug_config=dump_cce",
                    "--output=./output", "--debug_dir=" + test_root_dir]
        ret, opt_parser = opc.parse_args()
        opc.op_compile_classify(opt_parser)
        options = opt_parser.get_all_options()
        expect_options = {
            "op_path" : op_path,
            "input_param" : input_param_path,
            "main_func" : "mat_mul",
            "soc_version" : "Ascend910A",
            "op_debug_config": "dump_cce",
            "output" : current_dir + "/output",
            "debug_dir" : test_root_dir,
            "h" : "False",
            "log" : "null",
            "core_type" : None,
        }
        self.assertEqual(opt_parser.check_input_params(), True)
        self.check_options(options, expect_options)


    def test_options_parser_09_02(self):
        '''
        output not exist, opc will create
        :return:
        '''
        logger.info("Start to execute ==============test_options_parser_09_02==============")
        test_root_dir = os.path.abspath(os.path.dirname(__file__))
        input_param_path = test_root_dir + "/stub/files/matmul_test.json"
        op_path = test_root_dir + "/stub/files/mat_mul.py"

        sys.argv = ["xx", op_path, "--main_func=mat_mul",
                    "--input_param=" + input_param_path, "--soc_version=Ascend910A",
                    "--output=./outputtemp"]
        ret, opt_parser = opc.parse_args()
        opc.op_compile_classify(opt_parser)
        options = opt_parser.get_all_options()
        expect_options = {
            "op_path" : op_path,
            "input_param" : input_param_path,
            "main_func" : "mat_mul",
            "soc_version" : "Ascend910A",
            "output" : current_dir + "/outputtemp",
            "debug_dir" : current_dir,
            "h" : "False",
            "log" : "null",
            "core_type" : None
        }
        self.assertEqual(opt_parser.check_input_params(), True)
        self.check_options(options, expect_options)
        #remove current_dir + "/outputtemp" create by opc
        if os.path.exists(current_dir + "/outputtemp"):
            logger.info("Delete existed output dir created by opc.")
            os.rmdir(current_dir + "/outputtemp")


    def test_options_parser_10(self):
        '''
        log is not empty
        :return:
        '''
        logger.info("Start to execute ==============test_options_parser_10==============")
        test_root_dir = os.path.abspath(os.path.dirname(__file__))
        input_param_path = test_root_dir + "/stub/files/matmul_test.json"
        op_path = test_root_dir + "/stub/files/mat_mul.py"

        sys.argv = ["xx", op_path, "--main_func=mat_mul",
                    "--input_param=" + input_param_path, "--soc_version=Ascend910A",
                    "--output=./output", "--log=debug"]
        ret, opt_parser = opc.parse_args()
        opc.op_compile_classify(opt_parser)
        options = opt_parser.get_all_options()
        expect_options = {
            "op_path" : op_path,
            "input_param" : input_param_path,
            "main_func" : "mat_mul",
            "soc_version" : "Ascend910A",
            "output" : current_dir + "/output",
            "debug_dir" : current_dir,
            "h" : "False",
            "log" : "debug",
            "core_type" : None,
        }
        self.assertEqual(opt_parser.check_input_params(), True)
        self.check_options(options, expect_options)
        self.assertEqual(opt_parser.get_option("log"), "debug")


    def test_options_parser_11(self):
        '''
        core_type is not empty
        :return:
        '''
        logger.info("Start to execute ==============test_options_parser_11==============")
        test_root_dir = os.path.abspath(os.path.dirname(__file__))
        input_param_path = test_root_dir + "/stub/files/matmul_test.json"
        op_path = test_root_dir + "/stub/files/mat_mul.py"

        sys.argv = ["xx", op_path, "--main_func=mat_mul",
                    "--input_param=" + input_param_path, "--soc_version=Ascend910A",
                    "--output=./output", "--log=debug", "--core_type=VectorCore"]
        ret, opt_parser = opc.parse_args()
        opc.op_compile_classify(opt_parser)
        options = opt_parser.get_all_options()
        expect_options = {
            "op_path" : op_path,
            "input_param" : input_param_path,
            "main_func" : "mat_mul",
            "soc_version" : "Ascend910A",
            "output" : current_dir + "/output",
            "debug_dir" : current_dir,
            "h" : "False",
            "log" : "debug",
            "core_type" : "VectorCore",
        }
        self.assertEqual(opt_parser.check_input_params(), True)
        self.check_options(options, expect_options)


    def test_options_parser_12(self):
        '''
        core_type is not empty
        :return:
        '''
        logger.info("Start to execute ==============test_options_parser_12==============")
        test_root_dir = os.path.abspath(os.path.dirname(__file__))
        input_param_path = test_root_dir + "/stub/files/matmul_test.json"
        op_path = test_root_dir + "/stub/files/mat_mul.py"

        sys.argv = ["xx", op_path, "--main_func=mat_mul",
                    "--input_param=" + input_param_path, "--soc_version=Ascend910A",
                    "--output=./output", "--log=debug", "--core_type=VectorCore"]
        ret, opt_parser = opc.parse_args()
        opc.op_compile_classify(opt_parser)
        options = opt_parser.get_all_options()
        expect_options = {
            "op_path" : op_path,
            "input_param" : input_param_path,
            "main_func" : "mat_mul",
            "soc_version" : "Ascend910A",
            "output" : current_dir + "/output",
            "debug_dir" : current_dir,
            "h" : "False",
            "log" : "debug",
            "core_type" : "VectorCore",
        }
        self.assertEqual(opt_parser.check_input_params(), True)
        self.check_options(options, expect_options)

    def test_options_parser_13(self):
        '''
        no arguments
        :return:
        '''
        logger.info("Start to execute ==============test_options_parser_13==============")
        sys.argv = ["xx"]
        ret, opt_parser = opc.parse_args()
        opc.op_compile_classify(opt_parser)
        options = opt_parser.get_all_options()
        expect_options = {
            "op_path" : "",
            "input_param" : None,
            "main_func" : None,
            "soc_version" : "",
            "output" : "",
            "debug_dir" : "",
            "h" : "False",
            "log" : "null",
            "core_type" : "AiCore",
        }
        self.assertEqual(opt_parser.check_input_params(), False)
        self.check_options(options, expect_options)

    def test_options_parser_14(self):
        '''
        -h and --help only
        :return:
        '''
        logger.info("Start to execute ==============test_options_parser_14==============")
        sys.argv = ["xx"]
        ret, opt_parser = opc.parse_args()
        opc.op_compile_classify(opt_parser)
        options = opt_parser.get_all_options()
        expect_options = {
            "op_path" : "",
            "input_param" : None,
            "main_func" : None,
            "soc_version" : "",
            "output" : "",
            "debug_dir" : "",
            "h" : "False",
            "log" : "null",
            "core_type" : "AiCore",
        }
        self.assertEqual(opt_parser.check_input_params(), False)
        self.check_options(options, expect_options)

    def test_options_parser_18(self):
        '''
        test invalid core_type: ai_vector
        '''
        logger.info("Start to execute ==============test_options_parser_18==============")
        test_root_dir = os.path.abspath(os.path.dirname(__file__))
        input_param_path = test_root_dir + "/stub/files/matmul_test.json"
        op_path = test_root_dir + "/stub/files/mat_mul.py"

        sys.argv = ["xx", op_path, "--main_func=mat_mul",
                    "--input_param=" + input_param_path, "--soc_version=Ascend910A",
                    "--output=./output", "--log=debug", "--core_type=ai_vector"]
        ret, opt_parser = opc.parse_args()
        opc.op_compile_classify(opt_parser)
        options = opt_parser.get_all_options()
        expect_options = {
            "op_path" : op_path,
            "input_param" : input_param_path,
            "main_func" : "mat_mul",
            "soc_version" : "Ascend910A",
            "output" : current_dir + "/output",
            "debug_dir" : current_dir,
            "h" : "False",
            "log" : "debug",
            "core_type" : "ai_vector"
        }
        self.assertEqual(opt_parser.check_input_params(), False)
        self.check_options(options, expect_options)


    def test_options_parser_19(self):
        '''
        test invalid aicore_num: sih
        '''
        logger.info("Start to execute ==============test_options_parser_19==============")
        test_root_dir = os.path.abspath(os.path.dirname(__file__))
        input_param_path = test_root_dir + "/stub/files/matmul_test.json"
        op_path = test_root_dir + "/stub/files/mat_mul.py"

        sys.argv = ["xx", op_path, "--main_func=mat_mul",
                    "--input_param=" + input_param_path, "--soc_version=Ascend910A",
                    "--output=./output", "--log=debug", "--aicore_num=sih"]
        try:
            ret, opt_parser = opc.parse_args()
        except SystemExit as e:
            logger.info("aicore_num only support digit.")
            self.assertEqual("1", str(e))


    def test_options_parser_20(self):
        '''
        test invalid mdl_bank_path
        '''
        logger.info("Start to execute ==============test_options_parser_20==============")
        test_root_dir = os.path.abspath(os.path.dirname(__file__))
        input_param_path = test_root_dir + "/stub/files/matmul_test.json"
        op_path = test_root_dir + "/stub/files/mat_mul.py"

        sys.argv = ["xx", op_path, "--main_func=mat_mul",
                    "--input_param=" + input_param_path, "--soc_version=Ascend910A",
                    "--output=./output", "--log=debug"]
        ret, opt_parser = opc.parse_args()
        opc.op_compile_classify(opt_parser)
        options = opt_parser.get_all_options()
        self.assertEqual(opt_parser.check_input_params(), True)

    def test_options_parser_21(self):
        '''
        test invalid op_bank_path
        '''
        logger.info("Start to execute ==============test_options_parser_21==============")
        test_root_dir = os.path.abspath(os.path.dirname(__file__))
        input_param_path = test_root_dir + "/stub/files/matmul_test.json"
        op_path = test_root_dir + "/stub/files/mat_mul.py"

        sys.argv = ["xx", op_path, "--main_func=mat_mul",
                    "--input_param=" + input_param_path, "--soc_version=Ascend910A",
                    "--output=./output", "--log=debug"]
        ret, opt_parser = opc.parse_args()
        opc.op_compile_classify(opt_parser)
        options = opt_parser.get_all_options()
        self.assertEqual(opt_parser.check_input_params(), True)

    def test_options_parser_22(self):
        '''
        test invalid op_debug_level
        '''
        logger.info("Start to execute ==============test_options_parser_22==============")
        test_root_dir = os.path.abspath(os.path.dirname(__file__))
        input_param_path = test_root_dir + "/stub/files/matmul_test.json"
        op_path = test_root_dir + "/stub/files/mat_mul.py"

        sys.argv = ["xx", op_path, "--main_func=mat_mul",
                    "--input_param=" + input_param_path, "--soc_version=Ascend910A",
                    "--output=./output", "--log=debug", "--op_debug_level=5", "--op_debug_config=dump_cce,dump_bin"]
        ret, opt_parser = opc.parse_args()
        opc.op_compile_classify(opt_parser)
        options = opt_parser.get_all_options()
        self.assertEqual(opt_parser.check_input_params(), False)


    def test_options_parser_23(self):
        '''
        test invalid impl_mode: ascend
        '''
        logger.info("Start to execute ==============test_options_parser_23==============")
        test_root_dir = os.path.abspath(os.path.dirname(__file__))
        input_param_path = test_root_dir + "/stub/files/matmul_test.json"
        op_path = test_root_dir + "/stub/files/mat_mul.py"

        sys.argv = ["xx", op_path, "--main_func=mat_mul",
                    "--input_param=" + input_param_path, "--soc_version=Ascend910A",
                    "--output=./output", "--log=debug", "--impl_mode=high_precision,enable_hi_float_32_execution"]
        ret, opt_parser = opc.parse_args()
        opc.op_compile_classify(opt_parser)
        options = opt_parser.get_all_options()
        self.assertEqual(opt_parser.check_input_params(), True)


    def test_options_parse_24(self):
        '''
        test valid core_type, aicore_num, mdl_bank_path, op_bank_path, impl_mode
        '''
        logger.info("Start to execute ==============test_options_parse_24==============")
        test_root_dir = os.path.abspath(os.path.dirname(__file__))
        path = test_root_dir + "/output"
        input_param_path = test_root_dir + "/stub/files/matmul_test.json"
        op_path = test_root_dir + "/stub/files/mat_mul.py"

        sys.argv = ["xx", op_path, "--main_func=mat_mul",
                    "--input_param=" + input_param_path, "--soc_version=Ascend910A",
                    "--output=./output", "--log=debug", "--core_type=AiCore",
                    "--aicore_num=1", "--impl_mode=high_performance"]
        ret, opt_parser = opc.parse_args()
        opc.op_compile_classify(opt_parser)
        options = opt_parser.get_all_options()
        self.assertEqual(opt_parser.check_input_params(), True)

    def test_options_parse_25(self):
        '''
        test valid core_type, aicore_num, mdl_bank_path, op_bank_path, impl_mode
        '''
        logger.info("Start to execute ==============test_options_parse_25==============")
        test_root_dir = os.path.abspath(os.path.dirname(__file__))
        path = test_root_dir + "/output"
        input_param_path = test_root_dir + "/stub/files/matmul_test.json"
        op_path = test_root_dir + "/stub/files/mat_mul.py"

        sys.argv = ["xx", op_path, "--main_func=mat_mul",
                    "--input_param=" + input_param_path, "--soc_version=Ascend910A",
                    "--output=./output", "--log=debug", "--core_type=AiCore,VectorCore",
                    "--aicore_num=1", "--impl_mode=high_performance", 
                    "--simplified_key_mode=0"]
        ret, opt_parser = opc.parse_args()
        opc.op_compile_classify(opt_parser)
        options = opt_parser.get_all_options()
        self.assertEqual(opt_parser.check_input_params(), True)

    def test_options_parser_debug_config(self):
        '''
        correct case
        :return:
        '''
        logger.info("Start to execute ==============ut_test_options_parser_debug_config==============")
        test_root_dir = os.path.abspath(os.path.dirname(__file__))
        input_param_path = test_root_dir + "/stub/files/matmul_test.json"
        op_path = test_root_dir + "/stub/files/mat_mul.py"

        sys.argv = ["xx", op_path, "--main_func=mat_mul",
                    "--input_param=" + input_param_path, "--soc_version=Ascend910A", "--op_debug_config=None",
                    "--output=./output"]
        ret, opt_parser = opc.parse_args()
        opc.op_compile_classify(opt_parser)
        self.assertEqual(opt_parser.check_input_params(), False)

    def test_options__deterministic__when_not_specified__will_set_to_all_as_default(self):
        sys.argv = []

        _, result_parser = opc.parse_args()
        result_option = result_parser.get_all_options()

        assert("deterministic" in result_option)
        assert(result_option["deterministic"] == "all")

    def test_options__deterministic__when_value_invalid__will_check_failed(self):
        def do_check_input_args(args):
            with RequiredValidArgs() as incare_required_args:
                sys.argv = incare_required_args + args
                _, result_parser = opc.parse_args()
                print(sys.argv)
            return result_parser.check_input_params()

        assert(do_check_input_args(["--deterministic", "all"]) == True)
        assert(do_check_input_args(["--deterministic", "true"]) == True)
        assert(do_check_input_args(["--deterministic", "false"]) == True)
        assert(do_check_input_args(["--deterministic", "other"]) == False)


    def test_options_parse_24(self):
        '''
        test valid core_type, aicore_num, mdl_bank_path, op_bank_path, impl_mode
        '''
        logger.info("Start to execute ==============test_options_parse_24==============")
        test_root_dir = os.path.abspath(os.path.dirname(__file__))
        path = test_root_dir + "/output"
        input_param_path = test_root_dir + "/stub/files/matmul_test.json"
        op_path = test_root_dir + "/stub/files/mat_mul.py"

        sys.argv = ["xx", op_path, "--main_func=mat_mul",
                    "--input_param=" + input_param_path, "--soc_version=Ascend910A",
                    "--output=./output", "--log=debug", "--core_type=AiCore",
                    "--aicore_num=1", "--impl_mode=high_performance",
                    "--optional_input_mode=gen_placeholder"]
        ret, opt_parser = opc.parse_args()
        self.assertEqual(ret, 0)
        opc.op_compile_classify(opt_parser)
        options = opt_parser.get_all_options()
        self.assertEqual(opt_parser.check_input_params(), True)

    # def test_op_compilation_config_file(self):
    #     """test test_op_compilation_config_file"""
    #     logger.debug("Start to execute ============ test_op_compilation_config_file ============")

    #     def del_files(file_path):
    #         for file_ in os.listdir(file_path):
    #             to_del_file = "{}/{}".format(file_path, file_)
    #             os.remove(to_del_file)

    #     test_root_dir = os.path.abspath(os.path.dirname(__file__))
    #     # make stub .o file
    #     with open(test_root_dir + "/debug_dir/kernel_meta_matmul_1/kernel_meta/matmul_1.o", "wb") as file_:
    #         pass
    #     input_param_path = test_root_dir + "/stub/files/matmul_1.json"
    #     opc_compile_args = {
    #         "input_param" : input_param_path,
    #         "soc_version" : "Ascend910A",
    #         "output" : test_root_dir + "/output",
    #         "debug_dir" : test_root_dir + "/debug_dir",
    #         "op_compile_classify": "single_op_compile_config_file_mode",
    #         "op_debug_level": 3,
    #         "op_debug_config": "dump_bin",
    #         "core_type" : "AiCore"
    #     }
    #     json_path = test_root_dir + "/stub/files/ascend910.json"
    #     load_set_op_content(json_path)
    #     op_compile = OpCompilation(opc_compile_args)
    #     ret = op_compile.op_compilation()
    #     self.assertEqual(ret, True)

    #     # delete stub .o file and outputs
    #     os.remove(test_root_dir + "/debug_dir/kernel_meta_matmul_1/kernel_meta/matmul_1.o")
    #     del_files(test_root_dir + "/output")

    #     logger.debug("End to execute ============ test_op_compilation_config_file ============")

    def test_check_op_optional_paramtype(self):
        """test check_op_optional_paramtype"""
        logger.debug("Start to execute ============ test_check_op_optional_paramtype ============")

        test_root_dir = os.path.abspath(os.path.dirname(__file__))
        input_param_path = test_root_dir + "/stub/files/apply_adam_v2.json"
        op_path = test_root_dir + "/stub/files/apply_adam_v2.py"
        opc_compile_args = {
            "op_path" : op_path,
            "input_param" : input_param_path,
            "soc_version" : "Ascend910A",
            "output" : test_root_dir + "/output",
            "debug_dir" : test_root_dir + "/debug_dir",
            "op_compile_classify": "single_op_compile_config_file_mode",
            "op_debug_level": 3,
            "optional_input_mode": "gen_placeholder"
        }
        try:
            with open(input_param_path, "r") as file_handle:
                json_dict = json.load(file_handle)
        except Exception as e:
            logger.error("load file[%s] failed, reason: %s.", input_param_path, str(e))
            return False, None
        finally:
            pass
        ret = check_op_optional_paramtype(json_dict, opc_compile_args)
        self.assertEqual(ret, True)
        logger.debug("End to execute ============ test_check_op_optional_paramtype ============")

    def test_get_int64_mode(self):
        """test_get_int64_mode"""
        logger.debug("Start to execute ============ test_get_int64_mode ============")

        test_root_dir = os.path.abspath(os.path.dirname(__file__))
        input_param_path = test_root_dir + "/stub/files/ConcatD.json"
        with open(input_param_path, "r") as file_in:
            json_data = json.load(file_in)
        op_list = json_data.get("op_list")
        for op_operator in op_list:
            ret = get_int64_mode(op_operator.get("inputs"))
            self.assertEqual(ret, False)
            ret = get_int64_mode(op_operator.get("outputs"))
            self.assertEqual(ret, False)

        logger.debug("End to execute ============ test_get_int64_mode ============")

    def test_compile_op_api(self):
        """test_compile_op_api"""
        logger.debug("Start to execute ============ test_compile_op_api ============")

        test_root_dir = os.path.abspath(os.path.dirname(__file__))
        input_param_path = test_root_dir + "/stub/files/sqrt.json"
        output_dir = test_root_dir + "/output"
        debug_dir = test_root_dir + "/debug_dir"
        op_path = test_root_dir + "/stub/files/Sqrt.py"
        with open(input_param_path, "r") as file_in:
            json_data = json.load(file_in)

        build_options = {
            "main_func": "sqrt",
            "op_debug_level": 2,
            "op_path" : op_path,
            "soc_version" : "Ascend910A",
            "output" : output_dir,
            "debug_dir" : debug_dir,
            "optional_input_mode": "gen_placeholder",
            "bin_filename": "Sqrt"
        }
        res = opc_api.compile_op(json_data, build_options)
        self.assertEqual(res, True)

        os.remove(test_root_dir + "/debug_dir/kernel_meta_Sqrt/kernel_meta/Sqrt.o")
        logger.debug("End to execute ============ test_compile_op_api ============")
        
    def test_compile_op_api_fail(self):
        """test_compile_op_api"""
        logger.debug("Start to execute ============ test_compile_op_api_fail ============")

        test_root_dir = os.path.abspath(os.path.dirname(__file__))
        input_param_path = test_root_dir + "/stub/files/MatMul_no_op_type.json"
        output_dir = test_root_dir + "/output"
        debug_dir = test_root_dir + "/debug_dir"
        op_path = test_root_dir + "/stub/files/sqrt.py"
        with open(input_param_path, "r") as file_in:
            json_data = json.load(file_in)

        build_options = {
            "op_path" : op_path,
            "soc_version" : "Ascend910A",
            "output" : output_dir,
            "debug_dir" : debug_dir,
            "optional_input_mode": "gen_placeholder",
            "bin_filename": "ConcatD",
            "test": "Not exsit"
        }
        res = opc_api.compile_op(json_data, build_options)
        self.assertEqual(res, False)

        logger.debug("End to execute ============ test_compile_op_api_fail ============")


if __name__ == '__main__':
    unittest.main()