-- Copyright (c) 2026 Huawei Technologies Co., Ltd.
-- openUBMC is licensed under Mulan PSL v2.
-- You can use this software according to the terms and conditions of the Mulan PSL v2.
-- You may obtain a copy of Mulan PSL v2 at:
--          http://license.coscl.org.cn/MulanPSL2
-- 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 FIT FOR A PARTICULAR PURPOSE.
-- See the Mulan PSL v2 for more details.

local lu = require('luaunit')
local chip = require('chip')
local old_write = chip.write
local log = require('mc.logging')
local chip_instance = chip.new('Eeprom_1')

TestChip = {}

local old_log_raise = log.raise
function TestChip:setUp()
    log.raise = function() end
end

function TestChip:tearDown()
    log.raise = old_log_raise
end

function TestChip:test_batch_write_once()
    local obj = {
        batch_write_data = { { Offset = 0, InData = { 0 } } },
        fetch = {
            cb = function()
                return false
            end,
        },
    }
    chip_instance.write_retry_times = 0
    chip_instance.write = nil
    local ret = chip_instance:batch_write_once(obj)
    lu.assertIsNil(ret)
    chip_instance.write = old_write
end

function TestChip:test_plugin_run_once()
    local obj = { run = nil, fetches = { { ['error'] = 0, result = 0, cb = function() end } } }
    local ret = chip_instance:plugin_run_once(obj)
    lu.assertIsNil(ret)
end

function TestChip:test_cpld_upg_run()
    local obj = { run = nil, fetch = { ['error'] = 0, result = 0, cb = function() end } }
    local ret = chip_instance:cpld_upg_run(obj)
    lu.assertIsNil(ret)
end

function TestChip:test_realtime_read()
    local fetch = { ['error'] = 0, result = 0, cb = function() end }
    chip_instance.accessors = {}
    chip_instance.high_cache = { queue_over_flag = { ['read'] = false }, queue_len = { ['read'] = 10 } }
    chip_instance.name = 'a'
    chip_instance.host_bus = { name = 'b' }
    local ret = chip_instance:realtime_read('accessor_1', fetch)
    lu.assertIsNil(ret)
end

function TestChip:test_realtime_write()
    local fetch = { ['error'] = 0, result = 0, cb = function() end }
    chip_instance.accessors = {}
    chip_instance.high_cache = { queue_over_flag = { ['write'] = false }, queue_len = { ['write'] = 10 } }
    chip_instance.name = 'a'
    chip_instance.host_bus = { name = 'b' }
    local ret = chip_instance:realtime_write('accessor_1', fetch)
    lu.assertIsNil(ret)
end

function TestChip:test_block_read()
    local fetch = { ['error'] = 0, result = 0, cb = function() end }
    chip_instance.accessible_status = false
    chip_instance.high_cache =
        { queue_over_flag = { ['read'] = false }, queue_len = { ['read'] = 10 }, read = function() end }
    chip_instance.name = 'a'
    chip_instance.host_bus = { name = 'b', notify_high_task = function() end }
    local ctx = {}
    local ret = chip_instance:block_read(fetch, ctx, 0, 1)
    lu.assertIsNil(ret)
end

function TestChip:test_block_read_with_low_priority()
    local fetch = { ['error'] = 0, result = 0, cb = function() end }
    chip_instance.accessible_status = false
    chip_instance.high_cache =
        { queue_over_flag = { ['read'] = false }, queue_len = { ['read'] = 10 }, read = function() end }
    chip_instance.low_cache =
        { queue_over_flag = { ['read'] = false }, queue_len = { ['read'] = 10 }, read = function() end }
    chip_instance.name = 'a'
    chip_instance.host_bus = { name = 'b', notify_high_task = function() end }
    local ctx = {}
    local ret = chip_instance:block_read_with_low_priority(fetch, ctx, 0, 1)
    lu.assertIsNil(ret)
end

function TestChip:test_block_write()
    local fetch = { ['error'] = 0, result = 0, cb = function() end }
    chip_instance.accessors = {}
    chip_instance.high_cache =
        { queue_over_flag = { ['write'] = false }, queue_len = { ['write'] = 10 }, ['write'] = function() end }
    chip_instance.name = 'a'
    chip_instance.host_bus = { name = 'b', notify_high_task = function() end }
    local ctx = {}
    local ret = chip_instance:block_write(fetch, ctx, 0, '0x1')
    lu.assertIsNil(ret)
end

function TestChip:test_block_batch_write()
    local fetch = { ['error'] = 0, result = 0, cb = function() end }
    chip_instance.accessors = {}
    chip_instance.high_cache = {
        queue_over_flag = { ['write'] = false, ['read'] = false },
        queue_len = { ['write'] = 10, ['read'] = 10 },
        ['write'] = function() end,
        ['read'] = function() end,
    }
    chip_instance.name = 'a'
    chip_instance.host_bus = { name = 'b', notify_high_task = function() end }
    local ctx = {}
    local ret = chip_instance:block_batch_write(fetch, ctx, '0x1')
    lu.assertIsNil(ret)
end

function TestChip:test_block_write_read()
    local fetch = { ['error'] = 0, result = 0, cb = function() end }
    chip_instance.accessors = {}
    chip_instance.high_cache = {
        queue_over_flag = { ['write'] = false, ['read'] = false },
        queue_len = { ['write'] = 10, ['read'] = 10 },
        ['write'] = function() end,
        ['read'] = function() end,
    }
    chip_instance.name = 'a'
    chip_instance.host_bus = { name = 'b', notify_high_task = function() end }
    local ctx = { ['Protocol'] = 'smbus' }
    local ret = chip_instance:block_write_read(fetch, ctx, '0x1', 1)
    lu.assertIsNil(ret)
end

function TestChip:test_block_combo_write_read()
    local fetch = { ['error'] = 0, result = 0, cb = function() end }
    chip_instance.accessors = {}
    chip_instance.high_cache = {
        queue_over_flag = { ['write'] = false, ['read'] = false },
        queue_len = { ['write'] = 10, ['read'] = 10 },
        ['write'] = function() end,
        ['read'] = function() end,
    }
    chip_instance.name = 'a'
    chip_instance.host_bus = { name = 'b', notify_high_task = function() end }
    local ctx = {}
    local ret = chip_instance:block_combo_write_read(fetch, ctx, 0, '0x1', 0, 1)
    lu.assertIsNil(ret)
end

function TestChip:test_bit_read()
    local fetch = { ['error'] = 0, result = 0, cb = function() end }
    chip_instance.accessible_status = false
    chip_instance.low_cache =
        { queue_over_flag = { ['read'] = false }, queue_len = { ['read'] = 10 }, read = function() end }
    chip_instance.name = 'a'
    chip_instance.host_bus = { name = 'b', notify_high_task = function() end }
    local ctx = {}
    local ret = chip_instance:bit_read(fetch, ctx, 0, 1, '0xff')
    lu.assertIsNil(ret)
end

function TestChip:test_bit_write()
    local fetch = { ['error'] = 0, result = 0, cb = function() end }
    chip_instance.accessible_status = false
    chip_instance.low_cache =
        { queue_over_flag = { ['write'] = false }, queue_len = { ['write'] = 10 }, write = function() end }
    chip_instance.name = 'a'
    chip_instance.host_bus = { name = 'b', notify_high_task = function() end }
    local ctx = {}
    local ret = chip_instance:bit_write(fetch, ctx, 0, 1, '0xff', '1')
    lu.assertIsNil(ret)
end

function TestChip:test_plugin_request()
    local fetch = { ['error'] = 0, result = 0, cb = function() end }
    chip_instance.accessible_status = false
    chip_instance.high_cache =
        { queue_over_flag = { ['plugin'] = false }, queue_len = { ['plugin'] = 10 }, plugin_request = function() end }
    chip_instance.name = 'a'
    chip_instance.host_bus = { name = 'b', notify_high_task = function() end, notify_secondary_task = function() end }
    local ftc_func = function() end
    local ret = chip_instance:plugin_request(fetch, ftc_func)
    lu.assertIsNil(ret)
end

function TestChip:test_write_and_read()
    local accessor = {
        offset = '0x01',
        mask = 0xff,
        type = 0,
        length = 1,
        protocol_flag = nil,
        data_in = '0x01',
        is_trace = true,
        requestor = 'bmc.kepler.hwproxy',
        address = 0,
    }
    chip_instance.driver = {
        address = 0,
        addr_width = 1,
        offset_width = 1,
    }
    chip_instance.name = 'chip_1'
    chip_instance.ismonitored = true
    local buffer = '0x01'
    local ok, _ = pcall(chip_instance.read, chip_instance, accessor)
    lu.assertIsFalse(ok)
    ok, _ = pcall(chip_instance.write, chip_instance, accessor, buffer)
    lu.assertIsFalse(ok)
end

function TestChip:test_chip_test()
    local count = 0
    local fetch = {
        error = '',
        result = 0,
        cb = function()
            count = count + 1
        end,
    }
    chip_instance.low_cache = { notify_parent = function() end }

    chip_instance:chip_test(fetch, { 1, 2, 3 })
    lu.assertEquals(#chip_instance.chip_test_fetches, 1)
    lu.assertEquals(chip_instance.chip_test_paras, { 1, 2, 3 })

    chip_instance:process_chip_test({ run_once = function() end })
    lu.assertIsNil(chip_instance.chip_test_fetches)
    lu.assertIsNil(chip_instance.chip_test_paras)
    lu.assertEquals(count, 0)

    chip_instance:chip_test(fetch, { 1, 101, 1011 })
    chip_instance:flush_chip_test('err')
    lu.assertIsNil(chip_instance.chip_test_fetches)
    lu.assertIsNil(chip_instance.chip_test_paras)
    lu.assertEquals(fetch.error, 'err')
    lu.assertEquals(fetch.result, 'Failed')
    lu.assertEquals(count, 1)
end

function TestChip:test_dump_chip_access_info()
    local dump_chip_info = chip_instance:dump_chip_access_info()
    lu.assertEquals(dump_chip_info[1].chip_name, 'a')
    lu.assertEquals(dump_chip_info[1].write_success_count, 0)
    lu.assertEquals(dump_chip_info[1].write_failed_count, 1)
    lu.assertEquals(type(dump_chip_info[1].err_table), 'table')
    lu.assertNotIsNil(string.match(dump_chip_info[1].err_table[1], 'Invalid chip type'))
end

function TestChip:test_stop()
    -- 打桩smc_dfx_info和aggregate_sections, 验证能正常进入分支执行停止回调
    chip_instance.smc_dfx_infos = {
        {
            stopped = false,
            stop = function(self)
                self.stopped = true
            end,
        },
    }
    chip_instance.aggregate_sections = {
        {
            stopped = false,
            stop = function(self)
                self.stopped = true
            end,
        },
    }
    chip_instance.low_cache.clean = function() end
    chip_instance.high_cache.clean = function() end
    chip_instance.secondary_cache.clean = function() end
    chip_instance.low_cache.clear_queue = function() end
    chip_instance.high_cache.clear_queue = function() end
    chip_instance.secondary_cache.clear_queue = function() end
    local ok, ret = pcall(chip_instance.stop, chip_instance)
    lu.assertEquals(ok, true)
    lu.assertIsNil(ret)
    lu.assertEquals(chip_instance.smc_dfx_infos[1].stopped, true)
    lu.assertEquals(chip_instance.aggregate_sections[1].stopped, true)
end

function TestChip:test_mcuswitch_combowriteread()
    local object = {
        name = 'Chip_Mcu_0101',
        class_name = 'Chip',
        SwitchSupported = true,
    }
    local ctx = {}
    local mock_data = '\x10\x20\x30'
    local chip_mcu = chip.new(object)
    chip_mcu.write = function(chip_obj, input, data)
        lu.assertEquals(data, '\x01\x02\x03')
    end
    chip_mcu.read = function()
        return mock_data
    end
    local ok, ret = pcall(chip_mcu.ComboWriteRead, chip_mcu, ctx, 0, '\x01\x02\x03')
    lu.assertEquals(ok, true)
    lu.assertEquals(ret, mock_data)
end

function TestChip:test_chip_new_with_delay()
    local object_with_delay = {
        name = 'Test_Chip_Delay',
        class_name = 'Chip',
        Delay = 100,
    }
    local chip_with_delay = chip.new(object_with_delay)
    lu.assertEquals(chip_with_delay.delay, 100)

    local object_without_delay = {
        name = 'Test_Chip_No_Delay',
        class_name = 'Chip',
        Delay = 0,
    }
    local chip_without_delay = chip.new(object_without_delay)
    lu.assertIsNil(chip_without_delay.delay)

    local object_no_delay_field = {
        name = 'Test_Chip_No_Field',
        class_name = 'Chip',
    }
    local chip_no_field = chip.new(object_no_delay_field)
    lu.assertIsNil(chip_no_field.delay)
end

function TestChip:test_open_channel_with_delay()
    local object = {
        name = 'Test_Chip_Channel',
        class_name = 'Chip',
        Delay = 50,
    }
    local chip_instance = chip.new(object)
    lu.assertEquals(chip_instance.delay, 50)
    chip_instance.opened_channel_id = -1
    chip_instance.mux = {
        open_channel = function(self, channel_id)
            return true
        end,
        close_channel = function(self, channel_id)
            return true
        end,
    }

    chip_instance:open_channel(1)
    lu.assertEquals(chip_instance.opened_channel_id, 1)
end

function TestChip:test_open_channel_without_delay()
    local object = {
        name = 'Test_Chip_No_Delay',
        class_name = 'Chip',
        Delay = 0,
    }
    local chip_instance = chip.new(object)
    chip_instance.opened_channel_id = -1
    chip_instance.mux = {
        open_channel = function(self, channel_id)
            return true
        end,
        close_channel = function(self, channel_id)
            return true
        end,
    }

    local start_time = os.time()
    chip_instance:open_channel(1)
    local end_time = os.time()
    local elapsed = end_time - start_time
    lu.assertEquals(chip_instance.opened_channel_id, 1)
    lu.assertTrue(elapsed < 1)
end