Below is the sample function that I want to test using Ceedling:

fsp_err_t half_bridge_reset(const half_bridge_cfg_t* cfg, half_bridge_ctrl_t* ctrl, const ioport_instance_t* io)
{

    /* Reset direction output */
    io->p_api->pinWrite(io->p_ctrl, cfg->dir_pin, (bsp_io_level_t) HALF_BRIDGE_CONVERT_UP);

    /* Clear duty cycle and return */
    return cfg->pwm_tmr->p_api->dutyCycleSet(cfg->pwm_tmr->p_ctrl, 0, cfg->pwm_pin);
}

/** Read level of a pin.
 *
 * @param[in]  p_ctrl               Pointer to control structure.
 * @param[in]  pin                  Pin to be read.
 * @param[in]  p_pin_value          Pointer to return the pin level.
 */
fsp_err_t (* pinRead)(ioport_ctrl_t * const p_ctrl, bsp_io_port_pin_t pin, bsp_io_level_t * p_pin_value);

/** Write specified level to a pin.
 *
 * @param[in]  p_ctrl               Pointer to control structure.
 * @param[in]  pin                  Pin to be written to.
 * @param[in]  level                State to be written to the pin.
 */
fsp_err_t (* pinWrite)(ioport_ctrl_t * const p_ctrl, bsp_io_port_pin_t pin, bsp_io_level_t level);

/** Set the direction of one or more pins on a port.
 *
 * @param[in]  p_ctrl               Pointer to control structure.
 * @param[in]  port                 Port being configured.
 * @param[in]  direction_values     Value controlling direction of pins on port.
 * @param[in]  mask                 Mask controlling which pins on the port are to be configured.
 */
fsp_err_t (* portDirectionSet)(ioport_ctrl_t * const p_ctrl, bsp_io_port_t port, ioport_size_t direction_values,
                                   ioport_size_t mask);

/** Read captured event data for a port.
 *
 * @param[in]  p_ctrl               Pointer to control structure.
 * @param[in]  port                 Port to be read.
 * @param[in]  p_event_data         Pointer to return the event data.
 */
fsp_err_t (* portEventInputRead)(ioport_ctrl_t * const p_ctrl, bsp_io_port_t port, ioport_size_t * p_event_data);

/** Write event output data for a port.
 *
 * @param[in]  p_ctrl               Pointer to control structure.
 * @param[in]  port                 Port event data will be written to.
 * @param[in]  event_data           Data to be written as event data to specified port.
 * @param[in]  mask_value           Each bit set to 1 in the mask corresponds to that bit's value in event data.
 * being written to port.
     */
fsp_err_t (* portEventOutputWrite)(ioport_ctrl_t * const p_ctrl, bsp_io_port_t port, ioport_size_t event_data,
                                       ioport_size_t mask_value);

/** Read states of pins on the specified port.
 *
 * @param[in]  p_ctrl               Pointer to control structure.
 * @param[in]  port                 Port to be read.
 * @param[in]  p_port_value         Pointer to return the port value.
 */
fsp_err_t (* portRead)(ioport_ctrl_t * const p_ctrl, bsp_io_port_t port, ioport_size_t * p_port_value);

/** Write to multiple pins on a port.
 *
 * @param[in]  p_ctrl               Pointer to control structure.
 * @param[in]  port                 Port to be written to.
 * @param[in]  value                Value to be written to the port.
 * @param[in]  mask                 Mask controlling which pins on the port are written to.
 */
fsp_err_t (* portWrite)(ioport_ctrl_t * const p_ctrl, bsp_io_port_t port, ioport_size_t value, ioport_size_t mask);
}ioport_api_t;

The function is accessing elements of the structure that are function pointers. How can we test such functions with Ceedling if we want to mock them?