# Test the chassisd run
    chassis = MockSmartSwitchChassis()

    # DPU0 details
    index = 0
    name = "DPU0"
    desc = "DPU Module 0"
    slot = 0
    sup_slot = 0
    serial = "DPU0-0000"
    module_type = ModuleBase.MODULE_TYPE_DPU
    module = MockModule(index, name, desc, module_type, slot, serial)
    module.set_midplane_ip()

    # Set initial state for DPU0
    status = ModuleBase.MODULE_STATUS_PRESENT
    module.set_oper_status(status)
    chassis.module_list.append(module)

    # Supervisor ModuleUpdater
    module_updater = SmartSwitchModuleUpdater(SYSLOG_IDENTIFIER, chassis)
    module_updater.module_db_update()
    module_updater.modules_num_update()

    # ChassisdDaemon setup
    daemon_chassisd = ChassisdDaemon(SYSLOG_IDENTIFIER, chassis)
    daemon_chassisd.module_updater = module_updater
    daemon_chassisd.stop = MagicMock()
    daemon_chassisd.stop.wait.return_value = True
    daemon_chassisd.smartswitch = True

    # Import platform and use chassis as platform_chassis
    import sonic_platform.platform
    platform_chassis = chassis

    # Mock objects
    mock_chassis = MagicMock()
    mock_module_updater = MagicMock()

    # Mock the module (DPU0)
    mock_module = MagicMock()
    mock_module.get_name.return_value = "DPU0"

    # Mock chassis.get_module to return the mock_module for DPU0
    def mock_get_module(index):
        if index == 0:  # For DPU0
            return mock_module
        return None  # No other modules available in this test case

    # Apply the side effect for chassis.get_module
    mock_chassis.get_module.side_effect = mock_get_module

    # Mock state_db
    mock_state_db = MagicMock()
    # fvs_mock = [True, {CHASSIS_MIDPLANE_INFO_ACCESS_FIELD: 'True'}]
    # mock_state_db.get.return_value = fvs_mock

    # Mock db_connect
    mock_db_connect = MagicMock()
    mock_db_connect.return_value = mock_state_db

    # Mock admin_status
    # mock_module_updater.get_module_admin_status.return_value = 'up'

    # Set access of DPU0 up
    midplane_table = module_updater.midplane_table
    module.set_midplane_reachable(False)
    module_updater.check_midplane_reachability()
    fvs = midplane_table.get(name)
    assert fvs != None
    if isinstance(fvs, list):
        fvs = dict(fvs[-1])
    assert module.get_midplane_ip() == fvs[CHASSIS_MIDPLANE_INFO_IP_FIELD]
    assert str(module.is_midplane_reachable()) == fvs[CHASSIS_MIDPLANE_INFO_ACCESS_FIELD]

    # Patching platform's Chassis object to return the mocked module
    with patch.object(sonic_platform.platform.Chassis, 'is_smartswitch') as mock_is_smartswitch, \
         patch.object(sonic_platform.platform.Chassis, 'get_module', side_effect=mock_get_module):

        # Simulate that the system is a SmartSwitch
        mock_is_smartswitch.return_value = True

        # Patch num_modules for the updater
        with patch.object(daemon_chassisd.module_updater, 'num_modules', 1), \
             patch.object(daemon_chassisd.module_updater, 'get_module_admin_status', return_value='up'):
            # Now run the function that sets the initial admin state
            daemon_chassisd.set_initial_dpu_admin_state()