From 57b115720f21dc1727d803575cfec22952aeea6b Mon Sep 17 00:00:00 2001 From: Amr Mohamed Date: Wed, 20 Nov 2024 12:34:08 +0000 Subject: [PATCH] ppu_v1: Include AE feature in the ppu_v1 - In AE processors before each write operation to the ppu registers, a key should be written to the cluster AE register. - Add a new unit test for the ppu_v1.c to test the newly implemented function. Signed-off-by: Amr Mohamed --- doc/cmake_readme.md | 3 + framework/CMakeLists.txt | 4 + module/ppu_v1/include/mod_ppu_v1.h | 5 + module/ppu_v1/src/mod_ppu_v1.c | 94 +-- module/ppu_v1/src/ppu_v1.c | 338 ++++++--- module/ppu_v1/src/ppu_v1.h | 220 +++--- module/ppu_v1/test/CMakeLists.txt | 42 ++ .../ppu_v1/test/mocks/Mockmod_ppu_v1_extra.c | 666 +++++++++--------- .../ppu_v1/test/mocks/Mockmod_ppu_v1_extra.h | 370 +++++----- module/ppu_v1/test/mocks/Mockppu_v1.c | 666 +++++++++--------- module/ppu_v1/test/mocks/Mockppu_v1.h | 370 +++++----- module/ppu_v1/test/mod_ppu_v1_extra.h | 77 +- module/ppu_v1/test/mod_ppu_v1_unit_test.c | 10 +- module/ppu_v1/test/ppu_v1_unit_test.c | 66 ++ 14 files changed, 1621 insertions(+), 1310 deletions(-) create mode 100644 module/ppu_v1/test/ppu_v1_unit_test.c diff --git a/doc/cmake_readme.md b/doc/cmake_readme.md index f498c1a31..6b745cb79 100644 --- a/doc/cmake_readme.md +++ b/doc/cmake_readme.md @@ -146,6 +146,9 @@ e.g. For ARM Juno platform. See below - `SCP_ENABLE_STATISTICS`: Enable/disable Juno statistics. +- `SCP_ENABLE_AE_EXTENSION`: Enable/disable AE extension. This + should be enabled, if the processor has an AE extension. + ## Modifying build options There are a number of ways to configure a specific option. diff --git a/framework/CMakeLists.txt b/framework/CMakeLists.txt index 98b1ce815..8353ccaff 100644 --- a/framework/CMakeLists.txt +++ b/framework/CMakeLists.txt @@ -143,6 +143,10 @@ if(SCP_ENABLE_AGENT_LOGICAL_DOMAIN) target_compile_definitions(framework PUBLIC "BUILD_HAS_AGENT_LOGICAL_DOMAIN") endif() +if(SCP_ENABLE_AE_EXTENSION) + target_compile_definitions(framework PUBLIC "BUILD_HAS_AE_EXTENSION") +endif() + # # Handle the framework logging filter level. # diff --git a/module/ppu_v1/include/mod_ppu_v1.h b/module/ppu_v1/include/mod_ppu_v1.h index cbbfc49a5..d2d6723e3 100644 --- a/module/ppu_v1/include/mod_ppu_v1.h +++ b/module/ppu_v1/include/mod_ppu_v1.h @@ -134,6 +134,11 @@ struct mod_ppu_v1_pd_config { /*! PPU descriptor */ struct mod_ppu_v1 ppu; +#ifdef BUILD_HAS_AE_EXTENSION + /*! Base address of the Cluster AE registers */ + uintptr_t cluster_ae_reg_base; +#endif + /*! * In the case of a core power domain, identifier of the cluster power * domain it belongs to. If the power domain is not a core power domain, diff --git a/module/ppu_v1/src/mod_ppu_v1.c b/module/ppu_v1/src/mod_ppu_v1.c index 58e4907ea..0b7e2f580 100644 --- a/module/ppu_v1/src/mod_ppu_v1.c +++ b/module/ppu_v1/src/mod_ppu_v1.c @@ -37,8 +37,8 @@ struct ppu_v1_pd_ctx { /* Power domain configuration data */ const struct mod_ppu_v1_pd_config *config; - /* PPU registers */ - struct ppu_v1_reg *ppu; + /* PPU register sets */ + struct ppu_v1_regs ppu; /* Identifier of the entity bound to the power domain driver API */ fwk_id_t bound_id; @@ -117,11 +117,11 @@ static const uint8_t ppu_mode_to_power_state[] = { static void deeper_locking_alarm_callback(uintptr_t param) { struct ppu_v1_pd_ctx *pd_ctx; - struct ppu_v1_reg *ppu; + struct ppu_v1_regs *ppu; unsigned int pd_id = (unsigned int)param; pd_ctx = ppu_v1_ctx.pd_ctx_table + pd_id; - ppu = pd_ctx->ppu; + ppu = &pd_ctx->ppu; /* Disable the lock at off and unlock */ ppu_v1_lock_off_disable(ppu); @@ -149,7 +149,7 @@ static int start_deeper_locking_alarm(fwk_id_t core_pd_id) } #endif -static int get_state(struct ppu_v1_reg *ppu, unsigned int *state) +static int get_state(struct ppu_v1_regs *ppu, unsigned int *state) { enum ppu_v1_mode mode; @@ -185,11 +185,11 @@ static int ppu_v1_pd_set_state(fwk_id_t pd_id, unsigned int state) switch (state) { case MOD_PD_STATE_ON: status = ppu_v1_set_power_mode( - pd_ctx->ppu, PPU_V1_MODE_ON, pd_ctx->timer_ctx); + &pd_ctx->ppu, PPU_V1_MODE_ON, pd_ctx->timer_ctx); if (status == FWK_SUCCESS) { pd_mod_state = state; } else { - get_state(pd_ctx->ppu, &pd_mod_state); + get_state(&pd_ctx->ppu, &pd_mod_state); } status = pd_ctx->pd_driver_input_api->report_power_state_transition( @@ -199,11 +199,11 @@ static int ppu_v1_pd_set_state(fwk_id_t pd_id, unsigned int state) case MOD_PD_STATE_OFF: status = ppu_v1_set_power_mode( - pd_ctx->ppu, PPU_V1_MODE_OFF, pd_ctx->timer_ctx); + &pd_ctx->ppu, PPU_V1_MODE_OFF, pd_ctx->timer_ctx); if (status == FWK_SUCCESS) { pd_mod_state = state; } else { - get_state(pd_ctx->ppu, &pd_mod_state); + get_state(&pd_ctx->ppu, &pd_mod_state); } status = pd_ctx->pd_driver_input_api->report_power_state_transition( @@ -226,7 +226,7 @@ static int ppu_v1_pd_get_state(fwk_id_t pd_id, unsigned int *state) pd_ctx = ppu_v1_ctx.pd_ctx_table + fwk_id_get_element_idx(pd_id); - return get_state(pd_ctx->ppu, state); + return get_state(&pd_ctx->ppu, state); } static int ppu_v1_pd_reset(fwk_id_t pd_id) @@ -238,10 +238,10 @@ static int ppu_v1_pd_reset(fwk_id_t pd_id) /* Model does not support warm reset at the moment. Using OFF instead. */ status = - ppu_v1_set_power_mode(pd_ctx->ppu, PPU_V1_MODE_OFF, pd_ctx->timer_ctx); + ppu_v1_set_power_mode(&pd_ctx->ppu, PPU_V1_MODE_OFF, pd_ctx->timer_ctx); if (status == FWK_SUCCESS) { status = ppu_v1_set_power_mode( - pd_ctx->ppu, PPU_V1_MODE_ON, pd_ctx->timer_ctx); + &pd_ctx->ppu, PPU_V1_MODE_ON, pd_ctx->timer_ctx); } return status; @@ -266,7 +266,7 @@ static const struct mod_pd_driver_api pd_driver = { static int ppu_v1_core_pd_init(struct ppu_v1_pd_ctx *pd_ctx) { int status; - struct ppu_v1_reg *ppu = pd_ctx->ppu; + struct ppu_v1_regs *ppu = &pd_ctx->ppu; unsigned int state; ppu_v1_init(ppu); @@ -289,10 +289,10 @@ static int ppu_v1_core_pd_set_state(fwk_id_t core_pd_id, unsigned int state) { int status; struct ppu_v1_pd_ctx *pd_ctx; - struct ppu_v1_reg *ppu; + struct ppu_v1_regs *ppu; pd_ctx = ppu_v1_ctx.pd_ctx_table + fwk_id_get_element_idx(core_pd_id); - ppu = pd_ctx->ppu; + ppu = &pd_ctx->ppu; switch (state) { case MOD_PD_STATE_OFF: @@ -364,10 +364,10 @@ static int ppu_v1_core_pd_reset(fwk_id_t core_pd_id) static int ppu_v1_core_pd_prepare_for_system_suspend(fwk_id_t core_pd_id) { struct ppu_v1_pd_ctx *pd_ctx; - struct ppu_v1_reg *ppu; + struct ppu_v1_regs *ppu; pd_ctx = ppu_v1_ctx.pd_ctx_table + fwk_id_get_element_idx(core_pd_id); - ppu = pd_ctx->ppu; + ppu = &pd_ctx->ppu; ppu_v1_set_input_edge_sensitivity(ppu, PPU_V1_MODE_ON, @@ -381,9 +381,9 @@ static int ppu_v1_core_pd_prepare_for_system_suspend(fwk_id_t core_pd_id) static void core_pd_ppu_interrupt_handler(struct ppu_v1_pd_ctx *pd_ctx) { int status; - struct ppu_v1_reg *ppu; + struct ppu_v1_regs *ppu; - ppu = pd_ctx->ppu; + ppu = &pd_ctx->ppu; /* ON request interrupt */ if (ppu_v1_is_power_active_edge_interrupt(ppu, PPU_V1_MODE_ON)) { @@ -456,7 +456,7 @@ static const struct mod_pd_driver_api core_pd_driver = { static void unlock_all_cores(struct ppu_v1_pd_ctx *pd_ctx) { struct ppu_v1_cluster_pd_ctx *cluster_pd_ctx; - struct ppu_v1_reg *cpu_ppu; + struct ppu_v1_regs *core_ppu; unsigned int core_idx; fwk_assert(pd_ctx != NULL); @@ -464,16 +464,16 @@ static void unlock_all_cores(struct ppu_v1_pd_ctx *pd_ctx) cluster_pd_ctx = pd_ctx->data; for (core_idx = 0; core_idx < cluster_pd_ctx->core_count; ++core_idx) { - cpu_ppu = cluster_pd_ctx->core_pd_ctx_table[core_idx]->ppu; - ppu_v1_lock_off_disable(cpu_ppu); - ppu_v1_off_unlock(cpu_ppu); + core_ppu = &cluster_pd_ctx->core_pd_ctx_table[core_idx]->ppu; + ppu_v1_lock_off_disable(core_ppu); + ppu_v1_off_unlock(core_ppu); } } static bool lock_all_dynamic_cores(struct ppu_v1_pd_ctx *pd_ctx) { struct ppu_v1_cluster_pd_ctx *cluster_pd_ctx; - struct ppu_v1_reg *cpu_ppu; + struct ppu_v1_regs *core_ppu; unsigned int core_idx; fwk_assert(pd_ctx != NULL); @@ -481,19 +481,19 @@ static bool lock_all_dynamic_cores(struct ppu_v1_pd_ctx *pd_ctx) cluster_pd_ctx = pd_ctx->data; for (core_idx = 0; core_idx < cluster_pd_ctx->core_count; ++core_idx) { - cpu_ppu = cluster_pd_ctx->core_pd_ctx_table[core_idx]->ppu; + core_ppu = &cluster_pd_ctx->core_pd_ctx_table[core_idx]->ppu; - if (!ppu_v1_is_dynamic_enabled(cpu_ppu)) { + if (!ppu_v1_is_dynamic_enabled(core_ppu)) { continue; } - ppu_v1_lock_off_enable(cpu_ppu); - while ((!ppu_v1_is_locked(cpu_ppu)) && - (!ppu_v1_is_power_devactive_high(cpu_ppu, PPU_V1_MODE_ON))) { + ppu_v1_lock_off_enable(core_ppu); + while ((!ppu_v1_is_locked(core_ppu)) && + (!ppu_v1_is_power_devactive_high(core_ppu, PPU_V1_MODE_ON))) { continue; } - if (ppu_v1_is_power_devactive_high(cpu_ppu, PPU_V1_MODE_ON)) { + if (ppu_v1_is_power_devactive_high(core_ppu, PPU_V1_MODE_ON)) { return false; } } @@ -503,12 +503,12 @@ static bool lock_all_dynamic_cores(struct ppu_v1_pd_ctx *pd_ctx) static bool cluster_off(struct ppu_v1_pd_ctx *pd_ctx) { - struct ppu_v1_reg *ppu; + struct ppu_v1_regs *ppu; bool lock_successful; fwk_assert(pd_ctx != NULL); - ppu = pd_ctx->ppu; + ppu = &pd_ctx->ppu; ppu_v1_set_input_edge_sensitivity(ppu, PPU_V1_MODE_ON, @@ -527,11 +527,11 @@ static bool cluster_off(struct ppu_v1_pd_ctx *pd_ctx) static void cluster_on(struct ppu_v1_pd_ctx *pd_ctx) { int status; - struct ppu_v1_reg *ppu; + struct ppu_v1_regs *ppu; fwk_assert(pd_ctx != NULL); - ppu = pd_ctx->ppu; + ppu = &pd_ctx->ppu; ppu_v1_set_input_edge_sensitivity(ppu, PPU_V1_MODE_ON, @@ -561,7 +561,7 @@ static void cluster_on(struct ppu_v1_pd_ctx *pd_ctx) static int ppu_v1_cluster_pd_init(struct ppu_v1_pd_ctx *pd_ctx) { int status; - struct ppu_v1_reg *ppu = pd_ctx->ppu; + struct ppu_v1_regs *ppu = &pd_ctx->ppu; unsigned int state; ppu_v1_init(ppu); @@ -628,8 +628,8 @@ static void cluster_pd_ppu_dyn_policy_min_int_handler( { int status; - ppu_v1_ack_interrupt(pd_ctx->ppu, PPU_V1_ISR_DYN_POLICY_MIN_IRQ); - ppu_v1_interrupt_mask(pd_ctx->ppu, PPU_V1_IMR_DYN_POLICY_MIN_IRQ_MASK); + ppu_v1_ack_interrupt(&pd_ctx->ppu, PPU_V1_ISR_DYN_POLICY_MIN_IRQ); + ppu_v1_interrupt_mask(&pd_ctx->ppu, PPU_V1_IMR_DYN_POLICY_MIN_IRQ_MASK); status = pd_ctx->pd_driver_input_api->report_power_state_transition( pd_ctx->bound_id, MOD_PD_STATE_SLEEP); @@ -642,9 +642,9 @@ static void cluster_pd_ppu_normal_mode_int_handler(struct ppu_v1_pd_ctx *pd_ctx) { int status; enum ppu_v1_mode current_mode; - struct ppu_v1_reg *ppu; + struct ppu_v1_regs *ppu; - ppu = pd_ctx->ppu; + ppu = &pd_ctx->ppu; if (!ppu_v1_is_power_active_edge_interrupt(ppu, PPU_V1_MODE_ON)) { return; /* Spurious interrupt */ @@ -701,7 +701,7 @@ static void cluster_pd_ppu_interrupt_handler(struct ppu_v1_pd_ctx *pd_ctx) fwk_assert(pd_ctx != NULL); /* Minimum policy reached interrupt */ - if (ppu_v1_is_dyn_policy_min_interrupt(pd_ctx->ppu)) { + if (ppu_v1_is_dyn_policy_min_interrupt(&pd_ctx->ppu)) { return cluster_pd_ppu_dyn_policy_min_int_handler(pd_ctx); } @@ -757,7 +757,7 @@ static int ppu_power_mode_on(fwk_id_t pd_id) pd_ctx = ppu_v1_ctx.pd_ctx_table + fwk_id_get_element_idx(pd_id); return ppu_v1_set_power_mode( - pd_ctx->ppu, PPU_V1_MODE_ON, pd_ctx->timer_ctx); + &pd_ctx->ppu, PPU_V1_MODE_ON, pd_ctx->timer_ctx); } static const struct ppu_v1_boot_api boot_api = { @@ -806,7 +806,11 @@ static int ppu_v1_pd_init(fwk_id_t pd_id, unsigned int unused, const void *data) pd_ctx = ppu_v1_ctx.pd_ctx_table + fwk_id_get_element_idx(pd_id); pd_ctx->config = config; - pd_ctx->ppu = (struct ppu_v1_reg *)(config->ppu.reg_base); + pd_ctx->ppu.ppu_reg = (struct ppu_v1_ppu_reg *)(config->ppu.reg_base); +#ifdef BUILD_HAS_AE_EXTENSION + pd_ctx->ppu.cluster_ae_reg = + (struct ppu_v1_cluster_ae_reg *)(config->cluster_ae_reg_base); +#endif pd_ctx->bound_id = FWK_ID_NONE; if (config->ppu.irq != FWK_INTERRUPT_NONE) { @@ -861,8 +865,8 @@ static int ppu_v1_pd_init(fwk_id_t pd_id, unsigned int unused, const void *data) case MOD_PD_TYPE_DEVICE_DEBUG: /* Fall through */ case MOD_PD_TYPE_SYSTEM: - ppu_v1_init(pd_ctx->ppu); - return ppu_v1_set_power_mode(pd_ctx->ppu, PPU_V1_MODE_ON, NULL); + ppu_v1_init(&pd_ctx->ppu); + return ppu_v1_set_power_mode(&pd_ctx->ppu, PPU_V1_MODE_ON, NULL); default: fwk_unexpected(); @@ -1174,7 +1178,7 @@ static int ppu_v1_process_notification( return ppu_v1_cluster_pd_init(pd_ctx); default: - ppu_v1_init(pd_ctx->ppu); + ppu_v1_init(&pd_ctx->ppu); return FWK_SUCCESS; } } diff --git a/module/ppu_v1/src/ppu_v1.c b/module/ppu_v1/src/ppu_v1.c index b89b50600..4c16854e2 100644 --- a/module/ppu_v1/src/ppu_v1.c +++ b/module/ppu_v1/src/ppu_v1.c @@ -1,6 +1,6 @@ /* * Arm SCP/MCP Software - * Copyright (c) 2015-2021, Arm Limited and Contributors. All rights reserved. + * Copyright (c) 2015-2024, Arm Limited and Contributors. All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause */ @@ -12,9 +12,12 @@ #include +#define PPU_V1_WRITE_PPU_REG(ppu, reg, value) \ + (ppu_v1_write_ppu_reg(ppu, &ppu->ppu_reg->reg, value)) + struct set_power_status_check_params_v1 { enum ppu_v1_mode mode; - struct ppu_v1_reg *reg; + struct ppu_v1_regs *reg; }; static bool ppu_v1_set_power_status_check(void *data) @@ -25,53 +28,75 @@ static bool ppu_v1_set_power_status_check(void *data) params = (struct set_power_status_check_params_v1 *)data; return ( - (params->reg->PWSR & + (params->reg->ppu_reg->PWSR & (PPU_V1_PWSR_PWR_STATUS | PPU_V1_PWSR_PWR_DYN_STATUS)) == params->mode); } -void ppu_v1_init(struct ppu_v1_reg *ppu) +static inline void ppu_v1_write_ppu_reg( + struct ppu_v1_regs *ppu, + FWK_W uint32_t *ppu_reg, + uint32_t value) +{ +#ifdef BUILD_HAS_AE_EXTENSION + if (ppu->cluster_ae_reg != NULL) { + ppu->cluster_ae_reg->CLUSTERWRITEKEY = CLUSTER_AE_KEY_VALUE; + } +#endif + *ppu_reg = value; +} + +void ppu_v1_init(struct ppu_v1_regs *ppu) { fwk_assert(ppu != NULL); + fwk_assert(ppu->ppu_reg != NULL); /* Set edge sensitivity to masked for all input edges */ - ppu->IESR = 0; + PPU_V1_WRITE_PPU_REG(ppu, IESR, 0); /* Mask all interrupts */ - ppu->IMR = PPU_V1_IMR_MASK; + PPU_V1_WRITE_PPU_REG(ppu, IMR, PPU_V1_IMR_MASK); /* Acknowledge any interrupt left pending */ - ppu->ISR = PPU_V1_ISR_MASK; + PPU_V1_WRITE_PPU_REG(ppu, ISR, PPU_V1_ISR_MASK); } /* * PWPR and PWSR registers */ -int ppu_v1_request_power_mode(struct ppu_v1_reg *ppu, enum ppu_v1_mode ppu_mode) +int ppu_v1_request_power_mode( + struct ppu_v1_regs *ppu, + enum ppu_v1_mode ppu_mode) { uint32_t power_policy; fwk_assert(ppu != NULL); + fwk_assert(ppu->ppu_reg != NULL); fwk_assert(ppu_mode < PPU_V1_MODE_COUNT); - power_policy = ppu->PWPR & ~(PPU_V1_PWPR_POLICY | PPU_V1_PWPR_DYNAMIC_EN); - ppu->PWPR = power_policy | ppu_mode; + power_policy = + ppu->ppu_reg->PWPR & ~(PPU_V1_PWPR_POLICY | PPU_V1_PWPR_DYNAMIC_EN); + PPU_V1_WRITE_PPU_REG(ppu, PWPR, power_policy | ppu_mode); return FWK_SUCCESS; } int ppu_v1_set_power_mode( - struct ppu_v1_reg *ppu, + struct ppu_v1_regs *ppu, enum ppu_v1_mode ppu_mode, struct ppu_v1_timer_ctx *timer_ctx) { int status; struct set_power_status_check_params_v1 params; + + fwk_assert(ppu != NULL); + fwk_assert(ppu->ppu_reg != NULL); + status = ppu_v1_request_power_mode(ppu, ppu_mode); if (status != FWK_SUCCESS) return status; if (timer_ctx == NULL) { - while ((ppu->PWSR & + while ((ppu->ppu_reg->PWSR & (PPU_V1_PWSR_PWR_STATUS | PPU_V1_PWSR_PWR_DYN_STATUS)) != ppu_mode) continue; @@ -88,307 +113,410 @@ int ppu_v1_set_power_mode( return FWK_SUCCESS; } -int ppu_v1_request_operating_mode(struct ppu_v1_reg *ppu, - enum ppu_v1_opmode op_mode) +int ppu_v1_request_operating_mode( + struct ppu_v1_regs *ppu, + enum ppu_v1_opmode op_mode) { uint32_t power_policy; fwk_assert(ppu != NULL); + fwk_assert(ppu->ppu_reg != NULL); fwk_assert(op_mode < PPU_V1_OPMODE_COUNT); - power_policy = ppu->PWPR & ~(PPU_V1_PWPR_OP_POLICY | PPU_V1_PWPR_OP_DYN_EN); - ppu->PWPR = power_policy | (op_mode << PPU_V1_PWPR_OP_POLICY_POS); + power_policy = + ppu->ppu_reg->PWPR & ~(PPU_V1_PWPR_OP_POLICY | PPU_V1_PWPR_OP_DYN_EN); + PPU_V1_WRITE_PPU_REG( + ppu, PWPR, power_policy | (op_mode << PPU_V1_PWPR_OP_POLICY_POS)); return FWK_SUCCESS; } -void ppu_v1_opmode_dynamic_enable(struct ppu_v1_reg *ppu, - enum ppu_v1_opmode min_dyn_mode) +void ppu_v1_opmode_dynamic_enable( + struct ppu_v1_regs *ppu, + enum ppu_v1_opmode min_dyn_mode) { uint32_t power_policy; fwk_assert(ppu != NULL); + fwk_assert(ppu->ppu_reg != NULL); fwk_assert(min_dyn_mode < PPU_V1_OPMODE_COUNT); - power_policy = ppu->PWPR & ~PPU_V1_PWPR_OP_POLICY; - ppu->PWPR = power_policy | - PPU_V1_PWPR_OP_DYN_EN | - (min_dyn_mode << PPU_V1_PWPR_OP_POLICY_POS); - while ((ppu->PWSR & PPU_V1_PWSR_OP_DYN_STATUS) == 0) + power_policy = ppu->ppu_reg->PWPR & ~PPU_V1_PWPR_OP_POLICY; + PPU_V1_WRITE_PPU_REG( + ppu, + PWPR, + power_policy | PPU_V1_PWPR_OP_DYN_EN | + (min_dyn_mode << PPU_V1_PWPR_OP_POLICY_POS)); + while ((ppu->ppu_reg->PWSR & PPU_V1_PWSR_OP_DYN_STATUS) == 0) continue; } -void ppu_v1_dynamic_enable(struct ppu_v1_reg *ppu, - enum ppu_v1_mode min_dyn_state) +void ppu_v1_dynamic_enable( + struct ppu_v1_regs *ppu, + enum ppu_v1_mode min_dyn_state) { uint32_t power_policy; fwk_assert(ppu != NULL); + fwk_assert(ppu->ppu_reg != NULL); fwk_assert(min_dyn_state < PPU_V1_MODE_COUNT); - power_policy = ppu->PWPR & ~PPU_V1_PWPR_POLICY; - ppu->PWPR = power_policy | PPU_V1_PWPR_DYNAMIC_EN | min_dyn_state; - while ((ppu->PWSR & PPU_V1_PWSR_PWR_DYN_STATUS) == 0) + power_policy = ppu->ppu_reg->PWPR & ~PPU_V1_PWPR_POLICY; + PPU_V1_WRITE_PPU_REG( + ppu, PWPR, power_policy | PPU_V1_PWPR_DYNAMIC_EN | min_dyn_state); + while ((ppu->ppu_reg->PWSR & PPU_V1_PWSR_PWR_DYN_STATUS) == 0) continue; } -void ppu_v1_lock_off_enable(struct ppu_v1_reg *ppu) +void ppu_v1_lock_off_enable(struct ppu_v1_regs *ppu) { fwk_assert(ppu != NULL); + fwk_assert(ppu->ppu_reg != NULL); - ppu->PWPR |= PPU_V1_PWPR_OFF_LOCK_EN; + PPU_V1_WRITE_PPU_REG( + ppu, PWPR, ppu->ppu_reg->PWPR | PPU_V1_PWPR_OFF_LOCK_EN); } -void ppu_v1_lock_off_disable(struct ppu_v1_reg *ppu) +void ppu_v1_lock_off_disable(struct ppu_v1_regs *ppu) { fwk_assert(ppu != NULL); + fwk_assert(ppu->ppu_reg != NULL); - ppu->PWPR &= ~PPU_V1_PWPR_OFF_LOCK_EN; + PPU_V1_WRITE_PPU_REG( + ppu, PWPR, ppu->ppu_reg->PWPR & ~PPU_V1_PWPR_OFF_LOCK_EN); } -enum ppu_v1_mode ppu_v1_get_power_mode(struct ppu_v1_reg *ppu) +enum ppu_v1_mode ppu_v1_get_power_mode(struct ppu_v1_regs *ppu) { fwk_assert(ppu != NULL); + fwk_assert(ppu->ppu_reg != NULL); - return (enum ppu_v1_mode)(ppu->PWSR & PPU_V1_PWSR_PWR_STATUS); + return (enum ppu_v1_mode)(ppu->ppu_reg->PWSR & PPU_V1_PWSR_PWR_STATUS); } -enum ppu_v1_mode ppu_v1_get_programmed_power_mode(struct ppu_v1_reg *ppu) +enum ppu_v1_mode ppu_v1_get_programmed_power_mode(struct ppu_v1_regs *ppu) { fwk_assert(ppu != NULL); + fwk_assert(ppu->ppu_reg != NULL); - return (enum ppu_v1_mode)(ppu->PWPR & PPU_V1_PWPR_POLICY); + return (enum ppu_v1_mode)(ppu->ppu_reg->PWPR & PPU_V1_PWPR_POLICY); } -enum ppu_v1_opmode ppu_v1_get_operating_mode(struct ppu_v1_reg *ppu) +enum ppu_v1_opmode ppu_v1_get_operating_mode(struct ppu_v1_regs *ppu) { fwk_assert(ppu != NULL); + fwk_assert(ppu->ppu_reg != NULL); - return (enum ppu_v1_opmode) - ((ppu->PWSR & PPU_V1_PWSR_OP_STATUS) >> PPU_V1_PWSR_OP_STATUS_POS); + return (enum ppu_v1_opmode)( + (ppu->ppu_reg->PWSR & PPU_V1_PWSR_OP_STATUS) >> + PPU_V1_PWSR_OP_STATUS_POS); } -enum ppu_v1_opmode ppu_v1_get_programmed_operating_mode(struct ppu_v1_reg *ppu) +enum ppu_v1_opmode ppu_v1_get_programmed_operating_mode(struct ppu_v1_regs *ppu) { fwk_assert(ppu != NULL); + fwk_assert(ppu->ppu_reg != NULL); - return (enum ppu_v1_opmode) - ((ppu->PWPR & PPU_V1_PWPR_OP_POLICY) >> PPU_V1_PWPR_OP_POLICY_POS); + return (enum ppu_v1_opmode)( + (ppu->ppu_reg->PWPR & PPU_V1_PWPR_OP_POLICY) >> + PPU_V1_PWPR_OP_POLICY_POS); } -bool ppu_v1_is_dynamic_enabled(struct ppu_v1_reg *ppu) +bool ppu_v1_is_dynamic_enabled(struct ppu_v1_regs *ppu) { fwk_assert(ppu != NULL); + fwk_assert(ppu->ppu_reg != NULL); - return ((ppu->PWSR & PPU_V1_PWSR_PWR_DYN_STATUS) != 0); + return ((ppu->ppu_reg->PWSR & PPU_V1_PWSR_PWR_DYN_STATUS) != 0); } -bool ppu_v1_is_locked(struct ppu_v1_reg *ppu) +bool ppu_v1_is_locked(struct ppu_v1_regs *ppu) { fwk_assert(ppu != NULL); + fwk_assert(ppu->ppu_reg != NULL); - return ((ppu->PWSR & PPU_V1_PWSR_OFF_LOCK_STATUS) != 0); + return ((ppu->ppu_reg->PWSR & PPU_V1_PWSR_OFF_LOCK_STATUS) != 0); } /* * DISR register */ -bool ppu_v1_is_power_devactive_high(struct ppu_v1_reg *ppu, - enum ppu_v1_mode ppu_mode) +bool ppu_v1_is_power_devactive_high( + struct ppu_v1_regs *ppu, + enum ppu_v1_mode ppu_mode) { fwk_assert(ppu != NULL); + fwk_assert(ppu->ppu_reg != NULL); - return (ppu->DISR & + return (ppu->ppu_reg->DISR & (1 << (ppu_mode + PPU_V1_DISR_PWR_DEVACTIVE_STATUS_POS))) != 0; } -bool ppu_v1_is_op_devactive_high(struct ppu_v1_reg *ppu, - enum ppu_v1_op_devactive op_devactive) +bool ppu_v1_is_op_devactive_high( + struct ppu_v1_regs *ppu, + enum ppu_v1_op_devactive op_devactive) { fwk_assert(ppu != NULL); + fwk_assert(ppu->ppu_reg != NULL); - return (ppu->DISR & + return (ppu->ppu_reg->DISR & (1 << (op_devactive + PPU_V1_DISR_OP_DEVACTIVE_STATUS_POS))) != 0; } /* * UNLK register */ -void ppu_v1_off_unlock(struct ppu_v1_reg *ppu) +void ppu_v1_off_unlock(struct ppu_v1_regs *ppu) { fwk_assert(ppu != NULL); + fwk_assert(ppu->ppu_reg != NULL); - ppu->UNLK = PPU_V1_UNLK_OFF_UNLOCK; + PPU_V1_WRITE_PPU_REG(ppu, UNLK, PPU_V1_UNLK_OFF_UNLOCK); } /* * PWCR register */ -void ppu_v1_disable_devactive(struct ppu_v1_reg *ppu) +void ppu_v1_disable_devactive(struct ppu_v1_regs *ppu) { fwk_assert(ppu != NULL); + fwk_assert(ppu->ppu_reg != NULL); - ppu->PWCR &= ~PPU_V1_PWCR_DEV_ACTIVE_EN; + PPU_V1_WRITE_PPU_REG( + ppu, PWCR, ppu->ppu_reg->PWCR & ~PPU_V1_PWCR_DEV_ACTIVE_EN); } -void ppu_v1_disable_handshake(struct ppu_v1_reg *ppu) +void ppu_v1_disable_handshake(struct ppu_v1_regs *ppu) { fwk_assert(ppu != NULL); + fwk_assert(ppu->ppu_reg != NULL); - ppu->PWCR &= ~PPU_V1_PWCR_DEV_REQ_EN; + PPU_V1_WRITE_PPU_REG( + ppu, PWCR, ppu->ppu_reg->PWCR & ~PPU_V1_PWCR_DEV_REQ_EN); } /* * Interrupt registers: IMR, AIMR, ISR, AISR, IESR, OPSR */ -void ppu_v1_interrupt_mask(struct ppu_v1_reg *ppu, unsigned int mask) +void ppu_v1_interrupt_mask(struct ppu_v1_regs *ppu, unsigned int mask) { fwk_assert(ppu != NULL); + fwk_assert(ppu->ppu_reg != NULL); - ppu->IMR |= mask & PPU_V1_IMR_MASK; + PPU_V1_WRITE_PPU_REG( + ppu, IMR, ppu->ppu_reg->IMR | (mask & PPU_V1_IMR_MASK)); } -void ppu_v1_additional_interrupt_mask(struct ppu_v1_reg *ppu, unsigned int mask) +void ppu_v1_additional_interrupt_mask( + struct ppu_v1_regs *ppu, + unsigned int mask) { fwk_assert(ppu != NULL); + fwk_assert(ppu->ppu_reg != NULL); - ppu->AIMR |= mask & PPU_V1_AIMR_MASK; + PPU_V1_WRITE_PPU_REG( + ppu, AIMR, ppu->ppu_reg->AIMR | (mask & PPU_V1_AIMR_MASK)); } -void ppu_v1_interrupt_unmask(struct ppu_v1_reg *ppu, unsigned int mask) +void ppu_v1_interrupt_unmask(struct ppu_v1_regs *ppu, unsigned int mask) { fwk_assert(ppu != NULL); + fwk_assert(ppu->ppu_reg != NULL); - ppu->IMR &= ~(mask & PPU_V1_IMR_MASK); + PPU_V1_WRITE_PPU_REG( + ppu, IMR, ppu->ppu_reg->IMR & ~(mask & PPU_V1_IMR_MASK)); } -void ppu_v1_additional_interrupt_unmask(struct ppu_v1_reg *ppu, +void ppu_v1_additional_interrupt_unmask( + struct ppu_v1_regs *ppu, unsigned int mask) { fwk_assert(ppu != NULL); + fwk_assert(ppu->ppu_reg != NULL); - ppu->AIMR &= ~(mask & PPU_V1_AIMR_MASK); + PPU_V1_WRITE_PPU_REG( + ppu, AIMR, ppu->ppu_reg->AIMR & ~(mask & PPU_V1_AIMR_MASK)); } -bool ppu_v1_is_additional_interrupt_pending(struct ppu_v1_reg *ppu, +bool ppu_v1_is_additional_interrupt_pending( + struct ppu_v1_regs *ppu, unsigned int mask) { - return (ppu->AISR & (mask & PPU_V1_AISR_MASK)) != 0; + fwk_assert(ppu != NULL); + fwk_assert(ppu->ppu_reg != NULL); + + return (ppu->ppu_reg->AISR & (mask & PPU_V1_AISR_MASK)) != 0; } -void ppu_v1_ack_interrupt(struct ppu_v1_reg *ppu, unsigned int mask) +void ppu_v1_ack_interrupt(struct ppu_v1_regs *ppu, unsigned int mask) { fwk_assert(ppu != NULL); + fwk_assert(ppu->ppu_reg != NULL); - ppu->ISR &= mask & PPU_V1_IMR_MASK; + PPU_V1_WRITE_PPU_REG(ppu, ISR, ppu->ppu_reg->ISR & mask & PPU_V1_IMR_MASK); } -void ppu_v1_ack_additional_interrupt(struct ppu_v1_reg *ppu, unsigned int mask) +void ppu_v1_ack_additional_interrupt(struct ppu_v1_regs *ppu, unsigned int mask) { fwk_assert(ppu != NULL); + fwk_assert(ppu->ppu_reg != NULL); - ppu->AISR &= mask & PPU_V1_AIMR_MASK; + PPU_V1_WRITE_PPU_REG( + ppu, AISR, ppu->ppu_reg->AISR & mask & PPU_V1_AIMR_MASK); } -void ppu_v1_set_input_edge_sensitivity(struct ppu_v1_reg *ppu, - enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity edge_sensitivity) +void ppu_v1_set_input_edge_sensitivity( + struct ppu_v1_regs *ppu, + enum ppu_v1_mode ppu_mode, + enum ppu_v1_edge_sensitivity edge_sensitivity) { fwk_assert(ppu != NULL); + fwk_assert(ppu->ppu_reg != NULL); fwk_assert(ppu_mode < PPU_V1_MODE_COUNT); fwk_assert((edge_sensitivity & ~PPU_V1_EDGE_SENSITIVITY_MASK) == 0); /* Clear current settings */ - ppu->IESR &= ~(PPU_V1_EDGE_SENSITIVITY_MASK << - (ppu_mode * PPU_V1_BITS_PER_EDGE_SENSITIVITY)); + PPU_V1_WRITE_PPU_REG( + ppu, + IESR, + ppu->ppu_reg->IESR & + ~(PPU_V1_EDGE_SENSITIVITY_MASK + << (ppu_mode * PPU_V1_BITS_PER_EDGE_SENSITIVITY))); /* Update settings */ - ppu->IESR |= edge_sensitivity << - (ppu_mode * PPU_V1_BITS_PER_EDGE_SENSITIVITY); + PPU_V1_WRITE_PPU_REG( + ppu, + IESR, + ppu->ppu_reg->IESR | + edge_sensitivity << (ppu_mode * PPU_V1_BITS_PER_EDGE_SENSITIVITY)); } enum ppu_v1_edge_sensitivity ppu_v1_get_input_edge_sensitivity( - struct ppu_v1_reg *ppu, enum ppu_v1_mode ppu_mode) + struct ppu_v1_regs *ppu, + enum ppu_v1_mode ppu_mode) { fwk_assert(ppu != NULL); + fwk_assert(ppu->ppu_reg != NULL); fwk_assert(ppu_mode < PPU_V1_MODE_COUNT); return (enum ppu_v1_edge_sensitivity)( - (ppu->IESR >> (ppu_mode * PPU_V1_BITS_PER_EDGE_SENSITIVITY)) & - PPU_V1_EDGE_SENSITIVITY_MASK); + (ppu->ppu_reg->IESR >> (ppu_mode * PPU_V1_BITS_PER_EDGE_SENSITIVITY)) & + PPU_V1_EDGE_SENSITIVITY_MASK); } -void ppu_v1_ack_power_active_edge_interrupt(struct ppu_v1_reg *ppu, +void ppu_v1_ack_power_active_edge_interrupt( + struct ppu_v1_regs *ppu, enum ppu_v1_mode ppu_mode) { - ppu->ISR = 1 << (ppu_mode + PPU_V1_ISR_ACTIVE_EDGE_POS); + fwk_assert(ppu != NULL); + fwk_assert(ppu->ppu_reg != NULL); + + PPU_V1_WRITE_PPU_REG( + ppu, ISR, 1 << (ppu_mode + PPU_V1_ISR_ACTIVE_EDGE_POS)); } -bool ppu_v1_is_power_active_edge_interrupt(struct ppu_v1_reg *ppu, +bool ppu_v1_is_power_active_edge_interrupt( + struct ppu_v1_regs *ppu, enum ppu_v1_mode ppu_mode) { - return ppu->ISR & (1 << (ppu_mode + PPU_V1_ISR_ACTIVE_EDGE_POS)); + fwk_assert(ppu != NULL); + fwk_assert(ppu->ppu_reg != NULL); + + return ppu->ppu_reg->ISR & (1 << (ppu_mode + PPU_V1_ISR_ACTIVE_EDGE_POS)); } -void ppu_v1_set_op_active_edge_sensitivity(struct ppu_v1_reg *ppu, +void ppu_v1_set_op_active_edge_sensitivity( + struct ppu_v1_regs *ppu, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity edge_sensitivity) { fwk_assert(ppu != NULL); + fwk_assert(ppu->ppu_reg != NULL); fwk_assert(op_devactive < PPU_V1_OP_DEVACTIVE_COUNT); fwk_assert((edge_sensitivity & ~PPU_V1_EDGE_SENSITIVITY_MASK) == 0); /* Clear current settings */ - ppu->OPSR &= ~(PPU_V1_EDGE_SENSITIVITY_MASK << - (op_devactive * PPU_V1_BITS_PER_EDGE_SENSITIVITY)); + PPU_V1_WRITE_PPU_REG( + ppu, + OPSR, + ppu->ppu_reg->OPSR & + ~(PPU_V1_EDGE_SENSITIVITY_MASK + << (op_devactive * PPU_V1_BITS_PER_EDGE_SENSITIVITY))); /* Update settings */ - ppu->OPSR |= edge_sensitivity << - (op_devactive * PPU_V1_BITS_PER_EDGE_SENSITIVITY); + PPU_V1_WRITE_PPU_REG( + ppu, + OPSR, + ppu->ppu_reg->OPSR | + edge_sensitivity + << (op_devactive * PPU_V1_BITS_PER_EDGE_SENSITIVITY)); } enum ppu_v1_edge_sensitivity ppu_v1_get_op_active_edge_sensitivity( - struct ppu_v1_reg *ppu, enum ppu_v1_op_devactive op_devactive) + struct ppu_v1_regs *ppu, + enum ppu_v1_op_devactive op_devactive) { fwk_assert(ppu != NULL); + fwk_assert(ppu->ppu_reg != NULL); fwk_assert(op_devactive < PPU_V1_OP_DEVACTIVE_COUNT); return (enum ppu_v1_edge_sensitivity)( - (ppu->OPSR >> (op_devactive * PPU_V1_BITS_PER_EDGE_SENSITIVITY)) & - PPU_V1_EDGE_SENSITIVITY_MASK); + (ppu->ppu_reg->OPSR >> + (op_devactive * PPU_V1_BITS_PER_EDGE_SENSITIVITY)) & + PPU_V1_EDGE_SENSITIVITY_MASK); } -void ppu_v1_ack_op_active_edge_interrupt(struct ppu_v1_reg *ppu, +void ppu_v1_ack_op_active_edge_interrupt( + struct ppu_v1_regs *ppu, enum ppu_v1_op_devactive op_devactive) { - ppu->ISR = 1 << (op_devactive + PPU_V1_ISR_OP_ACTIVE_EDGE_POS); + fwk_assert(ppu != NULL); + fwk_assert(ppu->ppu_reg != NULL); + + PPU_V1_WRITE_PPU_REG( + ppu, ISR, 1 << (op_devactive + PPU_V1_ISR_OP_ACTIVE_EDGE_POS)); } -bool ppu_v1_is_op_active_edge_interrupt(struct ppu_v1_reg *ppu, +bool ppu_v1_is_op_active_edge_interrupt( + struct ppu_v1_regs *ppu, enum ppu_v1_op_devactive op_devactive) { - return ppu->ISR & (1 << (op_devactive + PPU_V1_ISR_OP_ACTIVE_EDGE_POS)); + fwk_assert(ppu != NULL); + fwk_assert(ppu->ppu_reg != NULL); + + return ppu->ppu_reg->ISR & + (1 << (op_devactive + PPU_V1_ISR_OP_ACTIVE_EDGE_POS)); } -bool ppu_v1_is_dyn_policy_min_interrupt(struct ppu_v1_reg *ppu) +bool ppu_v1_is_dyn_policy_min_interrupt(struct ppu_v1_regs *ppu) { - return ppu->ISR & PPU_V1_ISR_DYN_POLICY_MIN_IRQ; + fwk_assert(ppu != NULL); + fwk_assert(ppu->ppu_reg != NULL); + + return ppu->ppu_reg->ISR & PPU_V1_ISR_DYN_POLICY_MIN_IRQ; } /* * IDR0 register */ -unsigned int ppu_v1_get_num_opmode(struct ppu_v1_reg *ppu) +unsigned int ppu_v1_get_num_opmode(struct ppu_v1_regs *ppu) { - return ((ppu->IDR0 & PPU_V1_IDR0_NUM_OPMODE) - >> PPU_V1_IDR0_NUM_OPMODE_POS) + 1; + fwk_assert(ppu != NULL); + fwk_assert(ppu->ppu_reg != NULL); + + return ((ppu->ppu_reg->IDR0 & PPU_V1_IDR0_NUM_OPMODE) >> + PPU_V1_IDR0_NUM_OPMODE_POS) + + 1; } /* * AIDR register */ -unsigned int ppu_v1_get_arch_id(struct ppu_v1_reg *ppu) +unsigned int ppu_v1_get_arch_id(struct ppu_v1_regs *ppu) { fwk_assert(ppu != NULL); + fwk_assert(ppu->ppu_reg != NULL); - return (ppu->AIDR & (PPU_V1_AIDR_ARCH_REV_MINOR | - PPU_V1_AIDR_ARCH_REV_MAJOR)); + return ( + ppu->ppu_reg->AIDR & + (PPU_V1_AIDR_ARCH_REV_MINOR | PPU_V1_AIDR_ARCH_REV_MAJOR)); } diff --git a/module/ppu_v1/src/ppu_v1.h b/module/ppu_v1/src/ppu_v1.h index 30a92ff40..7d1636142 100644 --- a/module/ppu_v1/src/ppu_v1.h +++ b/module/ppu_v1/src/ppu_v1.h @@ -1,6 +1,6 @@ /* * Arm SCP/MCP Software - * Copyright (c) 2015-2021, Arm Limited and Contributors. All rights reserved. + * Copyright (c) 2015-2024, Arm Limited and Contributors. All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause */ @@ -23,41 +23,41 @@ /* * PPU 1.1 register definitions */ -struct ppu_v1_reg { - FWK_RW uint32_t PWPR; - FWK_RW uint32_t PMER; - FWK_R uint32_t PWSR; - uint32_t RESERVED0; - FWK_R uint32_t DISR; - FWK_R uint32_t MISR; - FWK_R uint32_t STSR; - FWK_RW uint32_t UNLK; - FWK_RW uint32_t PWCR; - FWK_RW uint32_t PTCR; - uint32_t RESERVED1[2]; - FWK_RW uint32_t IMR; - FWK_RW uint32_t AIMR; - FWK_RW uint32_t ISR; - FWK_RW uint32_t AISR; - FWK_RW uint32_t IESR; - FWK_RW uint32_t OPSR; - uint32_t RESERVED2[2]; - FWK_RW uint32_t FUNRR; - FWK_RW uint32_t FULRR; - FWK_RW uint32_t MEMRR; - uint8_t RESERVED3[0x160 - 0x5C]; - FWK_RW uint32_t EDTR0; - FWK_RW uint32_t EDTR1; - uint32_t RESERVED4[2]; - FWK_RW uint32_t DCCR0; - FWK_RW uint32_t DCCR1; - uint8_t RESERVED5[0xFB0 - 0x178]; - FWK_R uint32_t IDR0; - FWK_R uint32_t IDR1; - uint8_t RESERVED6[0xFC8 - 0xFB8]; - FWK_R uint32_t IIDR; - FWK_R uint32_t AIDR; - uint8_t RESERVED7[0x1000 - 0xFD0]; +struct ppu_v1_ppu_reg { + FWK_RW uint32_t PWPR; + FWK_RW uint32_t PMER; + FWK_R uint32_t PWSR; + uint32_t RESERVED0; + FWK_R uint32_t DISR; + FWK_R uint32_t MISR; + FWK_R uint32_t STSR; + FWK_RW uint32_t UNLK; + FWK_RW uint32_t PWCR; + FWK_RW uint32_t PTCR; + uint32_t RESERVED1[2]; + FWK_RW uint32_t IMR; + FWK_RW uint32_t AIMR; + FWK_RW uint32_t ISR; + FWK_RW uint32_t AISR; + FWK_RW uint32_t IESR; + FWK_RW uint32_t OPSR; + uint32_t RESERVED2[2]; + FWK_RW uint32_t FUNRR; + FWK_RW uint32_t FULRR; + FWK_RW uint32_t MEMRR; + uint8_t RESERVED3[0x160 - 0x5C]; + FWK_RW uint32_t EDTR0; + FWK_RW uint32_t EDTR1; + uint32_t RESERVED4[2]; + FWK_RW uint32_t DCCR0; + FWK_RW uint32_t DCCR1; + uint8_t RESERVED5[0xFB0 - 0x178]; + FWK_R uint32_t IDR0; + FWK_R uint32_t IDR1; + uint8_t RESERVED6[0xFC8 - 0xFB8]; + FWK_R uint32_t IIDR; + FWK_R uint32_t AIDR; + uint8_t RESERVED7[0x1000 - 0xFD0]; }; enum ppu_v1_mode { @@ -230,6 +230,41 @@ enum ppu_v1_edge_sensitivity { #define PPU_V1_IDR0_NUM_OPMODE_POS 4 #define PPU_V1_IDR0_NUM_OPMODE UINT32_C(0x000000F0) +/* + * Cluster AE register definitions + */ +struct ppu_v1_cluster_ae_reg { + /* Only available in case of DSU-AE cluster. */ + FWK_R uint64_t CLUSTERSLCFR; + FWK_R uint64_t CLUSTERSLCTLR; + FWK_R uint64_t CLUSTERSLSTAT; + uint64_t RESERVED0; + FWK_R uint64_t CORESLCFR; + uint64_t RESERVED1; + FWK_R uint64_t CORESLCTLR; + uint64_t RESERVED2; + FWK_R uint64_t CORESLSTAT; + uint64_t RESERVED3; + FWK_RW uint64_t CLUSTERRECOV; + uint64_t RESERVED4; + + /* This is 64-bit in case of DSU-AE cluster and 32-bit in case of, + the AE core cluster. Only bits 0-7 will be used. */ + FWK_W uint32_t CLUSTERWRITEKEY; +}; + +/* + * Bit definition for CLUSTERWRITEKEY + */ +#define CLUSTER_AE_KEY_VALUE 0x000000BA + +struct ppu_v1_regs { + struct ppu_v1_ppu_reg *ppu_reg; +#ifdef BUILD_HAS_AE_EXTENSION + struct ppu_v1_cluster_ae_reg *cluster_ae_reg; +#endif +}; + /* * Timer context to be passed to set_power_mode function. */ @@ -243,7 +278,7 @@ struct ppu_v1_timer_ctx { * Initializes the PPU by masking all interrupts and acknowledging any * previously pending interrupt. */ -void ppu_v1_init(struct ppu_v1_reg *ppu); +void ppu_v1_init(struct ppu_v1_regs *ppu); /* * Set PPU's power mode and wait for the transition. @@ -251,171 +286,189 @@ void ppu_v1_init(struct ppu_v1_reg *ppu); * limited error detection. */ int ppu_v1_set_power_mode( - struct ppu_v1_reg *ppu, + struct ppu_v1_regs *ppu, enum ppu_v1_mode ppu_mode, struct ppu_v1_timer_ctx *timer_ctx); /* * Request PPU's power mode and don't wait for the transition. */ -int ppu_v1_request_power_mode(struct ppu_v1_reg *ppu, - enum ppu_v1_mode ppu_mode); +int ppu_v1_request_power_mode( + struct ppu_v1_regs *ppu, + enum ppu_v1_mode ppu_mode); /* * Request a change to the PPU's operating mode. */ -int ppu_v1_request_operating_mode(struct ppu_v1_reg *ppu, - enum ppu_v1_opmode op_mode); +int ppu_v1_request_operating_mode( + struct ppu_v1_regs *ppu, + enum ppu_v1_opmode op_mode); /* * Enable PPU's dynamic operating mode transitions */ -void ppu_v1_opmode_dynamic_enable(struct ppu_v1_reg *ppu, - enum ppu_v1_opmode min_dyn_mode); +void ppu_v1_opmode_dynamic_enable( + struct ppu_v1_regs *ppu, + enum ppu_v1_opmode min_dyn_mode); /* * Enable PPU's dynamic power mode transitions */ -void ppu_v1_dynamic_enable(struct ppu_v1_reg *ppu, - enum ppu_v1_mode min_dyn_state); +void ppu_v1_dynamic_enable( + struct ppu_v1_regs *ppu, + enum ppu_v1_mode min_dyn_state); /* * Enable the lock in the OFF state */ -void ppu_v1_lock_off_enable(struct ppu_v1_reg *ppu); +void ppu_v1_lock_off_enable(struct ppu_v1_regs *ppu); /* * Disable the lock in the OFF state */ -void ppu_v1_lock_off_disable(struct ppu_v1_reg *ppu); +void ppu_v1_lock_off_disable(struct ppu_v1_regs *ppu); /* * Get the current power mode. */ -enum ppu_v1_mode ppu_v1_get_power_mode(struct ppu_v1_reg *ppu); +enum ppu_v1_mode ppu_v1_get_power_mode(struct ppu_v1_regs *ppu); /* * Get the current programmed power policy mode. */ -enum ppu_v1_mode ppu_v1_get_programmed_power_mode(struct ppu_v1_reg *ppu); +enum ppu_v1_mode ppu_v1_get_programmed_power_mode(struct ppu_v1_regs *ppu); /* * Get the current operating mode. */ -enum ppu_v1_opmode ppu_v1_get_operating_mode(struct ppu_v1_reg *ppu); +enum ppu_v1_opmode ppu_v1_get_operating_mode(struct ppu_v1_regs *ppu); /* * Get the current programmed operating mode policy. */ -enum ppu_v1_opmode ppu_v1_get_programmed_operating_mode(struct ppu_v1_reg *ppu); +enum ppu_v1_opmode ppu_v1_get_programmed_operating_mode( + struct ppu_v1_regs *ppu); /* * Check whether the dynamic transitions are enabled or not. */ -bool ppu_v1_is_dynamic_enabled(struct ppu_v1_reg *ppu); +bool ppu_v1_is_dynamic_enabled(struct ppu_v1_regs *ppu); /* * Check whether the locked in the MEM_RET or OFF state. */ -bool ppu_v1_is_locked(struct ppu_v1_reg *ppu); +bool ppu_v1_is_locked(struct ppu_v1_regs *ppu); /* * Check if the DEVACTIVE signal associated to a power mode is high. */ -bool ppu_v1_is_power_devactive_high(struct ppu_v1_reg *ppu, - enum ppu_v1_mode ppu_mode); +bool ppu_v1_is_power_devactive_high( + struct ppu_v1_regs *ppu, + enum ppu_v1_mode ppu_mode); /* * Check if the DEVACTIVE signal associated to an operating mode is high. */ -bool ppu_v1_is_op_devactive_high(struct ppu_v1_reg *ppu, - enum ppu_v1_op_devactive op_devactive); +bool ppu_v1_is_op_devactive_high( + struct ppu_v1_regs *ppu, + enum ppu_v1_op_devactive op_devactive); /* * Unlock the power domain from the OFF power mode. */ -void ppu_v1_off_unlock(struct ppu_v1_reg *ppu); +void ppu_v1_off_unlock(struct ppu_v1_regs *ppu); /* * Disable the check of the DEVACTIVE signals by the PPU logic for state * transition. */ -void ppu_v1_disable_devactive(struct ppu_v1_reg *ppu); +void ppu_v1_disable_devactive(struct ppu_v1_regs *ppu); /* * Disable the handshake with the P-channel or the Q-channels */ -void ppu_v1_disable_handshake(struct ppu_v1_reg *ppu); +void ppu_v1_disable_handshake(struct ppu_v1_regs *ppu); /* * Set one or more bits of the interrupt mask register. */ -void ppu_v1_interrupt_mask(struct ppu_v1_reg *ppu, unsigned int mask); +void ppu_v1_interrupt_mask(struct ppu_v1_regs *ppu, unsigned int mask); /* * Set one or more bits of the additional interrupt mask register. */ -void ppu_v1_additional_interrupt_mask(struct ppu_v1_reg *ppu, +void ppu_v1_additional_interrupt_mask( + struct ppu_v1_regs *ppu, unsigned int mask); /* * Clear one or more bits of the interrupt mask register. */ -void ppu_v1_interrupt_unmask(struct ppu_v1_reg *ppu, unsigned int mask); +void ppu_v1_interrupt_unmask(struct ppu_v1_regs *ppu, unsigned int mask); /* * Clear one or more bits of the additional interrupt mask register. */ -void ppu_v1_additional_interrupt_unmask(struct ppu_v1_reg *ppu, +void ppu_v1_additional_interrupt_unmask( + struct ppu_v1_regs *ppu, unsigned int mask); /* * Check if some additional interrupts are pending. */ -bool ppu_v1_is_additional_interrupt_pending(struct ppu_v1_reg *ppu, +bool ppu_v1_is_additional_interrupt_pending( + struct ppu_v1_regs *ppu, unsigned int mask); /* * Acknowledge one or more interrupts. */ -void ppu_v1_ack_interrupt(struct ppu_v1_reg *ppu, unsigned int mask); +void ppu_v1_ack_interrupt(struct ppu_v1_regs *ppu, unsigned int mask); /* * Acknowledge one or more additional interrupts. */ -void ppu_v1_ack_additional_interrupt(struct ppu_v1_reg *ppu, unsigned int mask); +void ppu_v1_ack_additional_interrupt( + struct ppu_v1_regs *ppu, + unsigned int mask); /* * Set input edge sensitivity. See 'enum ppu_v1_edge_sensitivity' for the * available sensitivities. */ -void ppu_v1_set_input_edge_sensitivity(struct ppu_v1_reg *ppu, - enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity edge_sensitivity); +void ppu_v1_set_input_edge_sensitivity( + struct ppu_v1_regs *ppu, + enum ppu_v1_mode ppu_mode, + enum ppu_v1_edge_sensitivity edge_sensitivity); /* * Get input edge sensitivity. See 'enum ppu_v1_edge_sensitivity' for the * available sensitivities. */ enum ppu_v1_edge_sensitivity ppu_v1_get_input_edge_sensitivity( - struct ppu_v1_reg *ppu, enum ppu_v1_mode ppu_mode); + struct ppu_v1_regs *ppu, + enum ppu_v1_mode ppu_mode); /* * Acknowledge a power active edge interrupt. */ -void ppu_v1_ack_power_active_edge_interrupt(struct ppu_v1_reg *ppu, - enum ppu_v1_mode ppu_mode); +void ppu_v1_ack_power_active_edge_interrupt( + struct ppu_v1_regs *ppu, + enum ppu_v1_mode ppu_mode); /* * Check if a power active edge interrupt is pending. */ -bool ppu_v1_is_power_active_edge_interrupt(struct ppu_v1_reg *ppu, - enum ppu_v1_mode ppu_mode); +bool ppu_v1_is_power_active_edge_interrupt( + struct ppu_v1_regs *ppu, + enum ppu_v1_mode ppu_mode); /* * Set operating mode active edge sensitivity. See * 'enum ppu_v1_edge_sensitivity' for the available sensitivities. */ -void ppu_v1_set_op_active_edge_sensitivity(struct ppu_v1_reg *ppu, +void ppu_v1_set_op_active_edge_sensitivity( + struct ppu_v1_regs *ppu, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity edge_sensitivity); @@ -424,34 +477,37 @@ void ppu_v1_set_op_active_edge_sensitivity(struct ppu_v1_reg *ppu, * See 'enum ppu_v1_edge_sensitivity for the available sensitivities. */ enum ppu_v1_edge_sensitivity ppu_v1_get_op_active_edge_sensitivity( - struct ppu_v1_reg *ppu, enum ppu_v1_op_devactive op_devactive); + struct ppu_v1_regs *ppu, + enum ppu_v1_op_devactive op_devactive); /* * Acknowledge operating mode active edge interrupt. */ -void ppu_v1_ack_op_active_edge_interrupt(struct ppu_v1_reg *ppu, +void ppu_v1_ack_op_active_edge_interrupt( + struct ppu_v1_regs *ppu, enum ppu_v1_op_devactive op_devactive); /* * Check if an operating mode active edge interrupt is pending. */ -bool ppu_v1_is_op_active_edge_interrupt(struct ppu_v1_reg *ppu, +bool ppu_v1_is_op_active_edge_interrupt( + struct ppu_v1_regs *ppu, enum ppu_v1_op_devactive op_devactive); /* * Check if the DYN input edge interrupt is pending. */ -bool ppu_v1_is_dyn_policy_min_interrupt(struct ppu_v1_reg *ppu); +bool ppu_v1_is_dyn_policy_min_interrupt(struct ppu_v1_regs *ppu); /* * Get the number of operating modes. */ -unsigned int ppu_v1_get_num_opmode(struct ppu_v1_reg *ppu); +unsigned int ppu_v1_get_num_opmode(struct ppu_v1_regs *ppu); /* * Get the PPU architecture ID. */ -unsigned int ppu_v1_get_arch_id(struct ppu_v1_reg *ppu); +unsigned int ppu_v1_get_arch_id(struct ppu_v1_regs *ppu); /*! * \endcond diff --git a/module/ppu_v1/test/CMakeLists.txt b/module/ppu_v1/test/CMakeLists.txt index b55ec90fe..67f0b5c9c 100644 --- a/module/ppu_v1/test/CMakeLists.txt +++ b/module/ppu_v1/test/CMakeLists.txt @@ -5,6 +5,48 @@ # SPDX-License-Identifier: BSD-3-Clause # +################################################################################ +# Test ppu_v1.c without BUILD_HAS_AE_EXTENSION # +################################################################################ +set(TEST_SRC ppu_v1) +set(TEST_FILE ppu_v1) + +set(UNIT_TEST_TARGET ${TEST_MODULE}_unit_test) + +set(MODULE_SRC ${MODULE_ROOT}/${TEST_MODULE}/src) +set(MODULE_INC ${MODULE_ROOT}/${TEST_MODULE}/include) +list(APPEND OTHER_MODULE_INC ${MODULE_ROOT}/power_domain/include) +list(APPEND OTHER_MODULE_INC ${MODULE_ROOT}/timer/include) +set(MODULE_UT_SRC ${CMAKE_CURRENT_LIST_DIR}) + +list(APPEND MOCK_REPLACEMENTS fwk_module) + +include(${SCP_ROOT}/unit_test/module_common.cmake) + +################################################################################ +# Test ppu_v1.c with BUILD_HAS_AE_EXTENSION # +################################################################################ +set(TEST_SRC ppu_v1) +set(TEST_FILE ppu_v1) + +set(UNIT_TEST_TARGET ${TEST_MODULE}_unit_test_ae) + +set(MODULE_SRC ${MODULE_ROOT}/${TEST_MODULE}/src) +set(MODULE_INC ${MODULE_ROOT}/${TEST_MODULE}/include) +list(APPEND OTHER_MODULE_INC ${MODULE_ROOT}/power_domain/include) +list(APPEND OTHER_MODULE_INC ${MODULE_ROOT}/timer/include) +set(MODULE_UT_SRC ${CMAKE_CURRENT_LIST_DIR}) + +list(APPEND MOCK_REPLACEMENTS fwk_module) + +include(${SCP_ROOT}/unit_test/module_common.cmake) + +target_compile_definitions(${UNIT_TEST_TARGET} + PUBLIC "BUILD_HAS_AE_EXTENSION") + +################################################################################ +# Test mod_ppu_v1.c # +################################################################################ set(TEST_SRC mod_ppu_v1) set(TEST_FILE mod_ppu_v1) diff --git a/module/ppu_v1/test/mocks/Mockmod_ppu_v1_extra.c b/module/ppu_v1/test/mocks/Mockmod_ppu_v1_extra.c index 1d6072939..e887d1ea3 100644 --- a/module/ppu_v1/test/mocks/Mockmod_ppu_v1_extra.c +++ b/module/ppu_v1/test/mocks/Mockmod_ppu_v1_extra.c @@ -91,10 +91,10 @@ typedef struct _CMOCK_ppu_v1_init_CALL_INSTANCE { UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; @@ -105,13 +105,13 @@ typedef struct _CMOCK_ppu_v1_set_power_mode_CALL_INSTANCE UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; int ReturnVal; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; enum ppu_v1_mode Expected_ppu_mode; struct ppu_v1_timer_ctx* Expected_timer_ctx; int Expected_ppu_Depth; int Expected_timer_ctx_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char ReturnThruPtr_timer_ctx_Used; struct ppu_v1_timer_ctx* ReturnThruPtr_timer_ctx_Val; @@ -127,11 +127,11 @@ typedef struct _CMOCK_ppu_v1_request_power_mode_CALL_INSTANCE UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; int ReturnVal; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; enum ppu_v1_mode Expected_ppu_mode; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; char IgnoreArg_ppu_mode; @@ -143,11 +143,11 @@ typedef struct _CMOCK_ppu_v1_request_operating_mode_CALL_INSTANCE UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; int ReturnVal; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; enum ppu_v1_opmode Expected_op_mode; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; char IgnoreArg_op_mode; @@ -158,11 +158,11 @@ typedef struct _CMOCK_ppu_v1_opmode_dynamic_enable_CALL_INSTANCE { UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; enum ppu_v1_opmode Expected_min_dyn_mode; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; char IgnoreArg_min_dyn_mode; @@ -173,11 +173,11 @@ typedef struct _CMOCK_ppu_v1_dynamic_enable_CALL_INSTANCE { UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; enum ppu_v1_mode Expected_min_dyn_state; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; char IgnoreArg_min_dyn_state; @@ -188,10 +188,10 @@ typedef struct _CMOCK_ppu_v1_lock_off_enable_CALL_INSTANCE { UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; @@ -201,10 +201,10 @@ typedef struct _CMOCK_ppu_v1_lock_off_disable_CALL_INSTANCE { UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; @@ -215,10 +215,10 @@ typedef struct _CMOCK_ppu_v1_get_power_mode_CALL_INSTANCE UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; enum ppu_v1_mode ReturnVal; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; @@ -229,10 +229,10 @@ typedef struct _CMOCK_ppu_v1_get_programmed_power_mode_CALL_INSTANCE UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; enum ppu_v1_mode ReturnVal; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; @@ -243,10 +243,10 @@ typedef struct _CMOCK_ppu_v1_get_operating_mode_CALL_INSTANCE UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; enum ppu_v1_opmode ReturnVal; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; @@ -257,10 +257,10 @@ typedef struct _CMOCK_ppu_v1_get_programmed_operating_mode_CALL_INSTANCE UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; enum ppu_v1_opmode ReturnVal; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; @@ -271,10 +271,10 @@ typedef struct _CMOCK_ppu_v1_is_dynamic_enabled_CALL_INSTANCE UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; bool ReturnVal; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; @@ -285,10 +285,10 @@ typedef struct _CMOCK_ppu_v1_is_locked_CALL_INSTANCE UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; bool ReturnVal; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; @@ -299,11 +299,11 @@ typedef struct _CMOCK_ppu_v1_is_power_devactive_high_CALL_INSTANCE UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; bool ReturnVal; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; enum ppu_v1_mode Expected_ppu_mode; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; char IgnoreArg_ppu_mode; @@ -315,11 +315,11 @@ typedef struct _CMOCK_ppu_v1_is_op_devactive_high_CALL_INSTANCE UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; bool ReturnVal; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; enum ppu_v1_op_devactive Expected_op_devactive; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; char IgnoreArg_op_devactive; @@ -330,10 +330,10 @@ typedef struct _CMOCK_ppu_v1_off_unlock_CALL_INSTANCE { UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; @@ -343,10 +343,10 @@ typedef struct _CMOCK_ppu_v1_disable_devactive_CALL_INSTANCE { UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; @@ -356,10 +356,10 @@ typedef struct _CMOCK_ppu_v1_disable_handshake_CALL_INSTANCE { UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; @@ -369,11 +369,11 @@ typedef struct _CMOCK_ppu_v1_interrupt_mask_CALL_INSTANCE { UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; unsigned int Expected_mask; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; char IgnoreArg_mask; @@ -384,11 +384,11 @@ typedef struct _CMOCK_ppu_v1_additional_interrupt_mask_CALL_INSTANCE { UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; unsigned int Expected_mask; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; char IgnoreArg_mask; @@ -399,11 +399,11 @@ typedef struct _CMOCK_ppu_v1_interrupt_unmask_CALL_INSTANCE { UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; unsigned int Expected_mask; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; char IgnoreArg_mask; @@ -414,11 +414,11 @@ typedef struct _CMOCK_ppu_v1_additional_interrupt_unmask_CALL_INSTANCE { UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; unsigned int Expected_mask; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; char IgnoreArg_mask; @@ -430,11 +430,11 @@ typedef struct _CMOCK_ppu_v1_is_additional_interrupt_pending_CALL_INSTANCE UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; bool ReturnVal; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; unsigned int Expected_mask; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; char IgnoreArg_mask; @@ -445,11 +445,11 @@ typedef struct _CMOCK_ppu_v1_ack_interrupt_CALL_INSTANCE { UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; unsigned int Expected_mask; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; char IgnoreArg_mask; @@ -460,11 +460,11 @@ typedef struct _CMOCK_ppu_v1_ack_additional_interrupt_CALL_INSTANCE { UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; unsigned int Expected_mask; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; char IgnoreArg_mask; @@ -475,12 +475,12 @@ typedef struct _CMOCK_ppu_v1_set_input_edge_sensitivity_CALL_INSTANCE { UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; enum ppu_v1_mode Expected_ppu_mode; enum ppu_v1_edge_sensitivity Expected_edge_sensitivity; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; char IgnoreArg_ppu_mode; @@ -493,11 +493,11 @@ typedef struct _CMOCK_ppu_v1_get_input_edge_sensitivity_CALL_INSTANCE UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; enum ppu_v1_edge_sensitivity ReturnVal; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; enum ppu_v1_mode Expected_ppu_mode; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; char IgnoreArg_ppu_mode; @@ -508,11 +508,11 @@ typedef struct _CMOCK_ppu_v1_ack_power_active_edge_interrupt_CALL_INSTANCE { UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; enum ppu_v1_mode Expected_ppu_mode; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; char IgnoreArg_ppu_mode; @@ -524,11 +524,11 @@ typedef struct _CMOCK_ppu_v1_is_power_active_edge_interrupt_CALL_INSTANCE UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; bool ReturnVal; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; enum ppu_v1_mode Expected_ppu_mode; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; char IgnoreArg_ppu_mode; @@ -539,12 +539,12 @@ typedef struct _CMOCK_ppu_v1_set_op_active_edge_sensitivity_CALL_INSTANCE { UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; enum ppu_v1_op_devactive Expected_op_devactive; enum ppu_v1_edge_sensitivity Expected_edge_sensitivity; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; char IgnoreArg_op_devactive; @@ -557,11 +557,11 @@ typedef struct _CMOCK_ppu_v1_get_op_active_edge_sensitivity_CALL_INSTANCE UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; enum ppu_v1_edge_sensitivity ReturnVal; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; enum ppu_v1_op_devactive Expected_op_devactive; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; char IgnoreArg_op_devactive; @@ -572,11 +572,11 @@ typedef struct _CMOCK_ppu_v1_ack_op_active_edge_interrupt_CALL_INSTANCE { UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; enum ppu_v1_op_devactive Expected_op_devactive; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; char IgnoreArg_op_devactive; @@ -588,11 +588,11 @@ typedef struct _CMOCK_ppu_v1_is_op_active_edge_interrupt_CALL_INSTANCE UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; bool ReturnVal; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; enum ppu_v1_op_devactive Expected_op_devactive; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; char IgnoreArg_op_devactive; @@ -604,10 +604,10 @@ typedef struct _CMOCK_ppu_v1_is_dyn_policy_min_interrupt_CALL_INSTANCE UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; bool ReturnVal; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; @@ -618,10 +618,10 @@ typedef struct _CMOCK_ppu_v1_get_num_opmode_CALL_INSTANCE UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; unsigned int ReturnVal; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; @@ -632,10 +632,10 @@ typedef struct _CMOCK_ppu_v1_get_arch_id_CALL_INSTANCE UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; unsigned int ReturnVal; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; @@ -1682,7 +1682,7 @@ void stop_alarm_api_CMockIgnoreArg_alarm_id(UNITY_LINE_TYPE cmock_line) cmock_call_instance->IgnoreArg_alarm_id = 1; } -void ppu_v1_init(struct ppu_v1_reg* ppu) +void ppu_v1_init(struct ppu_v1_regs* ppu) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_init_CALL_INSTANCE* cmock_call_instance; @@ -1711,7 +1711,7 @@ void ppu_v1_init(struct ppu_v1_reg* ppu) if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } } if (Mock.ppu_v1_init_CallbackFunctionPointer != NULL) @@ -1727,8 +1727,8 @@ void ppu_v1_init(struct ppu_v1_reg* ppu) UNITY_CLR_DETAILS(); } -void CMockExpectParameters_ppu_v1_init(CMOCK_ppu_v1_init_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth); -void CMockExpectParameters_ppu_v1_init(CMOCK_ppu_v1_init_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth) +void CMockExpectParameters_ppu_v1_init(CMOCK_ppu_v1_init_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth); +void CMockExpectParameters_ppu_v1_init(CMOCK_ppu_v1_init_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -1759,7 +1759,7 @@ void ppu_v1_init_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_init_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu) +void ppu_v1_init_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_init_CALL_INSTANCE)); CMOCK_ppu_v1_init_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_init_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -1786,7 +1786,7 @@ void ppu_v1_init_Stub(CMOCK_ppu_v1_init_CALLBACK Callback) Mock.ppu_v1_init_CallbackFunctionPointer = Callback; } -void ppu_v1_init_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth) +void ppu_v1_init_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_init_CALL_INSTANCE)); CMOCK_ppu_v1_init_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_init_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -1799,7 +1799,7 @@ void ppu_v1_init_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_ CMockExpectParameters_ppu_v1_init(cmock_call_instance, ppu, ppu_Depth); } -void ppu_v1_init_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_init_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_init_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_init_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_init_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -1815,7 +1815,7 @@ void ppu_v1_init_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line) cmock_call_instance->IgnoreArg_ppu = 1; } -int ppu_v1_set_power_mode(struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, struct ppu_v1_timer_ctx* timer_ctx) +int ppu_v1_set_power_mode(struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode, struct ppu_v1_timer_ctx* timer_ctx) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_set_power_mode_CALL_INSTANCE* cmock_call_instance; @@ -1847,7 +1847,7 @@ int ppu_v1_set_power_mode(struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, str if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_ppu_mode) { @@ -1883,8 +1883,8 @@ int ppu_v1_set_power_mode(struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, str return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_ppu_v1_set_power_mode(CMOCK_ppu_v1_set_power_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, struct ppu_v1_timer_ctx* timer_ctx, int timer_ctx_Depth); -void CMockExpectParameters_ppu_v1_set_power_mode(CMOCK_ppu_v1_set_power_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, struct ppu_v1_timer_ctx* timer_ctx, int timer_ctx_Depth) +void CMockExpectParameters_ppu_v1_set_power_mode(CMOCK_ppu_v1_set_power_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, struct ppu_v1_timer_ctx* timer_ctx, int timer_ctx_Depth); +void CMockExpectParameters_ppu_v1_set_power_mode(CMOCK_ppu_v1_set_power_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, struct ppu_v1_timer_ctx* timer_ctx, int timer_ctx_Depth) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -1934,7 +1934,7 @@ void ppu_v1_set_power_mode_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_lin cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_set_power_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, struct ppu_v1_timer_ctx* timer_ctx, int cmock_to_return) +void ppu_v1_set_power_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode, struct ppu_v1_timer_ctx* timer_ctx, int cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_set_power_mode_CALL_INSTANCE)); CMOCK_ppu_v1_set_power_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_set_power_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -1962,7 +1962,7 @@ void ppu_v1_set_power_mode_Stub(CMOCK_ppu_v1_set_power_mode_CALLBACK Callback) Mock.ppu_v1_set_power_mode_CallbackFunctionPointer = Callback; } -void ppu_v1_set_power_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, struct ppu_v1_timer_ctx* timer_ctx, int timer_ctx_Depth, int cmock_to_return) +void ppu_v1_set_power_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, struct ppu_v1_timer_ctx* timer_ctx, int timer_ctx_Depth, int cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_set_power_mode_CALL_INSTANCE)); CMOCK_ppu_v1_set_power_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_set_power_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -1976,7 +1976,7 @@ void ppu_v1_set_power_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_l cmock_call_instance->ReturnVal = cmock_to_return; } -void ppu_v1_set_power_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_set_power_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_set_power_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_set_power_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_set_power_mode_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -2015,7 +2015,7 @@ void ppu_v1_set_power_mode_CMockIgnoreArg_timer_ctx(UNITY_LINE_TYPE cmock_line) cmock_call_instance->IgnoreArg_timer_ctx = 1; } -int ppu_v1_request_power_mode(struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode) +int ppu_v1_request_power_mode(struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_request_power_mode_CALL_INSTANCE* cmock_call_instance; @@ -2047,7 +2047,7 @@ int ppu_v1_request_power_mode(struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode) if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_ppu_mode) { @@ -2069,8 +2069,8 @@ int ppu_v1_request_power_mode(struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode) return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_ppu_v1_request_power_mode(CMOCK_ppu_v1_request_power_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode); -void CMockExpectParameters_ppu_v1_request_power_mode(CMOCK_ppu_v1_request_power_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode) +void CMockExpectParameters_ppu_v1_request_power_mode(CMOCK_ppu_v1_request_power_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode); +void CMockExpectParameters_ppu_v1_request_power_mode(CMOCK_ppu_v1_request_power_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -2116,7 +2116,7 @@ void ppu_v1_request_power_mode_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_request_power_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, int cmock_to_return) +void ppu_v1_request_power_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode, int cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_request_power_mode_CALL_INSTANCE)); CMOCK_ppu_v1_request_power_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_request_power_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -2144,7 +2144,7 @@ void ppu_v1_request_power_mode_Stub(CMOCK_ppu_v1_request_power_mode_CALLBACK Cal Mock.ppu_v1_request_power_mode_CallbackFunctionPointer = Callback; } -void ppu_v1_request_power_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, int cmock_to_return) +void ppu_v1_request_power_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, int cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_request_power_mode_CALL_INSTANCE)); CMOCK_ppu_v1_request_power_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_request_power_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -2158,7 +2158,7 @@ void ppu_v1_request_power_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmo cmock_call_instance->ReturnVal = cmock_to_return; } -void ppu_v1_request_power_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_request_power_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_request_power_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_request_power_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_request_power_mode_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -2181,7 +2181,7 @@ void ppu_v1_request_power_mode_CMockIgnoreArg_ppu_mode(UNITY_LINE_TYPE cmock_lin cmock_call_instance->IgnoreArg_ppu_mode = 1; } -int ppu_v1_request_operating_mode(struct ppu_v1_reg* ppu, enum ppu_v1_opmode op_mode) +int ppu_v1_request_operating_mode(struct ppu_v1_regs* ppu, enum ppu_v1_opmode op_mode) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_request_operating_mode_CALL_INSTANCE* cmock_call_instance; @@ -2213,7 +2213,7 @@ int ppu_v1_request_operating_mode(struct ppu_v1_reg* ppu, enum ppu_v1_opmode op_ if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_op_mode) { @@ -2235,8 +2235,8 @@ int ppu_v1_request_operating_mode(struct ppu_v1_reg* ppu, enum ppu_v1_opmode op_ return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_ppu_v1_request_operating_mode(CMOCK_ppu_v1_request_operating_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_opmode op_mode); -void CMockExpectParameters_ppu_v1_request_operating_mode(CMOCK_ppu_v1_request_operating_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_opmode op_mode) +void CMockExpectParameters_ppu_v1_request_operating_mode(CMOCK_ppu_v1_request_operating_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_opmode op_mode); +void CMockExpectParameters_ppu_v1_request_operating_mode(CMOCK_ppu_v1_request_operating_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_opmode op_mode) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -2282,7 +2282,7 @@ void ppu_v1_request_operating_mode_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE c cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_request_operating_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_opmode op_mode, int cmock_to_return) +void ppu_v1_request_operating_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_opmode op_mode, int cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_request_operating_mode_CALL_INSTANCE)); CMOCK_ppu_v1_request_operating_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_request_operating_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -2310,7 +2310,7 @@ void ppu_v1_request_operating_mode_Stub(CMOCK_ppu_v1_request_operating_mode_CALL Mock.ppu_v1_request_operating_mode_CallbackFunctionPointer = Callback; } -void ppu_v1_request_operating_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_opmode op_mode, int cmock_to_return) +void ppu_v1_request_operating_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_opmode op_mode, int cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_request_operating_mode_CALL_INSTANCE)); CMOCK_ppu_v1_request_operating_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_request_operating_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -2324,7 +2324,7 @@ void ppu_v1_request_operating_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_call_instance->ReturnVal = cmock_to_return; } -void ppu_v1_request_operating_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_request_operating_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_request_operating_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_request_operating_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_request_operating_mode_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -2347,7 +2347,7 @@ void ppu_v1_request_operating_mode_CMockIgnoreArg_op_mode(UNITY_LINE_TYPE cmock_ cmock_call_instance->IgnoreArg_op_mode = 1; } -void ppu_v1_opmode_dynamic_enable(struct ppu_v1_reg* ppu, enum ppu_v1_opmode min_dyn_mode) +void ppu_v1_opmode_dynamic_enable(struct ppu_v1_regs* ppu, enum ppu_v1_opmode min_dyn_mode) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_opmode_dynamic_enable_CALL_INSTANCE* cmock_call_instance; @@ -2376,7 +2376,7 @@ void ppu_v1_opmode_dynamic_enable(struct ppu_v1_reg* ppu, enum ppu_v1_opmode min if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_min_dyn_mode) { @@ -2397,8 +2397,8 @@ void ppu_v1_opmode_dynamic_enable(struct ppu_v1_reg* ppu, enum ppu_v1_opmode min UNITY_CLR_DETAILS(); } -void CMockExpectParameters_ppu_v1_opmode_dynamic_enable(CMOCK_ppu_v1_opmode_dynamic_enable_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_opmode min_dyn_mode); -void CMockExpectParameters_ppu_v1_opmode_dynamic_enable(CMOCK_ppu_v1_opmode_dynamic_enable_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_opmode min_dyn_mode) +void CMockExpectParameters_ppu_v1_opmode_dynamic_enable(CMOCK_ppu_v1_opmode_dynamic_enable_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_opmode min_dyn_mode); +void CMockExpectParameters_ppu_v1_opmode_dynamic_enable(CMOCK_ppu_v1_opmode_dynamic_enable_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_opmode min_dyn_mode) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -2432,7 +2432,7 @@ void ppu_v1_opmode_dynamic_enable_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_opmode_dynamic_enable_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_opmode min_dyn_mode) +void ppu_v1_opmode_dynamic_enable_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_opmode min_dyn_mode) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_opmode_dynamic_enable_CALL_INSTANCE)); CMOCK_ppu_v1_opmode_dynamic_enable_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_opmode_dynamic_enable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -2459,7 +2459,7 @@ void ppu_v1_opmode_dynamic_enable_Stub(CMOCK_ppu_v1_opmode_dynamic_enable_CALLBA Mock.ppu_v1_opmode_dynamic_enable_CallbackFunctionPointer = Callback; } -void ppu_v1_opmode_dynamic_enable_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_opmode min_dyn_mode) +void ppu_v1_opmode_dynamic_enable_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_opmode min_dyn_mode) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_opmode_dynamic_enable_CALL_INSTANCE)); CMOCK_ppu_v1_opmode_dynamic_enable_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_opmode_dynamic_enable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -2472,7 +2472,7 @@ void ppu_v1_opmode_dynamic_enable_CMockExpectWithArray(UNITY_LINE_TYPE cmock_lin CMockExpectParameters_ppu_v1_opmode_dynamic_enable(cmock_call_instance, ppu, ppu_Depth, min_dyn_mode); } -void ppu_v1_opmode_dynamic_enable_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_opmode_dynamic_enable_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_opmode_dynamic_enable_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_opmode_dynamic_enable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_opmode_dynamic_enable_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -2495,7 +2495,7 @@ void ppu_v1_opmode_dynamic_enable_CMockIgnoreArg_min_dyn_mode(UNITY_LINE_TYPE cm cmock_call_instance->IgnoreArg_min_dyn_mode = 1; } -void ppu_v1_dynamic_enable(struct ppu_v1_reg* ppu, enum ppu_v1_mode min_dyn_state) +void ppu_v1_dynamic_enable(struct ppu_v1_regs* ppu, enum ppu_v1_mode min_dyn_state) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_dynamic_enable_CALL_INSTANCE* cmock_call_instance; @@ -2524,7 +2524,7 @@ void ppu_v1_dynamic_enable(struct ppu_v1_reg* ppu, enum ppu_v1_mode min_dyn_stat if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_min_dyn_state) { @@ -2545,8 +2545,8 @@ void ppu_v1_dynamic_enable(struct ppu_v1_reg* ppu, enum ppu_v1_mode min_dyn_stat UNITY_CLR_DETAILS(); } -void CMockExpectParameters_ppu_v1_dynamic_enable(CMOCK_ppu_v1_dynamic_enable_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode min_dyn_state); -void CMockExpectParameters_ppu_v1_dynamic_enable(CMOCK_ppu_v1_dynamic_enable_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode min_dyn_state) +void CMockExpectParameters_ppu_v1_dynamic_enable(CMOCK_ppu_v1_dynamic_enable_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode min_dyn_state); +void CMockExpectParameters_ppu_v1_dynamic_enable(CMOCK_ppu_v1_dynamic_enable_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode min_dyn_state) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -2580,7 +2580,7 @@ void ppu_v1_dynamic_enable_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_dynamic_enable_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_mode min_dyn_state) +void ppu_v1_dynamic_enable_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_mode min_dyn_state) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_dynamic_enable_CALL_INSTANCE)); CMOCK_ppu_v1_dynamic_enable_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_dynamic_enable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -2607,7 +2607,7 @@ void ppu_v1_dynamic_enable_Stub(CMOCK_ppu_v1_dynamic_enable_CALLBACK Callback) Mock.ppu_v1_dynamic_enable_CallbackFunctionPointer = Callback; } -void ppu_v1_dynamic_enable_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode min_dyn_state) +void ppu_v1_dynamic_enable_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode min_dyn_state) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_dynamic_enable_CALL_INSTANCE)); CMOCK_ppu_v1_dynamic_enable_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_dynamic_enable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -2620,7 +2620,7 @@ void ppu_v1_dynamic_enable_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, stru CMockExpectParameters_ppu_v1_dynamic_enable(cmock_call_instance, ppu, ppu_Depth, min_dyn_state); } -void ppu_v1_dynamic_enable_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_dynamic_enable_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_dynamic_enable_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_dynamic_enable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_dynamic_enable_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -2643,7 +2643,7 @@ void ppu_v1_dynamic_enable_CMockIgnoreArg_min_dyn_state(UNITY_LINE_TYPE cmock_li cmock_call_instance->IgnoreArg_min_dyn_state = 1; } -void ppu_v1_lock_off_enable(struct ppu_v1_reg* ppu) +void ppu_v1_lock_off_enable(struct ppu_v1_regs* ppu) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_lock_off_enable_CALL_INSTANCE* cmock_call_instance; @@ -2672,7 +2672,7 @@ void ppu_v1_lock_off_enable(struct ppu_v1_reg* ppu) if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } } if (Mock.ppu_v1_lock_off_enable_CallbackFunctionPointer != NULL) @@ -2688,8 +2688,8 @@ void ppu_v1_lock_off_enable(struct ppu_v1_reg* ppu) UNITY_CLR_DETAILS(); } -void CMockExpectParameters_ppu_v1_lock_off_enable(CMOCK_ppu_v1_lock_off_enable_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth); -void CMockExpectParameters_ppu_v1_lock_off_enable(CMOCK_ppu_v1_lock_off_enable_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth) +void CMockExpectParameters_ppu_v1_lock_off_enable(CMOCK_ppu_v1_lock_off_enable_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth); +void CMockExpectParameters_ppu_v1_lock_off_enable(CMOCK_ppu_v1_lock_off_enable_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -2720,7 +2720,7 @@ void ppu_v1_lock_off_enable_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_lock_off_enable_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu) +void ppu_v1_lock_off_enable_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_lock_off_enable_CALL_INSTANCE)); CMOCK_ppu_v1_lock_off_enable_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_lock_off_enable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -2747,7 +2747,7 @@ void ppu_v1_lock_off_enable_Stub(CMOCK_ppu_v1_lock_off_enable_CALLBACK Callback) Mock.ppu_v1_lock_off_enable_CallbackFunctionPointer = Callback; } -void ppu_v1_lock_off_enable_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth) +void ppu_v1_lock_off_enable_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_lock_off_enable_CALL_INSTANCE)); CMOCK_ppu_v1_lock_off_enable_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_lock_off_enable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -2760,7 +2760,7 @@ void ppu_v1_lock_off_enable_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, str CMockExpectParameters_ppu_v1_lock_off_enable(cmock_call_instance, ppu, ppu_Depth); } -void ppu_v1_lock_off_enable_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_lock_off_enable_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_lock_off_enable_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_lock_off_enable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_lock_off_enable_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -2776,7 +2776,7 @@ void ppu_v1_lock_off_enable_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line) cmock_call_instance->IgnoreArg_ppu = 1; } -void ppu_v1_lock_off_disable(struct ppu_v1_reg* ppu) +void ppu_v1_lock_off_disable(struct ppu_v1_regs* ppu) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_lock_off_disable_CALL_INSTANCE* cmock_call_instance; @@ -2805,7 +2805,7 @@ void ppu_v1_lock_off_disable(struct ppu_v1_reg* ppu) if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } } if (Mock.ppu_v1_lock_off_disable_CallbackFunctionPointer != NULL) @@ -2821,8 +2821,8 @@ void ppu_v1_lock_off_disable(struct ppu_v1_reg* ppu) UNITY_CLR_DETAILS(); } -void CMockExpectParameters_ppu_v1_lock_off_disable(CMOCK_ppu_v1_lock_off_disable_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth); -void CMockExpectParameters_ppu_v1_lock_off_disable(CMOCK_ppu_v1_lock_off_disable_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth) +void CMockExpectParameters_ppu_v1_lock_off_disable(CMOCK_ppu_v1_lock_off_disable_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth); +void CMockExpectParameters_ppu_v1_lock_off_disable(CMOCK_ppu_v1_lock_off_disable_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -2853,7 +2853,7 @@ void ppu_v1_lock_off_disable_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_lock_off_disable_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu) +void ppu_v1_lock_off_disable_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_lock_off_disable_CALL_INSTANCE)); CMOCK_ppu_v1_lock_off_disable_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_lock_off_disable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -2880,7 +2880,7 @@ void ppu_v1_lock_off_disable_Stub(CMOCK_ppu_v1_lock_off_disable_CALLBACK Callbac Mock.ppu_v1_lock_off_disable_CallbackFunctionPointer = Callback; } -void ppu_v1_lock_off_disable_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth) +void ppu_v1_lock_off_disable_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_lock_off_disable_CALL_INSTANCE)); CMOCK_ppu_v1_lock_off_disable_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_lock_off_disable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -2893,7 +2893,7 @@ void ppu_v1_lock_off_disable_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, st CMockExpectParameters_ppu_v1_lock_off_disable(cmock_call_instance, ppu, ppu_Depth); } -void ppu_v1_lock_off_disable_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_lock_off_disable_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_lock_off_disable_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_lock_off_disable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_lock_off_disable_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -2909,7 +2909,7 @@ void ppu_v1_lock_off_disable_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line) cmock_call_instance->IgnoreArg_ppu = 1; } -enum ppu_v1_mode ppu_v1_get_power_mode(struct ppu_v1_reg* ppu) +enum ppu_v1_mode ppu_v1_get_power_mode(struct ppu_v1_regs* ppu) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_get_power_mode_CALL_INSTANCE* cmock_call_instance; @@ -2942,7 +2942,7 @@ enum ppu_v1_mode ppu_v1_get_power_mode(struct ppu_v1_reg* ppu) if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } } if (Mock.ppu_v1_get_power_mode_CallbackFunctionPointer != NULL) @@ -2959,8 +2959,8 @@ enum ppu_v1_mode ppu_v1_get_power_mode(struct ppu_v1_reg* ppu) return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_ppu_v1_get_power_mode(CMOCK_ppu_v1_get_power_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth); -void CMockExpectParameters_ppu_v1_get_power_mode(CMOCK_ppu_v1_get_power_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth) +void CMockExpectParameters_ppu_v1_get_power_mode(CMOCK_ppu_v1_get_power_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth); +void CMockExpectParameters_ppu_v1_get_power_mode(CMOCK_ppu_v1_get_power_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -3003,7 +3003,7 @@ void ppu_v1_get_power_mode_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_lin cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_get_power_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_mode cmock_to_return) +void ppu_v1_get_power_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_mode cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_get_power_mode_CALL_INSTANCE)); CMOCK_ppu_v1_get_power_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_power_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -3032,7 +3032,7 @@ void ppu_v1_get_power_mode_Stub(CMOCK_ppu_v1_get_power_mode_CALLBACK Callback) Mock.ppu_v1_get_power_mode_CallbackFunctionPointer = Callback; } -void ppu_v1_get_power_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode cmock_to_return) +void ppu_v1_get_power_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_get_power_mode_CALL_INSTANCE)); CMOCK_ppu_v1_get_power_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_power_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -3046,7 +3046,7 @@ void ppu_v1_get_power_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_l cmock_call_instance->ReturnVal = cmock_to_return; } -void ppu_v1_get_power_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_get_power_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_get_power_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_power_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_get_power_mode_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -3062,7 +3062,7 @@ void ppu_v1_get_power_mode_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line) cmock_call_instance->IgnoreArg_ppu = 1; } -enum ppu_v1_mode ppu_v1_get_programmed_power_mode(struct ppu_v1_reg* ppu) +enum ppu_v1_mode ppu_v1_get_programmed_power_mode(struct ppu_v1_regs* ppu) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_get_programmed_power_mode_CALL_INSTANCE* cmock_call_instance; @@ -3095,7 +3095,7 @@ enum ppu_v1_mode ppu_v1_get_programmed_power_mode(struct ppu_v1_reg* ppu) if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } } if (Mock.ppu_v1_get_programmed_power_mode_CallbackFunctionPointer != NULL) @@ -3112,8 +3112,8 @@ enum ppu_v1_mode ppu_v1_get_programmed_power_mode(struct ppu_v1_reg* ppu) return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_ppu_v1_get_programmed_power_mode(CMOCK_ppu_v1_get_programmed_power_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth); -void CMockExpectParameters_ppu_v1_get_programmed_power_mode(CMOCK_ppu_v1_get_programmed_power_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth) +void CMockExpectParameters_ppu_v1_get_programmed_power_mode(CMOCK_ppu_v1_get_programmed_power_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth); +void CMockExpectParameters_ppu_v1_get_programmed_power_mode(CMOCK_ppu_v1_get_programmed_power_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -3156,7 +3156,7 @@ void ppu_v1_get_programmed_power_mode_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYP cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_get_programmed_power_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_mode cmock_to_return) +void ppu_v1_get_programmed_power_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_mode cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_get_programmed_power_mode_CALL_INSTANCE)); CMOCK_ppu_v1_get_programmed_power_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_programmed_power_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -3185,7 +3185,7 @@ void ppu_v1_get_programmed_power_mode_Stub(CMOCK_ppu_v1_get_programmed_power_mod Mock.ppu_v1_get_programmed_power_mode_CallbackFunctionPointer = Callback; } -void ppu_v1_get_programmed_power_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode cmock_to_return) +void ppu_v1_get_programmed_power_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_get_programmed_power_mode_CALL_INSTANCE)); CMOCK_ppu_v1_get_programmed_power_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_programmed_power_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -3199,7 +3199,7 @@ void ppu_v1_get_programmed_power_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_T cmock_call_instance->ReturnVal = cmock_to_return; } -void ppu_v1_get_programmed_power_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_get_programmed_power_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_get_programmed_power_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_programmed_power_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_get_programmed_power_mode_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -3215,7 +3215,7 @@ void ppu_v1_get_programmed_power_mode_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_l cmock_call_instance->IgnoreArg_ppu = 1; } -enum ppu_v1_opmode ppu_v1_get_operating_mode(struct ppu_v1_reg* ppu) +enum ppu_v1_opmode ppu_v1_get_operating_mode(struct ppu_v1_regs* ppu) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_get_operating_mode_CALL_INSTANCE* cmock_call_instance; @@ -3248,7 +3248,7 @@ enum ppu_v1_opmode ppu_v1_get_operating_mode(struct ppu_v1_reg* ppu) if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } } if (Mock.ppu_v1_get_operating_mode_CallbackFunctionPointer != NULL) @@ -3265,8 +3265,8 @@ enum ppu_v1_opmode ppu_v1_get_operating_mode(struct ppu_v1_reg* ppu) return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_ppu_v1_get_operating_mode(CMOCK_ppu_v1_get_operating_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth); -void CMockExpectParameters_ppu_v1_get_operating_mode(CMOCK_ppu_v1_get_operating_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth) +void CMockExpectParameters_ppu_v1_get_operating_mode(CMOCK_ppu_v1_get_operating_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth); +void CMockExpectParameters_ppu_v1_get_operating_mode(CMOCK_ppu_v1_get_operating_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -3309,7 +3309,7 @@ void ppu_v1_get_operating_mode_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_get_operating_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_opmode cmock_to_return) +void ppu_v1_get_operating_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_opmode cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_get_operating_mode_CALL_INSTANCE)); CMOCK_ppu_v1_get_operating_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_operating_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -3338,7 +3338,7 @@ void ppu_v1_get_operating_mode_Stub(CMOCK_ppu_v1_get_operating_mode_CALLBACK Cal Mock.ppu_v1_get_operating_mode_CallbackFunctionPointer = Callback; } -void ppu_v1_get_operating_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_opmode cmock_to_return) +void ppu_v1_get_operating_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_opmode cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_get_operating_mode_CALL_INSTANCE)); CMOCK_ppu_v1_get_operating_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_operating_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -3352,7 +3352,7 @@ void ppu_v1_get_operating_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmo cmock_call_instance->ReturnVal = cmock_to_return; } -void ppu_v1_get_operating_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_get_operating_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_get_operating_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_operating_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_get_operating_mode_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -3368,7 +3368,7 @@ void ppu_v1_get_operating_mode_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line) cmock_call_instance->IgnoreArg_ppu = 1; } -enum ppu_v1_opmode ppu_v1_get_programmed_operating_mode(struct ppu_v1_reg* ppu) +enum ppu_v1_opmode ppu_v1_get_programmed_operating_mode(struct ppu_v1_regs* ppu) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_get_programmed_operating_mode_CALL_INSTANCE* cmock_call_instance; @@ -3401,7 +3401,7 @@ enum ppu_v1_opmode ppu_v1_get_programmed_operating_mode(struct ppu_v1_reg* ppu) if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } } if (Mock.ppu_v1_get_programmed_operating_mode_CallbackFunctionPointer != NULL) @@ -3418,8 +3418,8 @@ enum ppu_v1_opmode ppu_v1_get_programmed_operating_mode(struct ppu_v1_reg* ppu) return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_ppu_v1_get_programmed_operating_mode(CMOCK_ppu_v1_get_programmed_operating_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth); -void CMockExpectParameters_ppu_v1_get_programmed_operating_mode(CMOCK_ppu_v1_get_programmed_operating_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth) +void CMockExpectParameters_ppu_v1_get_programmed_operating_mode(CMOCK_ppu_v1_get_programmed_operating_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth); +void CMockExpectParameters_ppu_v1_get_programmed_operating_mode(CMOCK_ppu_v1_get_programmed_operating_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -3462,7 +3462,7 @@ void ppu_v1_get_programmed_operating_mode_CMockExpectAnyArgsAndReturn(UNITY_LINE cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_get_programmed_operating_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_opmode cmock_to_return) +void ppu_v1_get_programmed_operating_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_opmode cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_get_programmed_operating_mode_CALL_INSTANCE)); CMOCK_ppu_v1_get_programmed_operating_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_programmed_operating_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -3491,7 +3491,7 @@ void ppu_v1_get_programmed_operating_mode_Stub(CMOCK_ppu_v1_get_programmed_opera Mock.ppu_v1_get_programmed_operating_mode_CallbackFunctionPointer = Callback; } -void ppu_v1_get_programmed_operating_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_opmode cmock_to_return) +void ppu_v1_get_programmed_operating_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_opmode cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_get_programmed_operating_mode_CALL_INSTANCE)); CMOCK_ppu_v1_get_programmed_operating_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_programmed_operating_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -3505,7 +3505,7 @@ void ppu_v1_get_programmed_operating_mode_CMockExpectWithArrayAndReturn(UNITY_LI cmock_call_instance->ReturnVal = cmock_to_return; } -void ppu_v1_get_programmed_operating_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_get_programmed_operating_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_get_programmed_operating_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_programmed_operating_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_get_programmed_operating_mode_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -3521,7 +3521,7 @@ void ppu_v1_get_programmed_operating_mode_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmo cmock_call_instance->IgnoreArg_ppu = 1; } -bool ppu_v1_is_dynamic_enabled(struct ppu_v1_reg* ppu) +bool ppu_v1_is_dynamic_enabled(struct ppu_v1_regs* ppu) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_is_dynamic_enabled_CALL_INSTANCE* cmock_call_instance; @@ -3553,7 +3553,7 @@ bool ppu_v1_is_dynamic_enabled(struct ppu_v1_reg* ppu) if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } } if (Mock.ppu_v1_is_dynamic_enabled_CallbackFunctionPointer != NULL) @@ -3570,8 +3570,8 @@ bool ppu_v1_is_dynamic_enabled(struct ppu_v1_reg* ppu) return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_ppu_v1_is_dynamic_enabled(CMOCK_ppu_v1_is_dynamic_enabled_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth); -void CMockExpectParameters_ppu_v1_is_dynamic_enabled(CMOCK_ppu_v1_is_dynamic_enabled_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth) +void CMockExpectParameters_ppu_v1_is_dynamic_enabled(CMOCK_ppu_v1_is_dynamic_enabled_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth); +void CMockExpectParameters_ppu_v1_is_dynamic_enabled(CMOCK_ppu_v1_is_dynamic_enabled_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -3614,7 +3614,7 @@ void ppu_v1_is_dynamic_enabled_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_is_dynamic_enabled_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, bool cmock_to_return) +void ppu_v1_is_dynamic_enabled_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, bool cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_is_dynamic_enabled_CALL_INSTANCE)); CMOCK_ppu_v1_is_dynamic_enabled_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_dynamic_enabled_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -3642,7 +3642,7 @@ void ppu_v1_is_dynamic_enabled_Stub(CMOCK_ppu_v1_is_dynamic_enabled_CALLBACK Cal Mock.ppu_v1_is_dynamic_enabled_CallbackFunctionPointer = Callback; } -void ppu_v1_is_dynamic_enabled_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, bool cmock_to_return) +void ppu_v1_is_dynamic_enabled_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, bool cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_is_dynamic_enabled_CALL_INSTANCE)); CMOCK_ppu_v1_is_dynamic_enabled_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_dynamic_enabled_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -3656,7 +3656,7 @@ void ppu_v1_is_dynamic_enabled_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmo cmock_call_instance->ReturnVal = cmock_to_return; } -void ppu_v1_is_dynamic_enabled_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_is_dynamic_enabled_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_is_dynamic_enabled_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_dynamic_enabled_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_is_dynamic_enabled_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -3672,7 +3672,7 @@ void ppu_v1_is_dynamic_enabled_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line) cmock_call_instance->IgnoreArg_ppu = 1; } -bool ppu_v1_is_locked(struct ppu_v1_reg* ppu) +bool ppu_v1_is_locked(struct ppu_v1_regs* ppu) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_is_locked_CALL_INSTANCE* cmock_call_instance; @@ -3704,7 +3704,7 @@ bool ppu_v1_is_locked(struct ppu_v1_reg* ppu) if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } } if (Mock.ppu_v1_is_locked_CallbackFunctionPointer != NULL) @@ -3721,8 +3721,8 @@ bool ppu_v1_is_locked(struct ppu_v1_reg* ppu) return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_ppu_v1_is_locked(CMOCK_ppu_v1_is_locked_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth); -void CMockExpectParameters_ppu_v1_is_locked(CMOCK_ppu_v1_is_locked_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth) +void CMockExpectParameters_ppu_v1_is_locked(CMOCK_ppu_v1_is_locked_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth); +void CMockExpectParameters_ppu_v1_is_locked(CMOCK_ppu_v1_is_locked_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -3765,7 +3765,7 @@ void ppu_v1_is_locked_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, bo cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_is_locked_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, bool cmock_to_return) +void ppu_v1_is_locked_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, bool cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_is_locked_CALL_INSTANCE)); CMOCK_ppu_v1_is_locked_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_locked_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -3793,7 +3793,7 @@ void ppu_v1_is_locked_Stub(CMOCK_ppu_v1_is_locked_CALLBACK Callback) Mock.ppu_v1_is_locked_CallbackFunctionPointer = Callback; } -void ppu_v1_is_locked_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, bool cmock_to_return) +void ppu_v1_is_locked_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, bool cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_is_locked_CALL_INSTANCE)); CMOCK_ppu_v1_is_locked_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_locked_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -3807,7 +3807,7 @@ void ppu_v1_is_locked_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, cmock_call_instance->ReturnVal = cmock_to_return; } -void ppu_v1_is_locked_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_is_locked_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_is_locked_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_locked_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_is_locked_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -3823,7 +3823,7 @@ void ppu_v1_is_locked_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line) cmock_call_instance->IgnoreArg_ppu = 1; } -bool ppu_v1_is_power_devactive_high(struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode) +bool ppu_v1_is_power_devactive_high(struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_is_power_devactive_high_CALL_INSTANCE* cmock_call_instance; @@ -3855,7 +3855,7 @@ bool ppu_v1_is_power_devactive_high(struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_ppu_mode) { @@ -3877,8 +3877,8 @@ bool ppu_v1_is_power_devactive_high(struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_ppu_v1_is_power_devactive_high(CMOCK_ppu_v1_is_power_devactive_high_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode); -void CMockExpectParameters_ppu_v1_is_power_devactive_high(CMOCK_ppu_v1_is_power_devactive_high_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode) +void CMockExpectParameters_ppu_v1_is_power_devactive_high(CMOCK_ppu_v1_is_power_devactive_high_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode); +void CMockExpectParameters_ppu_v1_is_power_devactive_high(CMOCK_ppu_v1_is_power_devactive_high_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -3924,7 +3924,7 @@ void ppu_v1_is_power_devactive_high_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_is_power_devactive_high_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, bool cmock_to_return) +void ppu_v1_is_power_devactive_high_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode, bool cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_is_power_devactive_high_CALL_INSTANCE)); CMOCK_ppu_v1_is_power_devactive_high_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_power_devactive_high_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -3952,7 +3952,7 @@ void ppu_v1_is_power_devactive_high_Stub(CMOCK_ppu_v1_is_power_devactive_high_CA Mock.ppu_v1_is_power_devactive_high_CallbackFunctionPointer = Callback; } -void ppu_v1_is_power_devactive_high_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, bool cmock_to_return) +void ppu_v1_is_power_devactive_high_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, bool cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_is_power_devactive_high_CALL_INSTANCE)); CMOCK_ppu_v1_is_power_devactive_high_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_power_devactive_high_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -3966,7 +3966,7 @@ void ppu_v1_is_power_devactive_high_CMockExpectWithArrayAndReturn(UNITY_LINE_TYP cmock_call_instance->ReturnVal = cmock_to_return; } -void ppu_v1_is_power_devactive_high_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_is_power_devactive_high_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_is_power_devactive_high_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_power_devactive_high_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_is_power_devactive_high_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -3989,7 +3989,7 @@ void ppu_v1_is_power_devactive_high_CMockIgnoreArg_ppu_mode(UNITY_LINE_TYPE cmoc cmock_call_instance->IgnoreArg_ppu_mode = 1; } -bool ppu_v1_is_op_devactive_high(struct ppu_v1_reg* ppu, enum ppu_v1_op_devactive op_devactive) +bool ppu_v1_is_op_devactive_high(struct ppu_v1_regs* ppu, enum ppu_v1_op_devactive op_devactive) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_is_op_devactive_high_CALL_INSTANCE* cmock_call_instance; @@ -4021,7 +4021,7 @@ bool ppu_v1_is_op_devactive_high(struct ppu_v1_reg* ppu, enum ppu_v1_op_devactiv if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_op_devactive) { @@ -4043,8 +4043,8 @@ bool ppu_v1_is_op_devactive_high(struct ppu_v1_reg* ppu, enum ppu_v1_op_devactiv return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_ppu_v1_is_op_devactive_high(CMOCK_ppu_v1_is_op_devactive_high_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive); -void CMockExpectParameters_ppu_v1_is_op_devactive_high(CMOCK_ppu_v1_is_op_devactive_high_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive) +void CMockExpectParameters_ppu_v1_is_op_devactive_high(CMOCK_ppu_v1_is_op_devactive_high_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive); +void CMockExpectParameters_ppu_v1_is_op_devactive_high(CMOCK_ppu_v1_is_op_devactive_high_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -4090,7 +4090,7 @@ void ppu_v1_is_op_devactive_high_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmo cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_is_op_devactive_high_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_op_devactive op_devactive, bool cmock_to_return) +void ppu_v1_is_op_devactive_high_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_op_devactive op_devactive, bool cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_is_op_devactive_high_CALL_INSTANCE)); CMOCK_ppu_v1_is_op_devactive_high_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_op_devactive_high_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -4118,7 +4118,7 @@ void ppu_v1_is_op_devactive_high_Stub(CMOCK_ppu_v1_is_op_devactive_high_CALLBACK Mock.ppu_v1_is_op_devactive_high_CallbackFunctionPointer = Callback; } -void ppu_v1_is_op_devactive_high_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive, bool cmock_to_return) +void ppu_v1_is_op_devactive_high_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive, bool cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_is_op_devactive_high_CALL_INSTANCE)); CMOCK_ppu_v1_is_op_devactive_high_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_op_devactive_high_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -4132,7 +4132,7 @@ void ppu_v1_is_op_devactive_high_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE c cmock_call_instance->ReturnVal = cmock_to_return; } -void ppu_v1_is_op_devactive_high_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_is_op_devactive_high_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_is_op_devactive_high_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_op_devactive_high_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_is_op_devactive_high_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -4155,7 +4155,7 @@ void ppu_v1_is_op_devactive_high_CMockIgnoreArg_op_devactive(UNITY_LINE_TYPE cmo cmock_call_instance->IgnoreArg_op_devactive = 1; } -void ppu_v1_off_unlock(struct ppu_v1_reg* ppu) +void ppu_v1_off_unlock(struct ppu_v1_regs* ppu) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_off_unlock_CALL_INSTANCE* cmock_call_instance; @@ -4184,7 +4184,7 @@ void ppu_v1_off_unlock(struct ppu_v1_reg* ppu) if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } } if (Mock.ppu_v1_off_unlock_CallbackFunctionPointer != NULL) @@ -4200,8 +4200,8 @@ void ppu_v1_off_unlock(struct ppu_v1_reg* ppu) UNITY_CLR_DETAILS(); } -void CMockExpectParameters_ppu_v1_off_unlock(CMOCK_ppu_v1_off_unlock_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth); -void CMockExpectParameters_ppu_v1_off_unlock(CMOCK_ppu_v1_off_unlock_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth) +void CMockExpectParameters_ppu_v1_off_unlock(CMOCK_ppu_v1_off_unlock_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth); +void CMockExpectParameters_ppu_v1_off_unlock(CMOCK_ppu_v1_off_unlock_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -4232,7 +4232,7 @@ void ppu_v1_off_unlock_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_off_unlock_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu) +void ppu_v1_off_unlock_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_off_unlock_CALL_INSTANCE)); CMOCK_ppu_v1_off_unlock_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_off_unlock_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -4259,7 +4259,7 @@ void ppu_v1_off_unlock_Stub(CMOCK_ppu_v1_off_unlock_CALLBACK Callback) Mock.ppu_v1_off_unlock_CallbackFunctionPointer = Callback; } -void ppu_v1_off_unlock_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth) +void ppu_v1_off_unlock_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_off_unlock_CALL_INSTANCE)); CMOCK_ppu_v1_off_unlock_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_off_unlock_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -4272,7 +4272,7 @@ void ppu_v1_off_unlock_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct p CMockExpectParameters_ppu_v1_off_unlock(cmock_call_instance, ppu, ppu_Depth); } -void ppu_v1_off_unlock_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_off_unlock_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_off_unlock_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_off_unlock_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_off_unlock_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -4288,7 +4288,7 @@ void ppu_v1_off_unlock_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line) cmock_call_instance->IgnoreArg_ppu = 1; } -void ppu_v1_disable_devactive(struct ppu_v1_reg* ppu) +void ppu_v1_disable_devactive(struct ppu_v1_regs* ppu) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_disable_devactive_CALL_INSTANCE* cmock_call_instance; @@ -4317,7 +4317,7 @@ void ppu_v1_disable_devactive(struct ppu_v1_reg* ppu) if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } } if (Mock.ppu_v1_disable_devactive_CallbackFunctionPointer != NULL) @@ -4333,8 +4333,8 @@ void ppu_v1_disable_devactive(struct ppu_v1_reg* ppu) UNITY_CLR_DETAILS(); } -void CMockExpectParameters_ppu_v1_disable_devactive(CMOCK_ppu_v1_disable_devactive_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth); -void CMockExpectParameters_ppu_v1_disable_devactive(CMOCK_ppu_v1_disable_devactive_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth) +void CMockExpectParameters_ppu_v1_disable_devactive(CMOCK_ppu_v1_disable_devactive_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth); +void CMockExpectParameters_ppu_v1_disable_devactive(CMOCK_ppu_v1_disable_devactive_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -4365,7 +4365,7 @@ void ppu_v1_disable_devactive_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_disable_devactive_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu) +void ppu_v1_disable_devactive_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_disable_devactive_CALL_INSTANCE)); CMOCK_ppu_v1_disable_devactive_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_disable_devactive_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -4392,7 +4392,7 @@ void ppu_v1_disable_devactive_Stub(CMOCK_ppu_v1_disable_devactive_CALLBACK Callb Mock.ppu_v1_disable_devactive_CallbackFunctionPointer = Callback; } -void ppu_v1_disable_devactive_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth) +void ppu_v1_disable_devactive_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_disable_devactive_CALL_INSTANCE)); CMOCK_ppu_v1_disable_devactive_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_disable_devactive_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -4405,7 +4405,7 @@ void ppu_v1_disable_devactive_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, s CMockExpectParameters_ppu_v1_disable_devactive(cmock_call_instance, ppu, ppu_Depth); } -void ppu_v1_disable_devactive_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_disable_devactive_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_disable_devactive_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_disable_devactive_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_disable_devactive_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -4421,7 +4421,7 @@ void ppu_v1_disable_devactive_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line) cmock_call_instance->IgnoreArg_ppu = 1; } -void ppu_v1_disable_handshake(struct ppu_v1_reg* ppu) +void ppu_v1_disable_handshake(struct ppu_v1_regs* ppu) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_disable_handshake_CALL_INSTANCE* cmock_call_instance; @@ -4450,7 +4450,7 @@ void ppu_v1_disable_handshake(struct ppu_v1_reg* ppu) if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } } if (Mock.ppu_v1_disable_handshake_CallbackFunctionPointer != NULL) @@ -4466,8 +4466,8 @@ void ppu_v1_disable_handshake(struct ppu_v1_reg* ppu) UNITY_CLR_DETAILS(); } -void CMockExpectParameters_ppu_v1_disable_handshake(CMOCK_ppu_v1_disable_handshake_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth); -void CMockExpectParameters_ppu_v1_disable_handshake(CMOCK_ppu_v1_disable_handshake_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth) +void CMockExpectParameters_ppu_v1_disable_handshake(CMOCK_ppu_v1_disable_handshake_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth); +void CMockExpectParameters_ppu_v1_disable_handshake(CMOCK_ppu_v1_disable_handshake_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -4498,7 +4498,7 @@ void ppu_v1_disable_handshake_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_disable_handshake_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu) +void ppu_v1_disable_handshake_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_disable_handshake_CALL_INSTANCE)); CMOCK_ppu_v1_disable_handshake_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_disable_handshake_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -4525,7 +4525,7 @@ void ppu_v1_disable_handshake_Stub(CMOCK_ppu_v1_disable_handshake_CALLBACK Callb Mock.ppu_v1_disable_handshake_CallbackFunctionPointer = Callback; } -void ppu_v1_disable_handshake_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth) +void ppu_v1_disable_handshake_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_disable_handshake_CALL_INSTANCE)); CMOCK_ppu_v1_disable_handshake_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_disable_handshake_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -4538,7 +4538,7 @@ void ppu_v1_disable_handshake_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, s CMockExpectParameters_ppu_v1_disable_handshake(cmock_call_instance, ppu, ppu_Depth); } -void ppu_v1_disable_handshake_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_disable_handshake_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_disable_handshake_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_disable_handshake_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_disable_handshake_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -4554,7 +4554,7 @@ void ppu_v1_disable_handshake_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line) cmock_call_instance->IgnoreArg_ppu = 1; } -void ppu_v1_interrupt_mask(struct ppu_v1_reg* ppu, unsigned int mask) +void ppu_v1_interrupt_mask(struct ppu_v1_regs* ppu, unsigned int mask) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_interrupt_mask_CALL_INSTANCE* cmock_call_instance; @@ -4583,7 +4583,7 @@ void ppu_v1_interrupt_mask(struct ppu_v1_reg* ppu, unsigned int mask) if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_mask) { @@ -4604,8 +4604,8 @@ void ppu_v1_interrupt_mask(struct ppu_v1_reg* ppu, unsigned int mask) UNITY_CLR_DETAILS(); } -void CMockExpectParameters_ppu_v1_interrupt_mask(CMOCK_ppu_v1_interrupt_mask_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask); -void CMockExpectParameters_ppu_v1_interrupt_mask(CMOCK_ppu_v1_interrupt_mask_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask) +void CMockExpectParameters_ppu_v1_interrupt_mask(CMOCK_ppu_v1_interrupt_mask_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask); +void CMockExpectParameters_ppu_v1_interrupt_mask(CMOCK_ppu_v1_interrupt_mask_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -4638,7 +4638,7 @@ void ppu_v1_interrupt_mask_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_interrupt_mask_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, unsigned int mask) +void ppu_v1_interrupt_mask_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, unsigned int mask) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_interrupt_mask_CALL_INSTANCE)); CMOCK_ppu_v1_interrupt_mask_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_interrupt_mask_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -4665,7 +4665,7 @@ void ppu_v1_interrupt_mask_Stub(CMOCK_ppu_v1_interrupt_mask_CALLBACK Callback) Mock.ppu_v1_interrupt_mask_CallbackFunctionPointer = Callback; } -void ppu_v1_interrupt_mask_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask) +void ppu_v1_interrupt_mask_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_interrupt_mask_CALL_INSTANCE)); CMOCK_ppu_v1_interrupt_mask_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_interrupt_mask_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -4678,7 +4678,7 @@ void ppu_v1_interrupt_mask_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, stru CMockExpectParameters_ppu_v1_interrupt_mask(cmock_call_instance, ppu, ppu_Depth, mask); } -void ppu_v1_interrupt_mask_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_interrupt_mask_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_interrupt_mask_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_interrupt_mask_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_interrupt_mask_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -4701,7 +4701,7 @@ void ppu_v1_interrupt_mask_CMockIgnoreArg_mask(UNITY_LINE_TYPE cmock_line) cmock_call_instance->IgnoreArg_mask = 1; } -void ppu_v1_additional_interrupt_mask(struct ppu_v1_reg* ppu, unsigned int mask) +void ppu_v1_additional_interrupt_mask(struct ppu_v1_regs* ppu, unsigned int mask) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_additional_interrupt_mask_CALL_INSTANCE* cmock_call_instance; @@ -4730,7 +4730,7 @@ void ppu_v1_additional_interrupt_mask(struct ppu_v1_reg* ppu, unsigned int mask) if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_mask) { @@ -4751,8 +4751,8 @@ void ppu_v1_additional_interrupt_mask(struct ppu_v1_reg* ppu, unsigned int mask) UNITY_CLR_DETAILS(); } -void CMockExpectParameters_ppu_v1_additional_interrupt_mask(CMOCK_ppu_v1_additional_interrupt_mask_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask); -void CMockExpectParameters_ppu_v1_additional_interrupt_mask(CMOCK_ppu_v1_additional_interrupt_mask_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask) +void CMockExpectParameters_ppu_v1_additional_interrupt_mask(CMOCK_ppu_v1_additional_interrupt_mask_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask); +void CMockExpectParameters_ppu_v1_additional_interrupt_mask(CMOCK_ppu_v1_additional_interrupt_mask_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -4785,7 +4785,7 @@ void ppu_v1_additional_interrupt_mask_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_l cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_additional_interrupt_mask_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, unsigned int mask) +void ppu_v1_additional_interrupt_mask_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, unsigned int mask) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_additional_interrupt_mask_CALL_INSTANCE)); CMOCK_ppu_v1_additional_interrupt_mask_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_additional_interrupt_mask_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -4812,7 +4812,7 @@ void ppu_v1_additional_interrupt_mask_Stub(CMOCK_ppu_v1_additional_interrupt_mas Mock.ppu_v1_additional_interrupt_mask_CallbackFunctionPointer = Callback; } -void ppu_v1_additional_interrupt_mask_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask) +void ppu_v1_additional_interrupt_mask_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_additional_interrupt_mask_CALL_INSTANCE)); CMOCK_ppu_v1_additional_interrupt_mask_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_additional_interrupt_mask_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -4825,7 +4825,7 @@ void ppu_v1_additional_interrupt_mask_CMockExpectWithArray(UNITY_LINE_TYPE cmock CMockExpectParameters_ppu_v1_additional_interrupt_mask(cmock_call_instance, ppu, ppu_Depth, mask); } -void ppu_v1_additional_interrupt_mask_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_additional_interrupt_mask_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_additional_interrupt_mask_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_additional_interrupt_mask_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_additional_interrupt_mask_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -4848,7 +4848,7 @@ void ppu_v1_additional_interrupt_mask_CMockIgnoreArg_mask(UNITY_LINE_TYPE cmock_ cmock_call_instance->IgnoreArg_mask = 1; } -void ppu_v1_interrupt_unmask(struct ppu_v1_reg* ppu, unsigned int mask) +void ppu_v1_interrupt_unmask(struct ppu_v1_regs* ppu, unsigned int mask) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_interrupt_unmask_CALL_INSTANCE* cmock_call_instance; @@ -4877,7 +4877,7 @@ void ppu_v1_interrupt_unmask(struct ppu_v1_reg* ppu, unsigned int mask) if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_mask) { @@ -4898,8 +4898,8 @@ void ppu_v1_interrupt_unmask(struct ppu_v1_reg* ppu, unsigned int mask) UNITY_CLR_DETAILS(); } -void CMockExpectParameters_ppu_v1_interrupt_unmask(CMOCK_ppu_v1_interrupt_unmask_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask); -void CMockExpectParameters_ppu_v1_interrupt_unmask(CMOCK_ppu_v1_interrupt_unmask_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask) +void CMockExpectParameters_ppu_v1_interrupt_unmask(CMOCK_ppu_v1_interrupt_unmask_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask); +void CMockExpectParameters_ppu_v1_interrupt_unmask(CMOCK_ppu_v1_interrupt_unmask_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -4932,7 +4932,7 @@ void ppu_v1_interrupt_unmask_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_interrupt_unmask_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, unsigned int mask) +void ppu_v1_interrupt_unmask_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, unsigned int mask) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_interrupt_unmask_CALL_INSTANCE)); CMOCK_ppu_v1_interrupt_unmask_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_interrupt_unmask_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -4959,7 +4959,7 @@ void ppu_v1_interrupt_unmask_Stub(CMOCK_ppu_v1_interrupt_unmask_CALLBACK Callbac Mock.ppu_v1_interrupt_unmask_CallbackFunctionPointer = Callback; } -void ppu_v1_interrupt_unmask_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask) +void ppu_v1_interrupt_unmask_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_interrupt_unmask_CALL_INSTANCE)); CMOCK_ppu_v1_interrupt_unmask_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_interrupt_unmask_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -4972,7 +4972,7 @@ void ppu_v1_interrupt_unmask_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, st CMockExpectParameters_ppu_v1_interrupt_unmask(cmock_call_instance, ppu, ppu_Depth, mask); } -void ppu_v1_interrupt_unmask_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_interrupt_unmask_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_interrupt_unmask_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_interrupt_unmask_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_interrupt_unmask_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -4995,7 +4995,7 @@ void ppu_v1_interrupt_unmask_CMockIgnoreArg_mask(UNITY_LINE_TYPE cmock_line) cmock_call_instance->IgnoreArg_mask = 1; } -void ppu_v1_additional_interrupt_unmask(struct ppu_v1_reg* ppu, unsigned int mask) +void ppu_v1_additional_interrupt_unmask(struct ppu_v1_regs* ppu, unsigned int mask) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_additional_interrupt_unmask_CALL_INSTANCE* cmock_call_instance; @@ -5024,7 +5024,7 @@ void ppu_v1_additional_interrupt_unmask(struct ppu_v1_reg* ppu, unsigned int mas if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_mask) { @@ -5045,8 +5045,8 @@ void ppu_v1_additional_interrupt_unmask(struct ppu_v1_reg* ppu, unsigned int mas UNITY_CLR_DETAILS(); } -void CMockExpectParameters_ppu_v1_additional_interrupt_unmask(CMOCK_ppu_v1_additional_interrupt_unmask_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask); -void CMockExpectParameters_ppu_v1_additional_interrupt_unmask(CMOCK_ppu_v1_additional_interrupt_unmask_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask) +void CMockExpectParameters_ppu_v1_additional_interrupt_unmask(CMOCK_ppu_v1_additional_interrupt_unmask_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask); +void CMockExpectParameters_ppu_v1_additional_interrupt_unmask(CMOCK_ppu_v1_additional_interrupt_unmask_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -5079,7 +5079,7 @@ void ppu_v1_additional_interrupt_unmask_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_additional_interrupt_unmask_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, unsigned int mask) +void ppu_v1_additional_interrupt_unmask_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, unsigned int mask) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_additional_interrupt_unmask_CALL_INSTANCE)); CMOCK_ppu_v1_additional_interrupt_unmask_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_additional_interrupt_unmask_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -5106,7 +5106,7 @@ void ppu_v1_additional_interrupt_unmask_Stub(CMOCK_ppu_v1_additional_interrupt_u Mock.ppu_v1_additional_interrupt_unmask_CallbackFunctionPointer = Callback; } -void ppu_v1_additional_interrupt_unmask_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask) +void ppu_v1_additional_interrupt_unmask_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_additional_interrupt_unmask_CALL_INSTANCE)); CMOCK_ppu_v1_additional_interrupt_unmask_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_additional_interrupt_unmask_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -5119,7 +5119,7 @@ void ppu_v1_additional_interrupt_unmask_CMockExpectWithArray(UNITY_LINE_TYPE cmo CMockExpectParameters_ppu_v1_additional_interrupt_unmask(cmock_call_instance, ppu, ppu_Depth, mask); } -void ppu_v1_additional_interrupt_unmask_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_additional_interrupt_unmask_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_additional_interrupt_unmask_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_additional_interrupt_unmask_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_additional_interrupt_unmask_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -5142,7 +5142,7 @@ void ppu_v1_additional_interrupt_unmask_CMockIgnoreArg_mask(UNITY_LINE_TYPE cmoc cmock_call_instance->IgnoreArg_mask = 1; } -bool ppu_v1_is_additional_interrupt_pending(struct ppu_v1_reg* ppu, unsigned int mask) +bool ppu_v1_is_additional_interrupt_pending(struct ppu_v1_regs* ppu, unsigned int mask) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_is_additional_interrupt_pending_CALL_INSTANCE* cmock_call_instance; @@ -5174,7 +5174,7 @@ bool ppu_v1_is_additional_interrupt_pending(struct ppu_v1_reg* ppu, unsigned int if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_mask) { @@ -5196,8 +5196,8 @@ bool ppu_v1_is_additional_interrupt_pending(struct ppu_v1_reg* ppu, unsigned int return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_ppu_v1_is_additional_interrupt_pending(CMOCK_ppu_v1_is_additional_interrupt_pending_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask); -void CMockExpectParameters_ppu_v1_is_additional_interrupt_pending(CMOCK_ppu_v1_is_additional_interrupt_pending_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask) +void CMockExpectParameters_ppu_v1_is_additional_interrupt_pending(CMOCK_ppu_v1_is_additional_interrupt_pending_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask); +void CMockExpectParameters_ppu_v1_is_additional_interrupt_pending(CMOCK_ppu_v1_is_additional_interrupt_pending_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -5242,7 +5242,7 @@ void ppu_v1_is_additional_interrupt_pending_CMockExpectAnyArgsAndReturn(UNITY_LI cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_is_additional_interrupt_pending_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, unsigned int mask, bool cmock_to_return) +void ppu_v1_is_additional_interrupt_pending_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, unsigned int mask, bool cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_is_additional_interrupt_pending_CALL_INSTANCE)); CMOCK_ppu_v1_is_additional_interrupt_pending_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_additional_interrupt_pending_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -5270,7 +5270,7 @@ void ppu_v1_is_additional_interrupt_pending_Stub(CMOCK_ppu_v1_is_additional_inte Mock.ppu_v1_is_additional_interrupt_pending_CallbackFunctionPointer = Callback; } -void ppu_v1_is_additional_interrupt_pending_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask, bool cmock_to_return) +void ppu_v1_is_additional_interrupt_pending_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask, bool cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_is_additional_interrupt_pending_CALL_INSTANCE)); CMOCK_ppu_v1_is_additional_interrupt_pending_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_additional_interrupt_pending_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -5284,7 +5284,7 @@ void ppu_v1_is_additional_interrupt_pending_CMockExpectWithArrayAndReturn(UNITY_ cmock_call_instance->ReturnVal = cmock_to_return; } -void ppu_v1_is_additional_interrupt_pending_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_is_additional_interrupt_pending_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_is_additional_interrupt_pending_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_additional_interrupt_pending_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_is_additional_interrupt_pending_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -5307,7 +5307,7 @@ void ppu_v1_is_additional_interrupt_pending_CMockIgnoreArg_mask(UNITY_LINE_TYPE cmock_call_instance->IgnoreArg_mask = 1; } -void ppu_v1_ack_interrupt(struct ppu_v1_reg* ppu, unsigned int mask) +void ppu_v1_ack_interrupt(struct ppu_v1_regs* ppu, unsigned int mask) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_ack_interrupt_CALL_INSTANCE* cmock_call_instance; @@ -5336,7 +5336,7 @@ void ppu_v1_ack_interrupt(struct ppu_v1_reg* ppu, unsigned int mask) if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_mask) { @@ -5357,8 +5357,8 @@ void ppu_v1_ack_interrupt(struct ppu_v1_reg* ppu, unsigned int mask) UNITY_CLR_DETAILS(); } -void CMockExpectParameters_ppu_v1_ack_interrupt(CMOCK_ppu_v1_ack_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask); -void CMockExpectParameters_ppu_v1_ack_interrupt(CMOCK_ppu_v1_ack_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask) +void CMockExpectParameters_ppu_v1_ack_interrupt(CMOCK_ppu_v1_ack_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask); +void CMockExpectParameters_ppu_v1_ack_interrupt(CMOCK_ppu_v1_ack_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -5391,7 +5391,7 @@ void ppu_v1_ack_interrupt_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_ack_interrupt_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, unsigned int mask) +void ppu_v1_ack_interrupt_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, unsigned int mask) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_ack_interrupt_CALL_INSTANCE)); CMOCK_ppu_v1_ack_interrupt_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_ack_interrupt_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -5418,7 +5418,7 @@ void ppu_v1_ack_interrupt_Stub(CMOCK_ppu_v1_ack_interrupt_CALLBACK Callback) Mock.ppu_v1_ack_interrupt_CallbackFunctionPointer = Callback; } -void ppu_v1_ack_interrupt_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask) +void ppu_v1_ack_interrupt_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_ack_interrupt_CALL_INSTANCE)); CMOCK_ppu_v1_ack_interrupt_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_ack_interrupt_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -5431,7 +5431,7 @@ void ppu_v1_ack_interrupt_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struc CMockExpectParameters_ppu_v1_ack_interrupt(cmock_call_instance, ppu, ppu_Depth, mask); } -void ppu_v1_ack_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_ack_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_ack_interrupt_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_ack_interrupt_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_ack_interrupt_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -5454,7 +5454,7 @@ void ppu_v1_ack_interrupt_CMockIgnoreArg_mask(UNITY_LINE_TYPE cmock_line) cmock_call_instance->IgnoreArg_mask = 1; } -void ppu_v1_ack_additional_interrupt(struct ppu_v1_reg* ppu, unsigned int mask) +void ppu_v1_ack_additional_interrupt(struct ppu_v1_regs* ppu, unsigned int mask) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_ack_additional_interrupt_CALL_INSTANCE* cmock_call_instance; @@ -5483,7 +5483,7 @@ void ppu_v1_ack_additional_interrupt(struct ppu_v1_reg* ppu, unsigned int mask) if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_mask) { @@ -5504,8 +5504,8 @@ void ppu_v1_ack_additional_interrupt(struct ppu_v1_reg* ppu, unsigned int mask) UNITY_CLR_DETAILS(); } -void CMockExpectParameters_ppu_v1_ack_additional_interrupt(CMOCK_ppu_v1_ack_additional_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask); -void CMockExpectParameters_ppu_v1_ack_additional_interrupt(CMOCK_ppu_v1_ack_additional_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask) +void CMockExpectParameters_ppu_v1_ack_additional_interrupt(CMOCK_ppu_v1_ack_additional_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask); +void CMockExpectParameters_ppu_v1_ack_additional_interrupt(CMOCK_ppu_v1_ack_additional_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -5538,7 +5538,7 @@ void ppu_v1_ack_additional_interrupt_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_li cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_ack_additional_interrupt_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, unsigned int mask) +void ppu_v1_ack_additional_interrupt_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, unsigned int mask) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_ack_additional_interrupt_CALL_INSTANCE)); CMOCK_ppu_v1_ack_additional_interrupt_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_ack_additional_interrupt_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -5565,7 +5565,7 @@ void ppu_v1_ack_additional_interrupt_Stub(CMOCK_ppu_v1_ack_additional_interrupt_ Mock.ppu_v1_ack_additional_interrupt_CallbackFunctionPointer = Callback; } -void ppu_v1_ack_additional_interrupt_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask) +void ppu_v1_ack_additional_interrupt_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_ack_additional_interrupt_CALL_INSTANCE)); CMOCK_ppu_v1_ack_additional_interrupt_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_ack_additional_interrupt_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -5578,7 +5578,7 @@ void ppu_v1_ack_additional_interrupt_CMockExpectWithArray(UNITY_LINE_TYPE cmock_ CMockExpectParameters_ppu_v1_ack_additional_interrupt(cmock_call_instance, ppu, ppu_Depth, mask); } -void ppu_v1_ack_additional_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_ack_additional_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_ack_additional_interrupt_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_ack_additional_interrupt_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_ack_additional_interrupt_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -5601,7 +5601,7 @@ void ppu_v1_ack_additional_interrupt_CMockIgnoreArg_mask(UNITY_LINE_TYPE cmock_l cmock_call_instance->IgnoreArg_mask = 1; } -void ppu_v1_set_input_edge_sensitivity(struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity edge_sensitivity) +void ppu_v1_set_input_edge_sensitivity(struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity edge_sensitivity) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_set_input_edge_sensitivity_CALL_INSTANCE* cmock_call_instance; @@ -5630,7 +5630,7 @@ void ppu_v1_set_input_edge_sensitivity(struct ppu_v1_reg* ppu, enum ppu_v1_mode if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_ppu_mode) { @@ -5656,8 +5656,8 @@ void ppu_v1_set_input_edge_sensitivity(struct ppu_v1_reg* ppu, enum ppu_v1_mode UNITY_CLR_DETAILS(); } -void CMockExpectParameters_ppu_v1_set_input_edge_sensitivity(CMOCK_ppu_v1_set_input_edge_sensitivity_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity edge_sensitivity); -void CMockExpectParameters_ppu_v1_set_input_edge_sensitivity(CMOCK_ppu_v1_set_input_edge_sensitivity_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity edge_sensitivity) +void CMockExpectParameters_ppu_v1_set_input_edge_sensitivity(CMOCK_ppu_v1_set_input_edge_sensitivity_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity edge_sensitivity); +void CMockExpectParameters_ppu_v1_set_input_edge_sensitivity(CMOCK_ppu_v1_set_input_edge_sensitivity_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity edge_sensitivity) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -5694,7 +5694,7 @@ void ppu_v1_set_input_edge_sensitivity_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_ cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_set_input_edge_sensitivity_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity edge_sensitivity) +void ppu_v1_set_input_edge_sensitivity_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity edge_sensitivity) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_set_input_edge_sensitivity_CALL_INSTANCE)); CMOCK_ppu_v1_set_input_edge_sensitivity_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_set_input_edge_sensitivity_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -5721,7 +5721,7 @@ void ppu_v1_set_input_edge_sensitivity_Stub(CMOCK_ppu_v1_set_input_edge_sensitiv Mock.ppu_v1_set_input_edge_sensitivity_CallbackFunctionPointer = Callback; } -void ppu_v1_set_input_edge_sensitivity_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity edge_sensitivity) +void ppu_v1_set_input_edge_sensitivity_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity edge_sensitivity) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_set_input_edge_sensitivity_CALL_INSTANCE)); CMOCK_ppu_v1_set_input_edge_sensitivity_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_set_input_edge_sensitivity_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -5734,7 +5734,7 @@ void ppu_v1_set_input_edge_sensitivity_CMockExpectWithArray(UNITY_LINE_TYPE cmoc CMockExpectParameters_ppu_v1_set_input_edge_sensitivity(cmock_call_instance, ppu, ppu_Depth, ppu_mode, edge_sensitivity); } -void ppu_v1_set_input_edge_sensitivity_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_set_input_edge_sensitivity_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_set_input_edge_sensitivity_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_set_input_edge_sensitivity_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_set_input_edge_sensitivity_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -5764,7 +5764,7 @@ void ppu_v1_set_input_edge_sensitivity_CMockIgnoreArg_edge_sensitivity(UNITY_LIN cmock_call_instance->IgnoreArg_edge_sensitivity = 1; } -enum ppu_v1_edge_sensitivity ppu_v1_get_input_edge_sensitivity(struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode) +enum ppu_v1_edge_sensitivity ppu_v1_get_input_edge_sensitivity(struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_get_input_edge_sensitivity_CALL_INSTANCE* cmock_call_instance; @@ -5797,7 +5797,7 @@ enum ppu_v1_edge_sensitivity ppu_v1_get_input_edge_sensitivity(struct ppu_v1_reg if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_ppu_mode) { @@ -5819,8 +5819,8 @@ enum ppu_v1_edge_sensitivity ppu_v1_get_input_edge_sensitivity(struct ppu_v1_reg return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_ppu_v1_get_input_edge_sensitivity(CMOCK_ppu_v1_get_input_edge_sensitivity_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode); -void CMockExpectParameters_ppu_v1_get_input_edge_sensitivity(CMOCK_ppu_v1_get_input_edge_sensitivity_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode) +void CMockExpectParameters_ppu_v1_get_input_edge_sensitivity(CMOCK_ppu_v1_get_input_edge_sensitivity_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode); +void CMockExpectParameters_ppu_v1_get_input_edge_sensitivity(CMOCK_ppu_v1_get_input_edge_sensitivity_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -5866,7 +5866,7 @@ void ppu_v1_get_input_edge_sensitivity_CMockExpectAnyArgsAndReturn(UNITY_LINE_TY cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_get_input_edge_sensitivity_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity cmock_to_return) +void ppu_v1_get_input_edge_sensitivity_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_get_input_edge_sensitivity_CALL_INSTANCE)); CMOCK_ppu_v1_get_input_edge_sensitivity_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_input_edge_sensitivity_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -5895,7 +5895,7 @@ void ppu_v1_get_input_edge_sensitivity_Stub(CMOCK_ppu_v1_get_input_edge_sensitiv Mock.ppu_v1_get_input_edge_sensitivity_CallbackFunctionPointer = Callback; } -void ppu_v1_get_input_edge_sensitivity_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity cmock_to_return) +void ppu_v1_get_input_edge_sensitivity_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_get_input_edge_sensitivity_CALL_INSTANCE)); CMOCK_ppu_v1_get_input_edge_sensitivity_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_input_edge_sensitivity_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -5909,7 +5909,7 @@ void ppu_v1_get_input_edge_sensitivity_CMockExpectWithArrayAndReturn(UNITY_LINE_ cmock_call_instance->ReturnVal = cmock_to_return; } -void ppu_v1_get_input_edge_sensitivity_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_get_input_edge_sensitivity_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_get_input_edge_sensitivity_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_input_edge_sensitivity_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_get_input_edge_sensitivity_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -5932,7 +5932,7 @@ void ppu_v1_get_input_edge_sensitivity_CMockIgnoreArg_ppu_mode(UNITY_LINE_TYPE c cmock_call_instance->IgnoreArg_ppu_mode = 1; } -void ppu_v1_ack_power_active_edge_interrupt(struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode) +void ppu_v1_ack_power_active_edge_interrupt(struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_ack_power_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance; @@ -5961,7 +5961,7 @@ void ppu_v1_ack_power_active_edge_interrupt(struct ppu_v1_reg* ppu, enum ppu_v1_ if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_ppu_mode) { @@ -5982,8 +5982,8 @@ void ppu_v1_ack_power_active_edge_interrupt(struct ppu_v1_reg* ppu, enum ppu_v1_ UNITY_CLR_DETAILS(); } -void CMockExpectParameters_ppu_v1_ack_power_active_edge_interrupt(CMOCK_ppu_v1_ack_power_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode); -void CMockExpectParameters_ppu_v1_ack_power_active_edge_interrupt(CMOCK_ppu_v1_ack_power_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode) +void CMockExpectParameters_ppu_v1_ack_power_active_edge_interrupt(CMOCK_ppu_v1_ack_power_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode); +void CMockExpectParameters_ppu_v1_ack_power_active_edge_interrupt(CMOCK_ppu_v1_ack_power_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -6017,7 +6017,7 @@ void ppu_v1_ack_power_active_edge_interrupt_CMockExpectAnyArgs(UNITY_LINE_TYPE c cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_ack_power_active_edge_interrupt_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode) +void ppu_v1_ack_power_active_edge_interrupt_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_ack_power_active_edge_interrupt_CALL_INSTANCE)); CMOCK_ppu_v1_ack_power_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_ack_power_active_edge_interrupt_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -6044,7 +6044,7 @@ void ppu_v1_ack_power_active_edge_interrupt_Stub(CMOCK_ppu_v1_ack_power_active_e Mock.ppu_v1_ack_power_active_edge_interrupt_CallbackFunctionPointer = Callback; } -void ppu_v1_ack_power_active_edge_interrupt_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode) +void ppu_v1_ack_power_active_edge_interrupt_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_ack_power_active_edge_interrupt_CALL_INSTANCE)); CMOCK_ppu_v1_ack_power_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_ack_power_active_edge_interrupt_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -6057,7 +6057,7 @@ void ppu_v1_ack_power_active_edge_interrupt_CMockExpectWithArray(UNITY_LINE_TYPE CMockExpectParameters_ppu_v1_ack_power_active_edge_interrupt(cmock_call_instance, ppu, ppu_Depth, ppu_mode); } -void ppu_v1_ack_power_active_edge_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_ack_power_active_edge_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_ack_power_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_ack_power_active_edge_interrupt_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_ack_power_active_edge_interrupt_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -6080,7 +6080,7 @@ void ppu_v1_ack_power_active_edge_interrupt_CMockIgnoreArg_ppu_mode(UNITY_LINE_T cmock_call_instance->IgnoreArg_ppu_mode = 1; } -bool ppu_v1_is_power_active_edge_interrupt(struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode) +bool ppu_v1_is_power_active_edge_interrupt(struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_is_power_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance; @@ -6112,7 +6112,7 @@ bool ppu_v1_is_power_active_edge_interrupt(struct ppu_v1_reg* ppu, enum ppu_v1_m if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_ppu_mode) { @@ -6134,8 +6134,8 @@ bool ppu_v1_is_power_active_edge_interrupt(struct ppu_v1_reg* ppu, enum ppu_v1_m return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_ppu_v1_is_power_active_edge_interrupt(CMOCK_ppu_v1_is_power_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode); -void CMockExpectParameters_ppu_v1_is_power_active_edge_interrupt(CMOCK_ppu_v1_is_power_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode) +void CMockExpectParameters_ppu_v1_is_power_active_edge_interrupt(CMOCK_ppu_v1_is_power_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode); +void CMockExpectParameters_ppu_v1_is_power_active_edge_interrupt(CMOCK_ppu_v1_is_power_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -6181,7 +6181,7 @@ void ppu_v1_is_power_active_edge_interrupt_CMockExpectAnyArgsAndReturn(UNITY_LIN cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_is_power_active_edge_interrupt_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, bool cmock_to_return) +void ppu_v1_is_power_active_edge_interrupt_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode, bool cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_is_power_active_edge_interrupt_CALL_INSTANCE)); CMOCK_ppu_v1_is_power_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_power_active_edge_interrupt_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -6209,7 +6209,7 @@ void ppu_v1_is_power_active_edge_interrupt_Stub(CMOCK_ppu_v1_is_power_active_edg Mock.ppu_v1_is_power_active_edge_interrupt_CallbackFunctionPointer = Callback; } -void ppu_v1_is_power_active_edge_interrupt_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, bool cmock_to_return) +void ppu_v1_is_power_active_edge_interrupt_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, bool cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_is_power_active_edge_interrupt_CALL_INSTANCE)); CMOCK_ppu_v1_is_power_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_power_active_edge_interrupt_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -6223,7 +6223,7 @@ void ppu_v1_is_power_active_edge_interrupt_CMockExpectWithArrayAndReturn(UNITY_L cmock_call_instance->ReturnVal = cmock_to_return; } -void ppu_v1_is_power_active_edge_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_is_power_active_edge_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_is_power_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_power_active_edge_interrupt_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_is_power_active_edge_interrupt_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -6246,7 +6246,7 @@ void ppu_v1_is_power_active_edge_interrupt_CMockIgnoreArg_ppu_mode(UNITY_LINE_TY cmock_call_instance->IgnoreArg_ppu_mode = 1; } -void ppu_v1_set_op_active_edge_sensitivity(struct ppu_v1_reg* ppu, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity edge_sensitivity) +void ppu_v1_set_op_active_edge_sensitivity(struct ppu_v1_regs* ppu, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity edge_sensitivity) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_set_op_active_edge_sensitivity_CALL_INSTANCE* cmock_call_instance; @@ -6275,7 +6275,7 @@ void ppu_v1_set_op_active_edge_sensitivity(struct ppu_v1_reg* ppu, enum ppu_v1_o if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_op_devactive) { @@ -6301,8 +6301,8 @@ void ppu_v1_set_op_active_edge_sensitivity(struct ppu_v1_reg* ppu, enum ppu_v1_o UNITY_CLR_DETAILS(); } -void CMockExpectParameters_ppu_v1_set_op_active_edge_sensitivity(CMOCK_ppu_v1_set_op_active_edge_sensitivity_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity edge_sensitivity); -void CMockExpectParameters_ppu_v1_set_op_active_edge_sensitivity(CMOCK_ppu_v1_set_op_active_edge_sensitivity_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity edge_sensitivity) +void CMockExpectParameters_ppu_v1_set_op_active_edge_sensitivity(CMOCK_ppu_v1_set_op_active_edge_sensitivity_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity edge_sensitivity); +void CMockExpectParameters_ppu_v1_set_op_active_edge_sensitivity(CMOCK_ppu_v1_set_op_active_edge_sensitivity_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity edge_sensitivity) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -6339,7 +6339,7 @@ void ppu_v1_set_op_active_edge_sensitivity_CMockExpectAnyArgs(UNITY_LINE_TYPE cm cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_set_op_active_edge_sensitivity_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity edge_sensitivity) +void ppu_v1_set_op_active_edge_sensitivity_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity edge_sensitivity) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_set_op_active_edge_sensitivity_CALL_INSTANCE)); CMOCK_ppu_v1_set_op_active_edge_sensitivity_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_set_op_active_edge_sensitivity_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -6366,7 +6366,7 @@ void ppu_v1_set_op_active_edge_sensitivity_Stub(CMOCK_ppu_v1_set_op_active_edge_ Mock.ppu_v1_set_op_active_edge_sensitivity_CallbackFunctionPointer = Callback; } -void ppu_v1_set_op_active_edge_sensitivity_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity edge_sensitivity) +void ppu_v1_set_op_active_edge_sensitivity_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity edge_sensitivity) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_set_op_active_edge_sensitivity_CALL_INSTANCE)); CMOCK_ppu_v1_set_op_active_edge_sensitivity_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_set_op_active_edge_sensitivity_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -6379,7 +6379,7 @@ void ppu_v1_set_op_active_edge_sensitivity_CMockExpectWithArray(UNITY_LINE_TYPE CMockExpectParameters_ppu_v1_set_op_active_edge_sensitivity(cmock_call_instance, ppu, ppu_Depth, op_devactive, edge_sensitivity); } -void ppu_v1_set_op_active_edge_sensitivity_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_set_op_active_edge_sensitivity_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_set_op_active_edge_sensitivity_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_set_op_active_edge_sensitivity_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_set_op_active_edge_sensitivity_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -6409,7 +6409,7 @@ void ppu_v1_set_op_active_edge_sensitivity_CMockIgnoreArg_edge_sensitivity(UNITY cmock_call_instance->IgnoreArg_edge_sensitivity = 1; } -enum ppu_v1_edge_sensitivity ppu_v1_get_op_active_edge_sensitivity(struct ppu_v1_reg* ppu, enum ppu_v1_op_devactive op_devactive) +enum ppu_v1_edge_sensitivity ppu_v1_get_op_active_edge_sensitivity(struct ppu_v1_regs* ppu, enum ppu_v1_op_devactive op_devactive) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_get_op_active_edge_sensitivity_CALL_INSTANCE* cmock_call_instance; @@ -6442,7 +6442,7 @@ enum ppu_v1_edge_sensitivity ppu_v1_get_op_active_edge_sensitivity(struct ppu_v1 if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_op_devactive) { @@ -6464,8 +6464,8 @@ enum ppu_v1_edge_sensitivity ppu_v1_get_op_active_edge_sensitivity(struct ppu_v1 return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_ppu_v1_get_op_active_edge_sensitivity(CMOCK_ppu_v1_get_op_active_edge_sensitivity_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive); -void CMockExpectParameters_ppu_v1_get_op_active_edge_sensitivity(CMOCK_ppu_v1_get_op_active_edge_sensitivity_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive) +void CMockExpectParameters_ppu_v1_get_op_active_edge_sensitivity(CMOCK_ppu_v1_get_op_active_edge_sensitivity_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive); +void CMockExpectParameters_ppu_v1_get_op_active_edge_sensitivity(CMOCK_ppu_v1_get_op_active_edge_sensitivity_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -6511,7 +6511,7 @@ void ppu_v1_get_op_active_edge_sensitivity_CMockExpectAnyArgsAndReturn(UNITY_LIN cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_get_op_active_edge_sensitivity_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity cmock_to_return) +void ppu_v1_get_op_active_edge_sensitivity_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_get_op_active_edge_sensitivity_CALL_INSTANCE)); CMOCK_ppu_v1_get_op_active_edge_sensitivity_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_op_active_edge_sensitivity_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -6540,7 +6540,7 @@ void ppu_v1_get_op_active_edge_sensitivity_Stub(CMOCK_ppu_v1_get_op_active_edge_ Mock.ppu_v1_get_op_active_edge_sensitivity_CallbackFunctionPointer = Callback; } -void ppu_v1_get_op_active_edge_sensitivity_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity cmock_to_return) +void ppu_v1_get_op_active_edge_sensitivity_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_get_op_active_edge_sensitivity_CALL_INSTANCE)); CMOCK_ppu_v1_get_op_active_edge_sensitivity_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_op_active_edge_sensitivity_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -6554,7 +6554,7 @@ void ppu_v1_get_op_active_edge_sensitivity_CMockExpectWithArrayAndReturn(UNITY_L cmock_call_instance->ReturnVal = cmock_to_return; } -void ppu_v1_get_op_active_edge_sensitivity_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_get_op_active_edge_sensitivity_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_get_op_active_edge_sensitivity_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_op_active_edge_sensitivity_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_get_op_active_edge_sensitivity_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -6577,7 +6577,7 @@ void ppu_v1_get_op_active_edge_sensitivity_CMockIgnoreArg_op_devactive(UNITY_LIN cmock_call_instance->IgnoreArg_op_devactive = 1; } -void ppu_v1_ack_op_active_edge_interrupt(struct ppu_v1_reg* ppu, enum ppu_v1_op_devactive op_devactive) +void ppu_v1_ack_op_active_edge_interrupt(struct ppu_v1_regs* ppu, enum ppu_v1_op_devactive op_devactive) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_ack_op_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance; @@ -6606,7 +6606,7 @@ void ppu_v1_ack_op_active_edge_interrupt(struct ppu_v1_reg* ppu, enum ppu_v1_op_ if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_op_devactive) { @@ -6627,8 +6627,8 @@ void ppu_v1_ack_op_active_edge_interrupt(struct ppu_v1_reg* ppu, enum ppu_v1_op_ UNITY_CLR_DETAILS(); } -void CMockExpectParameters_ppu_v1_ack_op_active_edge_interrupt(CMOCK_ppu_v1_ack_op_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive); -void CMockExpectParameters_ppu_v1_ack_op_active_edge_interrupt(CMOCK_ppu_v1_ack_op_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive) +void CMockExpectParameters_ppu_v1_ack_op_active_edge_interrupt(CMOCK_ppu_v1_ack_op_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive); +void CMockExpectParameters_ppu_v1_ack_op_active_edge_interrupt(CMOCK_ppu_v1_ack_op_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -6662,7 +6662,7 @@ void ppu_v1_ack_op_active_edge_interrupt_CMockExpectAnyArgs(UNITY_LINE_TYPE cmoc cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_ack_op_active_edge_interrupt_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_op_devactive op_devactive) +void ppu_v1_ack_op_active_edge_interrupt_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_op_devactive op_devactive) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_ack_op_active_edge_interrupt_CALL_INSTANCE)); CMOCK_ppu_v1_ack_op_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_ack_op_active_edge_interrupt_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -6689,7 +6689,7 @@ void ppu_v1_ack_op_active_edge_interrupt_Stub(CMOCK_ppu_v1_ack_op_active_edge_in Mock.ppu_v1_ack_op_active_edge_interrupt_CallbackFunctionPointer = Callback; } -void ppu_v1_ack_op_active_edge_interrupt_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive) +void ppu_v1_ack_op_active_edge_interrupt_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_ack_op_active_edge_interrupt_CALL_INSTANCE)); CMOCK_ppu_v1_ack_op_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_ack_op_active_edge_interrupt_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -6702,7 +6702,7 @@ void ppu_v1_ack_op_active_edge_interrupt_CMockExpectWithArray(UNITY_LINE_TYPE cm CMockExpectParameters_ppu_v1_ack_op_active_edge_interrupt(cmock_call_instance, ppu, ppu_Depth, op_devactive); } -void ppu_v1_ack_op_active_edge_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_ack_op_active_edge_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_ack_op_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_ack_op_active_edge_interrupt_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_ack_op_active_edge_interrupt_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -6725,7 +6725,7 @@ void ppu_v1_ack_op_active_edge_interrupt_CMockIgnoreArg_op_devactive(UNITY_LINE_ cmock_call_instance->IgnoreArg_op_devactive = 1; } -bool ppu_v1_is_op_active_edge_interrupt(struct ppu_v1_reg* ppu, enum ppu_v1_op_devactive op_devactive) +bool ppu_v1_is_op_active_edge_interrupt(struct ppu_v1_regs* ppu, enum ppu_v1_op_devactive op_devactive) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_is_op_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance; @@ -6757,7 +6757,7 @@ bool ppu_v1_is_op_active_edge_interrupt(struct ppu_v1_reg* ppu, enum ppu_v1_op_d if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_op_devactive) { @@ -6779,8 +6779,8 @@ bool ppu_v1_is_op_active_edge_interrupt(struct ppu_v1_reg* ppu, enum ppu_v1_op_d return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_ppu_v1_is_op_active_edge_interrupt(CMOCK_ppu_v1_is_op_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive); -void CMockExpectParameters_ppu_v1_is_op_active_edge_interrupt(CMOCK_ppu_v1_is_op_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive) +void CMockExpectParameters_ppu_v1_is_op_active_edge_interrupt(CMOCK_ppu_v1_is_op_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive); +void CMockExpectParameters_ppu_v1_is_op_active_edge_interrupt(CMOCK_ppu_v1_is_op_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -6826,7 +6826,7 @@ void ppu_v1_is_op_active_edge_interrupt_CMockExpectAnyArgsAndReturn(UNITY_LINE_T cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_is_op_active_edge_interrupt_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_op_devactive op_devactive, bool cmock_to_return) +void ppu_v1_is_op_active_edge_interrupt_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_op_devactive op_devactive, bool cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_is_op_active_edge_interrupt_CALL_INSTANCE)); CMOCK_ppu_v1_is_op_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_op_active_edge_interrupt_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -6854,7 +6854,7 @@ void ppu_v1_is_op_active_edge_interrupt_Stub(CMOCK_ppu_v1_is_op_active_edge_inte Mock.ppu_v1_is_op_active_edge_interrupt_CallbackFunctionPointer = Callback; } -void ppu_v1_is_op_active_edge_interrupt_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive, bool cmock_to_return) +void ppu_v1_is_op_active_edge_interrupt_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive, bool cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_is_op_active_edge_interrupt_CALL_INSTANCE)); CMOCK_ppu_v1_is_op_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_op_active_edge_interrupt_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -6868,7 +6868,7 @@ void ppu_v1_is_op_active_edge_interrupt_CMockExpectWithArrayAndReturn(UNITY_LINE cmock_call_instance->ReturnVal = cmock_to_return; } -void ppu_v1_is_op_active_edge_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_is_op_active_edge_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_is_op_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_op_active_edge_interrupt_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_is_op_active_edge_interrupt_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -6891,7 +6891,7 @@ void ppu_v1_is_op_active_edge_interrupt_CMockIgnoreArg_op_devactive(UNITY_LINE_T cmock_call_instance->IgnoreArg_op_devactive = 1; } -bool ppu_v1_is_dyn_policy_min_interrupt(struct ppu_v1_reg* ppu) +bool ppu_v1_is_dyn_policy_min_interrupt(struct ppu_v1_regs* ppu) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_is_dyn_policy_min_interrupt_CALL_INSTANCE* cmock_call_instance; @@ -6923,7 +6923,7 @@ bool ppu_v1_is_dyn_policy_min_interrupt(struct ppu_v1_reg* ppu) if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } } if (Mock.ppu_v1_is_dyn_policy_min_interrupt_CallbackFunctionPointer != NULL) @@ -6940,8 +6940,8 @@ bool ppu_v1_is_dyn_policy_min_interrupt(struct ppu_v1_reg* ppu) return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_ppu_v1_is_dyn_policy_min_interrupt(CMOCK_ppu_v1_is_dyn_policy_min_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth); -void CMockExpectParameters_ppu_v1_is_dyn_policy_min_interrupt(CMOCK_ppu_v1_is_dyn_policy_min_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth) +void CMockExpectParameters_ppu_v1_is_dyn_policy_min_interrupt(CMOCK_ppu_v1_is_dyn_policy_min_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth); +void CMockExpectParameters_ppu_v1_is_dyn_policy_min_interrupt(CMOCK_ppu_v1_is_dyn_policy_min_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -6984,7 +6984,7 @@ void ppu_v1_is_dyn_policy_min_interrupt_CMockExpectAnyArgsAndReturn(UNITY_LINE_T cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_is_dyn_policy_min_interrupt_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, bool cmock_to_return) +void ppu_v1_is_dyn_policy_min_interrupt_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, bool cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_is_dyn_policy_min_interrupt_CALL_INSTANCE)); CMOCK_ppu_v1_is_dyn_policy_min_interrupt_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_dyn_policy_min_interrupt_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -7012,7 +7012,7 @@ void ppu_v1_is_dyn_policy_min_interrupt_Stub(CMOCK_ppu_v1_is_dyn_policy_min_inte Mock.ppu_v1_is_dyn_policy_min_interrupt_CallbackFunctionPointer = Callback; } -void ppu_v1_is_dyn_policy_min_interrupt_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, bool cmock_to_return) +void ppu_v1_is_dyn_policy_min_interrupt_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, bool cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_is_dyn_policy_min_interrupt_CALL_INSTANCE)); CMOCK_ppu_v1_is_dyn_policy_min_interrupt_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_dyn_policy_min_interrupt_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -7026,7 +7026,7 @@ void ppu_v1_is_dyn_policy_min_interrupt_CMockExpectWithArrayAndReturn(UNITY_LINE cmock_call_instance->ReturnVal = cmock_to_return; } -void ppu_v1_is_dyn_policy_min_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_is_dyn_policy_min_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_is_dyn_policy_min_interrupt_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_dyn_policy_min_interrupt_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_is_dyn_policy_min_interrupt_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -7042,7 +7042,7 @@ void ppu_v1_is_dyn_policy_min_interrupt_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock cmock_call_instance->IgnoreArg_ppu = 1; } -unsigned int ppu_v1_get_num_opmode(struct ppu_v1_reg* ppu) +unsigned int ppu_v1_get_num_opmode(struct ppu_v1_regs* ppu) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_get_num_opmode_CALL_INSTANCE* cmock_call_instance; @@ -7074,7 +7074,7 @@ unsigned int ppu_v1_get_num_opmode(struct ppu_v1_reg* ppu) if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } } if (Mock.ppu_v1_get_num_opmode_CallbackFunctionPointer != NULL) @@ -7091,8 +7091,8 @@ unsigned int ppu_v1_get_num_opmode(struct ppu_v1_reg* ppu) return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_ppu_v1_get_num_opmode(CMOCK_ppu_v1_get_num_opmode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth); -void CMockExpectParameters_ppu_v1_get_num_opmode(CMOCK_ppu_v1_get_num_opmode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth) +void CMockExpectParameters_ppu_v1_get_num_opmode(CMOCK_ppu_v1_get_num_opmode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth); +void CMockExpectParameters_ppu_v1_get_num_opmode(CMOCK_ppu_v1_get_num_opmode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -7135,7 +7135,7 @@ void ppu_v1_get_num_opmode_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_lin cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_get_num_opmode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, unsigned int cmock_to_return) +void ppu_v1_get_num_opmode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, unsigned int cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_get_num_opmode_CALL_INSTANCE)); CMOCK_ppu_v1_get_num_opmode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_num_opmode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -7163,7 +7163,7 @@ void ppu_v1_get_num_opmode_Stub(CMOCK_ppu_v1_get_num_opmode_CALLBACK Callback) Mock.ppu_v1_get_num_opmode_CallbackFunctionPointer = Callback; } -void ppu_v1_get_num_opmode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int cmock_to_return) +void ppu_v1_get_num_opmode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_get_num_opmode_CALL_INSTANCE)); CMOCK_ppu_v1_get_num_opmode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_num_opmode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -7177,7 +7177,7 @@ void ppu_v1_get_num_opmode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_l cmock_call_instance->ReturnVal = cmock_to_return; } -void ppu_v1_get_num_opmode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_get_num_opmode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_get_num_opmode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_num_opmode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_get_num_opmode_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -7193,7 +7193,7 @@ void ppu_v1_get_num_opmode_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line) cmock_call_instance->IgnoreArg_ppu = 1; } -unsigned int ppu_v1_get_arch_id(struct ppu_v1_reg* ppu) +unsigned int ppu_v1_get_arch_id(struct ppu_v1_regs* ppu) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_get_arch_id_CALL_INSTANCE* cmock_call_instance; @@ -7225,7 +7225,7 @@ unsigned int ppu_v1_get_arch_id(struct ppu_v1_reg* ppu) if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } } if (Mock.ppu_v1_get_arch_id_CallbackFunctionPointer != NULL) @@ -7242,8 +7242,8 @@ unsigned int ppu_v1_get_arch_id(struct ppu_v1_reg* ppu) return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_ppu_v1_get_arch_id(CMOCK_ppu_v1_get_arch_id_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth); -void CMockExpectParameters_ppu_v1_get_arch_id(CMOCK_ppu_v1_get_arch_id_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth) +void CMockExpectParameters_ppu_v1_get_arch_id(CMOCK_ppu_v1_get_arch_id_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth); +void CMockExpectParameters_ppu_v1_get_arch_id(CMOCK_ppu_v1_get_arch_id_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -7286,7 +7286,7 @@ void ppu_v1_get_arch_id_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_get_arch_id_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, unsigned int cmock_to_return) +void ppu_v1_get_arch_id_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, unsigned int cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_get_arch_id_CALL_INSTANCE)); CMOCK_ppu_v1_get_arch_id_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_arch_id_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -7314,7 +7314,7 @@ void ppu_v1_get_arch_id_Stub(CMOCK_ppu_v1_get_arch_id_CALLBACK Callback) Mock.ppu_v1_get_arch_id_CallbackFunctionPointer = Callback; } -void ppu_v1_get_arch_id_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int cmock_to_return) +void ppu_v1_get_arch_id_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_get_arch_id_CALL_INSTANCE)); CMOCK_ppu_v1_get_arch_id_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_arch_id_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -7328,7 +7328,7 @@ void ppu_v1_get_arch_id_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line cmock_call_instance->ReturnVal = cmock_to_return; } -void ppu_v1_get_arch_id_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_get_arch_id_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_get_arch_id_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_arch_id_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_get_arch_id_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); diff --git a/module/ppu_v1/test/mocks/Mockmod_ppu_v1_extra.h b/module/ppu_v1/test/mocks/Mockmod_ppu_v1_extra.h index cc5119169..d4859e9e7 100644 --- a/module/ppu_v1/test/mocks/Mockmod_ppu_v1_extra.h +++ b/module/ppu_v1/test/mocks/Mockmod_ppu_v1_extra.h @@ -68,17 +68,17 @@ void ppu_v1_init_CMockStopIgnore(void); #define ppu_v1_init_ExpectAnyArgs() ppu_v1_init_CMockExpectAnyArgs(__LINE__) void ppu_v1_init_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); #define ppu_v1_init_Expect(ppu) ppu_v1_init_CMockExpect(__LINE__, ppu) -void ppu_v1_init_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu); -typedef void (* CMOCK_ppu_v1_init_CALLBACK)(struct ppu_v1_reg* ppu, int cmock_num_calls); +void ppu_v1_init_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu); +typedef void (* CMOCK_ppu_v1_init_CALLBACK)(struct ppu_v1_regs* ppu, int cmock_num_calls); void ppu_v1_init_AddCallback(CMOCK_ppu_v1_init_CALLBACK Callback); void ppu_v1_init_Stub(CMOCK_ppu_v1_init_CALLBACK Callback); #define ppu_v1_init_StubWithCallback ppu_v1_init_Stub #define ppu_v1_init_ExpectWithArray(ppu, ppu_Depth) ppu_v1_init_CMockExpectWithArray(__LINE__, ppu, ppu_Depth) -void ppu_v1_init_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth); -#define ppu_v1_init_ReturnThruPtr_ppu(ppu) ppu_v1_init_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_init_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth); +#define ppu_v1_init_ReturnThruPtr_ppu(ppu) ppu_v1_init_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_init_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_init_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_init_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_init_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_init_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_init_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_init_IgnoreArg_ppu() ppu_v1_init_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_init_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_set_power_mode_IgnoreAndReturn(cmock_retval) ppu_v1_set_power_mode_CMockIgnoreAndReturn(__LINE__, cmock_retval) @@ -88,17 +88,17 @@ void ppu_v1_set_power_mode_CMockStopIgnore(void); #define ppu_v1_set_power_mode_ExpectAnyArgsAndReturn(cmock_retval) ppu_v1_set_power_mode_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) void ppu_v1_set_power_mode_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); #define ppu_v1_set_power_mode_ExpectAndReturn(ppu, ppu_mode, timer_ctx, cmock_retval) ppu_v1_set_power_mode_CMockExpectAndReturn(__LINE__, ppu, ppu_mode, timer_ctx, cmock_retval) -void ppu_v1_set_power_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, struct ppu_v1_timer_ctx* timer_ctx, int cmock_to_return); -typedef int (* CMOCK_ppu_v1_set_power_mode_CALLBACK)(struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, struct ppu_v1_timer_ctx* timer_ctx, int cmock_num_calls); +void ppu_v1_set_power_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode, struct ppu_v1_timer_ctx* timer_ctx, int cmock_to_return); +typedef int (* CMOCK_ppu_v1_set_power_mode_CALLBACK)(struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode, struct ppu_v1_timer_ctx* timer_ctx, int cmock_num_calls); void ppu_v1_set_power_mode_AddCallback(CMOCK_ppu_v1_set_power_mode_CALLBACK Callback); void ppu_v1_set_power_mode_Stub(CMOCK_ppu_v1_set_power_mode_CALLBACK Callback); #define ppu_v1_set_power_mode_StubWithCallback ppu_v1_set_power_mode_Stub #define ppu_v1_set_power_mode_ExpectWithArrayAndReturn(ppu, ppu_Depth, ppu_mode, timer_ctx, timer_ctx_Depth, cmock_retval) ppu_v1_set_power_mode_CMockExpectWithArrayAndReturn(__LINE__, ppu, ppu_Depth, ppu_mode, timer_ctx, timer_ctx_Depth, cmock_retval) -void ppu_v1_set_power_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, struct ppu_v1_timer_ctx* timer_ctx, int timer_ctx_Depth, int cmock_to_return); -#define ppu_v1_set_power_mode_ReturnThruPtr_ppu(ppu) ppu_v1_set_power_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_set_power_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, struct ppu_v1_timer_ctx* timer_ctx, int timer_ctx_Depth, int cmock_to_return); +#define ppu_v1_set_power_mode_ReturnThruPtr_ppu(ppu) ppu_v1_set_power_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_set_power_mode_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_set_power_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_set_power_mode_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_set_power_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_set_power_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_set_power_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_set_power_mode_ReturnThruPtr_timer_ctx(timer_ctx) ppu_v1_set_power_mode_CMockReturnMemThruPtr_timer_ctx(__LINE__, timer_ctx, sizeof(struct ppu_v1_timer_ctx)) #define ppu_v1_set_power_mode_ReturnArrayThruPtr_timer_ctx(timer_ctx, cmock_len) ppu_v1_set_power_mode_CMockReturnMemThruPtr_timer_ctx(__LINE__, timer_ctx, cmock_len * sizeof(*timer_ctx)) #define ppu_v1_set_power_mode_ReturnMemThruPtr_timer_ctx(timer_ctx, cmock_size) ppu_v1_set_power_mode_CMockReturnMemThruPtr_timer_ctx(__LINE__, timer_ctx, cmock_size) @@ -116,17 +116,17 @@ void ppu_v1_request_power_mode_CMockStopIgnore(void); #define ppu_v1_request_power_mode_ExpectAnyArgsAndReturn(cmock_retval) ppu_v1_request_power_mode_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) void ppu_v1_request_power_mode_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); #define ppu_v1_request_power_mode_ExpectAndReturn(ppu, ppu_mode, cmock_retval) ppu_v1_request_power_mode_CMockExpectAndReturn(__LINE__, ppu, ppu_mode, cmock_retval) -void ppu_v1_request_power_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, int cmock_to_return); -typedef int (* CMOCK_ppu_v1_request_power_mode_CALLBACK)(struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, int cmock_num_calls); +void ppu_v1_request_power_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode, int cmock_to_return); +typedef int (* CMOCK_ppu_v1_request_power_mode_CALLBACK)(struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode, int cmock_num_calls); void ppu_v1_request_power_mode_AddCallback(CMOCK_ppu_v1_request_power_mode_CALLBACK Callback); void ppu_v1_request_power_mode_Stub(CMOCK_ppu_v1_request_power_mode_CALLBACK Callback); #define ppu_v1_request_power_mode_StubWithCallback ppu_v1_request_power_mode_Stub #define ppu_v1_request_power_mode_ExpectWithArrayAndReturn(ppu, ppu_Depth, ppu_mode, cmock_retval) ppu_v1_request_power_mode_CMockExpectWithArrayAndReturn(__LINE__, ppu, ppu_Depth, ppu_mode, cmock_retval) -void ppu_v1_request_power_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, int cmock_to_return); -#define ppu_v1_request_power_mode_ReturnThruPtr_ppu(ppu) ppu_v1_request_power_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_request_power_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, int cmock_to_return); +#define ppu_v1_request_power_mode_ReturnThruPtr_ppu(ppu) ppu_v1_request_power_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_request_power_mode_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_request_power_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_request_power_mode_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_request_power_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_request_power_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_request_power_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_request_power_mode_IgnoreArg_ppu() ppu_v1_request_power_mode_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_request_power_mode_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_request_power_mode_IgnoreArg_ppu_mode() ppu_v1_request_power_mode_CMockIgnoreArg_ppu_mode(__LINE__) @@ -138,17 +138,17 @@ void ppu_v1_request_operating_mode_CMockStopIgnore(void); #define ppu_v1_request_operating_mode_ExpectAnyArgsAndReturn(cmock_retval) ppu_v1_request_operating_mode_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) void ppu_v1_request_operating_mode_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); #define ppu_v1_request_operating_mode_ExpectAndReturn(ppu, op_mode, cmock_retval) ppu_v1_request_operating_mode_CMockExpectAndReturn(__LINE__, ppu, op_mode, cmock_retval) -void ppu_v1_request_operating_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_opmode op_mode, int cmock_to_return); -typedef int (* CMOCK_ppu_v1_request_operating_mode_CALLBACK)(struct ppu_v1_reg* ppu, enum ppu_v1_opmode op_mode, int cmock_num_calls); +void ppu_v1_request_operating_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_opmode op_mode, int cmock_to_return); +typedef int (* CMOCK_ppu_v1_request_operating_mode_CALLBACK)(struct ppu_v1_regs* ppu, enum ppu_v1_opmode op_mode, int cmock_num_calls); void ppu_v1_request_operating_mode_AddCallback(CMOCK_ppu_v1_request_operating_mode_CALLBACK Callback); void ppu_v1_request_operating_mode_Stub(CMOCK_ppu_v1_request_operating_mode_CALLBACK Callback); #define ppu_v1_request_operating_mode_StubWithCallback ppu_v1_request_operating_mode_Stub #define ppu_v1_request_operating_mode_ExpectWithArrayAndReturn(ppu, ppu_Depth, op_mode, cmock_retval) ppu_v1_request_operating_mode_CMockExpectWithArrayAndReturn(__LINE__, ppu, ppu_Depth, op_mode, cmock_retval) -void ppu_v1_request_operating_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_opmode op_mode, int cmock_to_return); -#define ppu_v1_request_operating_mode_ReturnThruPtr_ppu(ppu) ppu_v1_request_operating_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_request_operating_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_opmode op_mode, int cmock_to_return); +#define ppu_v1_request_operating_mode_ReturnThruPtr_ppu(ppu) ppu_v1_request_operating_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_request_operating_mode_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_request_operating_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_request_operating_mode_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_request_operating_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_request_operating_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_request_operating_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_request_operating_mode_IgnoreArg_ppu() ppu_v1_request_operating_mode_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_request_operating_mode_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_request_operating_mode_IgnoreArg_op_mode() ppu_v1_request_operating_mode_CMockIgnoreArg_op_mode(__LINE__) @@ -160,17 +160,17 @@ void ppu_v1_opmode_dynamic_enable_CMockStopIgnore(void); #define ppu_v1_opmode_dynamic_enable_ExpectAnyArgs() ppu_v1_opmode_dynamic_enable_CMockExpectAnyArgs(__LINE__) void ppu_v1_opmode_dynamic_enable_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); #define ppu_v1_opmode_dynamic_enable_Expect(ppu, min_dyn_mode) ppu_v1_opmode_dynamic_enable_CMockExpect(__LINE__, ppu, min_dyn_mode) -void ppu_v1_opmode_dynamic_enable_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_opmode min_dyn_mode); -typedef void (* CMOCK_ppu_v1_opmode_dynamic_enable_CALLBACK)(struct ppu_v1_reg* ppu, enum ppu_v1_opmode min_dyn_mode, int cmock_num_calls); +void ppu_v1_opmode_dynamic_enable_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_opmode min_dyn_mode); +typedef void (* CMOCK_ppu_v1_opmode_dynamic_enable_CALLBACK)(struct ppu_v1_regs* ppu, enum ppu_v1_opmode min_dyn_mode, int cmock_num_calls); void ppu_v1_opmode_dynamic_enable_AddCallback(CMOCK_ppu_v1_opmode_dynamic_enable_CALLBACK Callback); void ppu_v1_opmode_dynamic_enable_Stub(CMOCK_ppu_v1_opmode_dynamic_enable_CALLBACK Callback); #define ppu_v1_opmode_dynamic_enable_StubWithCallback ppu_v1_opmode_dynamic_enable_Stub #define ppu_v1_opmode_dynamic_enable_ExpectWithArray(ppu, ppu_Depth, min_dyn_mode) ppu_v1_opmode_dynamic_enable_CMockExpectWithArray(__LINE__, ppu, ppu_Depth, min_dyn_mode) -void ppu_v1_opmode_dynamic_enable_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_opmode min_dyn_mode); -#define ppu_v1_opmode_dynamic_enable_ReturnThruPtr_ppu(ppu) ppu_v1_opmode_dynamic_enable_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_opmode_dynamic_enable_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_opmode min_dyn_mode); +#define ppu_v1_opmode_dynamic_enable_ReturnThruPtr_ppu(ppu) ppu_v1_opmode_dynamic_enable_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_opmode_dynamic_enable_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_opmode_dynamic_enable_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_opmode_dynamic_enable_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_opmode_dynamic_enable_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_opmode_dynamic_enable_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_opmode_dynamic_enable_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_opmode_dynamic_enable_IgnoreArg_ppu() ppu_v1_opmode_dynamic_enable_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_opmode_dynamic_enable_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_opmode_dynamic_enable_IgnoreArg_min_dyn_mode() ppu_v1_opmode_dynamic_enable_CMockIgnoreArg_min_dyn_mode(__LINE__) @@ -182,17 +182,17 @@ void ppu_v1_dynamic_enable_CMockStopIgnore(void); #define ppu_v1_dynamic_enable_ExpectAnyArgs() ppu_v1_dynamic_enable_CMockExpectAnyArgs(__LINE__) void ppu_v1_dynamic_enable_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); #define ppu_v1_dynamic_enable_Expect(ppu, min_dyn_state) ppu_v1_dynamic_enable_CMockExpect(__LINE__, ppu, min_dyn_state) -void ppu_v1_dynamic_enable_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_mode min_dyn_state); -typedef void (* CMOCK_ppu_v1_dynamic_enable_CALLBACK)(struct ppu_v1_reg* ppu, enum ppu_v1_mode min_dyn_state, int cmock_num_calls); +void ppu_v1_dynamic_enable_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_mode min_dyn_state); +typedef void (* CMOCK_ppu_v1_dynamic_enable_CALLBACK)(struct ppu_v1_regs* ppu, enum ppu_v1_mode min_dyn_state, int cmock_num_calls); void ppu_v1_dynamic_enable_AddCallback(CMOCK_ppu_v1_dynamic_enable_CALLBACK Callback); void ppu_v1_dynamic_enable_Stub(CMOCK_ppu_v1_dynamic_enable_CALLBACK Callback); #define ppu_v1_dynamic_enable_StubWithCallback ppu_v1_dynamic_enable_Stub #define ppu_v1_dynamic_enable_ExpectWithArray(ppu, ppu_Depth, min_dyn_state) ppu_v1_dynamic_enable_CMockExpectWithArray(__LINE__, ppu, ppu_Depth, min_dyn_state) -void ppu_v1_dynamic_enable_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode min_dyn_state); -#define ppu_v1_dynamic_enable_ReturnThruPtr_ppu(ppu) ppu_v1_dynamic_enable_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_dynamic_enable_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode min_dyn_state); +#define ppu_v1_dynamic_enable_ReturnThruPtr_ppu(ppu) ppu_v1_dynamic_enable_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_dynamic_enable_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_dynamic_enable_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_dynamic_enable_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_dynamic_enable_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_dynamic_enable_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_dynamic_enable_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_dynamic_enable_IgnoreArg_ppu() ppu_v1_dynamic_enable_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_dynamic_enable_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_dynamic_enable_IgnoreArg_min_dyn_state() ppu_v1_dynamic_enable_CMockIgnoreArg_min_dyn_state(__LINE__) @@ -204,17 +204,17 @@ void ppu_v1_lock_off_enable_CMockStopIgnore(void); #define ppu_v1_lock_off_enable_ExpectAnyArgs() ppu_v1_lock_off_enable_CMockExpectAnyArgs(__LINE__) void ppu_v1_lock_off_enable_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); #define ppu_v1_lock_off_enable_Expect(ppu) ppu_v1_lock_off_enable_CMockExpect(__LINE__, ppu) -void ppu_v1_lock_off_enable_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu); -typedef void (* CMOCK_ppu_v1_lock_off_enable_CALLBACK)(struct ppu_v1_reg* ppu, int cmock_num_calls); +void ppu_v1_lock_off_enable_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu); +typedef void (* CMOCK_ppu_v1_lock_off_enable_CALLBACK)(struct ppu_v1_regs* ppu, int cmock_num_calls); void ppu_v1_lock_off_enable_AddCallback(CMOCK_ppu_v1_lock_off_enable_CALLBACK Callback); void ppu_v1_lock_off_enable_Stub(CMOCK_ppu_v1_lock_off_enable_CALLBACK Callback); #define ppu_v1_lock_off_enable_StubWithCallback ppu_v1_lock_off_enable_Stub #define ppu_v1_lock_off_enable_ExpectWithArray(ppu, ppu_Depth) ppu_v1_lock_off_enable_CMockExpectWithArray(__LINE__, ppu, ppu_Depth) -void ppu_v1_lock_off_enable_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth); -#define ppu_v1_lock_off_enable_ReturnThruPtr_ppu(ppu) ppu_v1_lock_off_enable_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_lock_off_enable_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth); +#define ppu_v1_lock_off_enable_ReturnThruPtr_ppu(ppu) ppu_v1_lock_off_enable_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_lock_off_enable_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_lock_off_enable_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_lock_off_enable_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_lock_off_enable_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_lock_off_enable_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_lock_off_enable_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_lock_off_enable_IgnoreArg_ppu() ppu_v1_lock_off_enable_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_lock_off_enable_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_lock_off_disable_Ignore() ppu_v1_lock_off_disable_CMockIgnore() @@ -224,17 +224,17 @@ void ppu_v1_lock_off_disable_CMockStopIgnore(void); #define ppu_v1_lock_off_disable_ExpectAnyArgs() ppu_v1_lock_off_disable_CMockExpectAnyArgs(__LINE__) void ppu_v1_lock_off_disable_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); #define ppu_v1_lock_off_disable_Expect(ppu) ppu_v1_lock_off_disable_CMockExpect(__LINE__, ppu) -void ppu_v1_lock_off_disable_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu); -typedef void (* CMOCK_ppu_v1_lock_off_disable_CALLBACK)(struct ppu_v1_reg* ppu, int cmock_num_calls); +void ppu_v1_lock_off_disable_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu); +typedef void (* CMOCK_ppu_v1_lock_off_disable_CALLBACK)(struct ppu_v1_regs* ppu, int cmock_num_calls); void ppu_v1_lock_off_disable_AddCallback(CMOCK_ppu_v1_lock_off_disable_CALLBACK Callback); void ppu_v1_lock_off_disable_Stub(CMOCK_ppu_v1_lock_off_disable_CALLBACK Callback); #define ppu_v1_lock_off_disable_StubWithCallback ppu_v1_lock_off_disable_Stub #define ppu_v1_lock_off_disable_ExpectWithArray(ppu, ppu_Depth) ppu_v1_lock_off_disable_CMockExpectWithArray(__LINE__, ppu, ppu_Depth) -void ppu_v1_lock_off_disable_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth); -#define ppu_v1_lock_off_disable_ReturnThruPtr_ppu(ppu) ppu_v1_lock_off_disable_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_lock_off_disable_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth); +#define ppu_v1_lock_off_disable_ReturnThruPtr_ppu(ppu) ppu_v1_lock_off_disable_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_lock_off_disable_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_lock_off_disable_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_lock_off_disable_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_lock_off_disable_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_lock_off_disable_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_lock_off_disable_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_lock_off_disable_IgnoreArg_ppu() ppu_v1_lock_off_disable_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_lock_off_disable_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_get_power_mode_IgnoreAndReturn(cmock_retval) ppu_v1_get_power_mode_CMockIgnoreAndReturn(__LINE__, cmock_retval) @@ -244,17 +244,17 @@ void ppu_v1_get_power_mode_CMockStopIgnore(void); #define ppu_v1_get_power_mode_ExpectAnyArgsAndReturn(cmock_retval) ppu_v1_get_power_mode_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) void ppu_v1_get_power_mode_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, enum ppu_v1_mode cmock_to_return); #define ppu_v1_get_power_mode_ExpectAndReturn(ppu, cmock_retval) ppu_v1_get_power_mode_CMockExpectAndReturn(__LINE__, ppu, cmock_retval) -void ppu_v1_get_power_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_mode cmock_to_return); -typedef enum ppu_v1_mode (* CMOCK_ppu_v1_get_power_mode_CALLBACK)(struct ppu_v1_reg* ppu, int cmock_num_calls); +void ppu_v1_get_power_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_mode cmock_to_return); +typedef enum ppu_v1_mode (* CMOCK_ppu_v1_get_power_mode_CALLBACK)(struct ppu_v1_regs* ppu, int cmock_num_calls); void ppu_v1_get_power_mode_AddCallback(CMOCK_ppu_v1_get_power_mode_CALLBACK Callback); void ppu_v1_get_power_mode_Stub(CMOCK_ppu_v1_get_power_mode_CALLBACK Callback); #define ppu_v1_get_power_mode_StubWithCallback ppu_v1_get_power_mode_Stub #define ppu_v1_get_power_mode_ExpectWithArrayAndReturn(ppu, ppu_Depth, cmock_retval) ppu_v1_get_power_mode_CMockExpectWithArrayAndReturn(__LINE__, ppu, ppu_Depth, cmock_retval) -void ppu_v1_get_power_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode cmock_to_return); -#define ppu_v1_get_power_mode_ReturnThruPtr_ppu(ppu) ppu_v1_get_power_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_get_power_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode cmock_to_return); +#define ppu_v1_get_power_mode_ReturnThruPtr_ppu(ppu) ppu_v1_get_power_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_get_power_mode_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_get_power_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_get_power_mode_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_get_power_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_get_power_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_get_power_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_get_power_mode_IgnoreArg_ppu() ppu_v1_get_power_mode_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_get_power_mode_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_get_programmed_power_mode_IgnoreAndReturn(cmock_retval) ppu_v1_get_programmed_power_mode_CMockIgnoreAndReturn(__LINE__, cmock_retval) @@ -264,17 +264,17 @@ void ppu_v1_get_programmed_power_mode_CMockStopIgnore(void); #define ppu_v1_get_programmed_power_mode_ExpectAnyArgsAndReturn(cmock_retval) ppu_v1_get_programmed_power_mode_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) void ppu_v1_get_programmed_power_mode_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, enum ppu_v1_mode cmock_to_return); #define ppu_v1_get_programmed_power_mode_ExpectAndReturn(ppu, cmock_retval) ppu_v1_get_programmed_power_mode_CMockExpectAndReturn(__LINE__, ppu, cmock_retval) -void ppu_v1_get_programmed_power_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_mode cmock_to_return); -typedef enum ppu_v1_mode (* CMOCK_ppu_v1_get_programmed_power_mode_CALLBACK)(struct ppu_v1_reg* ppu, int cmock_num_calls); +void ppu_v1_get_programmed_power_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_mode cmock_to_return); +typedef enum ppu_v1_mode (* CMOCK_ppu_v1_get_programmed_power_mode_CALLBACK)(struct ppu_v1_regs* ppu, int cmock_num_calls); void ppu_v1_get_programmed_power_mode_AddCallback(CMOCK_ppu_v1_get_programmed_power_mode_CALLBACK Callback); void ppu_v1_get_programmed_power_mode_Stub(CMOCK_ppu_v1_get_programmed_power_mode_CALLBACK Callback); #define ppu_v1_get_programmed_power_mode_StubWithCallback ppu_v1_get_programmed_power_mode_Stub #define ppu_v1_get_programmed_power_mode_ExpectWithArrayAndReturn(ppu, ppu_Depth, cmock_retval) ppu_v1_get_programmed_power_mode_CMockExpectWithArrayAndReturn(__LINE__, ppu, ppu_Depth, cmock_retval) -void ppu_v1_get_programmed_power_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode cmock_to_return); -#define ppu_v1_get_programmed_power_mode_ReturnThruPtr_ppu(ppu) ppu_v1_get_programmed_power_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_get_programmed_power_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode cmock_to_return); +#define ppu_v1_get_programmed_power_mode_ReturnThruPtr_ppu(ppu) ppu_v1_get_programmed_power_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_get_programmed_power_mode_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_get_programmed_power_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_get_programmed_power_mode_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_get_programmed_power_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_get_programmed_power_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_get_programmed_power_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_get_programmed_power_mode_IgnoreArg_ppu() ppu_v1_get_programmed_power_mode_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_get_programmed_power_mode_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_get_operating_mode_IgnoreAndReturn(cmock_retval) ppu_v1_get_operating_mode_CMockIgnoreAndReturn(__LINE__, cmock_retval) @@ -284,17 +284,17 @@ void ppu_v1_get_operating_mode_CMockStopIgnore(void); #define ppu_v1_get_operating_mode_ExpectAnyArgsAndReturn(cmock_retval) ppu_v1_get_operating_mode_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) void ppu_v1_get_operating_mode_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, enum ppu_v1_opmode cmock_to_return); #define ppu_v1_get_operating_mode_ExpectAndReturn(ppu, cmock_retval) ppu_v1_get_operating_mode_CMockExpectAndReturn(__LINE__, ppu, cmock_retval) -void ppu_v1_get_operating_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_opmode cmock_to_return); -typedef enum ppu_v1_opmode (* CMOCK_ppu_v1_get_operating_mode_CALLBACK)(struct ppu_v1_reg* ppu, int cmock_num_calls); +void ppu_v1_get_operating_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_opmode cmock_to_return); +typedef enum ppu_v1_opmode (* CMOCK_ppu_v1_get_operating_mode_CALLBACK)(struct ppu_v1_regs* ppu, int cmock_num_calls); void ppu_v1_get_operating_mode_AddCallback(CMOCK_ppu_v1_get_operating_mode_CALLBACK Callback); void ppu_v1_get_operating_mode_Stub(CMOCK_ppu_v1_get_operating_mode_CALLBACK Callback); #define ppu_v1_get_operating_mode_StubWithCallback ppu_v1_get_operating_mode_Stub #define ppu_v1_get_operating_mode_ExpectWithArrayAndReturn(ppu, ppu_Depth, cmock_retval) ppu_v1_get_operating_mode_CMockExpectWithArrayAndReturn(__LINE__, ppu, ppu_Depth, cmock_retval) -void ppu_v1_get_operating_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_opmode cmock_to_return); -#define ppu_v1_get_operating_mode_ReturnThruPtr_ppu(ppu) ppu_v1_get_operating_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_get_operating_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_opmode cmock_to_return); +#define ppu_v1_get_operating_mode_ReturnThruPtr_ppu(ppu) ppu_v1_get_operating_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_get_operating_mode_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_get_operating_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_get_operating_mode_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_get_operating_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_get_operating_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_get_operating_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_get_operating_mode_IgnoreArg_ppu() ppu_v1_get_operating_mode_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_get_operating_mode_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_get_programmed_operating_mode_IgnoreAndReturn(cmock_retval) ppu_v1_get_programmed_operating_mode_CMockIgnoreAndReturn(__LINE__, cmock_retval) @@ -304,17 +304,17 @@ void ppu_v1_get_programmed_operating_mode_CMockStopIgnore(void); #define ppu_v1_get_programmed_operating_mode_ExpectAnyArgsAndReturn(cmock_retval) ppu_v1_get_programmed_operating_mode_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) void ppu_v1_get_programmed_operating_mode_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, enum ppu_v1_opmode cmock_to_return); #define ppu_v1_get_programmed_operating_mode_ExpectAndReturn(ppu, cmock_retval) ppu_v1_get_programmed_operating_mode_CMockExpectAndReturn(__LINE__, ppu, cmock_retval) -void ppu_v1_get_programmed_operating_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_opmode cmock_to_return); -typedef enum ppu_v1_opmode (* CMOCK_ppu_v1_get_programmed_operating_mode_CALLBACK)(struct ppu_v1_reg* ppu, int cmock_num_calls); +void ppu_v1_get_programmed_operating_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_opmode cmock_to_return); +typedef enum ppu_v1_opmode (* CMOCK_ppu_v1_get_programmed_operating_mode_CALLBACK)(struct ppu_v1_regs* ppu, int cmock_num_calls); void ppu_v1_get_programmed_operating_mode_AddCallback(CMOCK_ppu_v1_get_programmed_operating_mode_CALLBACK Callback); void ppu_v1_get_programmed_operating_mode_Stub(CMOCK_ppu_v1_get_programmed_operating_mode_CALLBACK Callback); #define ppu_v1_get_programmed_operating_mode_StubWithCallback ppu_v1_get_programmed_operating_mode_Stub #define ppu_v1_get_programmed_operating_mode_ExpectWithArrayAndReturn(ppu, ppu_Depth, cmock_retval) ppu_v1_get_programmed_operating_mode_CMockExpectWithArrayAndReturn(__LINE__, ppu, ppu_Depth, cmock_retval) -void ppu_v1_get_programmed_operating_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_opmode cmock_to_return); -#define ppu_v1_get_programmed_operating_mode_ReturnThruPtr_ppu(ppu) ppu_v1_get_programmed_operating_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_get_programmed_operating_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_opmode cmock_to_return); +#define ppu_v1_get_programmed_operating_mode_ReturnThruPtr_ppu(ppu) ppu_v1_get_programmed_operating_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_get_programmed_operating_mode_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_get_programmed_operating_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_get_programmed_operating_mode_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_get_programmed_operating_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_get_programmed_operating_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_get_programmed_operating_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_get_programmed_operating_mode_IgnoreArg_ppu() ppu_v1_get_programmed_operating_mode_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_get_programmed_operating_mode_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_is_dynamic_enabled_IgnoreAndReturn(cmock_retval) ppu_v1_is_dynamic_enabled_CMockIgnoreAndReturn(__LINE__, cmock_retval) @@ -324,17 +324,17 @@ void ppu_v1_is_dynamic_enabled_CMockStopIgnore(void); #define ppu_v1_is_dynamic_enabled_ExpectAnyArgsAndReturn(cmock_retval) ppu_v1_is_dynamic_enabled_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) void ppu_v1_is_dynamic_enabled_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return); #define ppu_v1_is_dynamic_enabled_ExpectAndReturn(ppu, cmock_retval) ppu_v1_is_dynamic_enabled_CMockExpectAndReturn(__LINE__, ppu, cmock_retval) -void ppu_v1_is_dynamic_enabled_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, bool cmock_to_return); -typedef bool (* CMOCK_ppu_v1_is_dynamic_enabled_CALLBACK)(struct ppu_v1_reg* ppu, int cmock_num_calls); +void ppu_v1_is_dynamic_enabled_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, bool cmock_to_return); +typedef bool (* CMOCK_ppu_v1_is_dynamic_enabled_CALLBACK)(struct ppu_v1_regs* ppu, int cmock_num_calls); void ppu_v1_is_dynamic_enabled_AddCallback(CMOCK_ppu_v1_is_dynamic_enabled_CALLBACK Callback); void ppu_v1_is_dynamic_enabled_Stub(CMOCK_ppu_v1_is_dynamic_enabled_CALLBACK Callback); #define ppu_v1_is_dynamic_enabled_StubWithCallback ppu_v1_is_dynamic_enabled_Stub #define ppu_v1_is_dynamic_enabled_ExpectWithArrayAndReturn(ppu, ppu_Depth, cmock_retval) ppu_v1_is_dynamic_enabled_CMockExpectWithArrayAndReturn(__LINE__, ppu, ppu_Depth, cmock_retval) -void ppu_v1_is_dynamic_enabled_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, bool cmock_to_return); -#define ppu_v1_is_dynamic_enabled_ReturnThruPtr_ppu(ppu) ppu_v1_is_dynamic_enabled_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_is_dynamic_enabled_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, bool cmock_to_return); +#define ppu_v1_is_dynamic_enabled_ReturnThruPtr_ppu(ppu) ppu_v1_is_dynamic_enabled_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_is_dynamic_enabled_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_is_dynamic_enabled_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_is_dynamic_enabled_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_is_dynamic_enabled_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_is_dynamic_enabled_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_is_dynamic_enabled_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_is_dynamic_enabled_IgnoreArg_ppu() ppu_v1_is_dynamic_enabled_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_is_dynamic_enabled_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_is_locked_IgnoreAndReturn(cmock_retval) ppu_v1_is_locked_CMockIgnoreAndReturn(__LINE__, cmock_retval) @@ -344,17 +344,17 @@ void ppu_v1_is_locked_CMockStopIgnore(void); #define ppu_v1_is_locked_ExpectAnyArgsAndReturn(cmock_retval) ppu_v1_is_locked_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) void ppu_v1_is_locked_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return); #define ppu_v1_is_locked_ExpectAndReturn(ppu, cmock_retval) ppu_v1_is_locked_CMockExpectAndReturn(__LINE__, ppu, cmock_retval) -void ppu_v1_is_locked_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, bool cmock_to_return); -typedef bool (* CMOCK_ppu_v1_is_locked_CALLBACK)(struct ppu_v1_reg* ppu, int cmock_num_calls); +void ppu_v1_is_locked_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, bool cmock_to_return); +typedef bool (* CMOCK_ppu_v1_is_locked_CALLBACK)(struct ppu_v1_regs* ppu, int cmock_num_calls); void ppu_v1_is_locked_AddCallback(CMOCK_ppu_v1_is_locked_CALLBACK Callback); void ppu_v1_is_locked_Stub(CMOCK_ppu_v1_is_locked_CALLBACK Callback); #define ppu_v1_is_locked_StubWithCallback ppu_v1_is_locked_Stub #define ppu_v1_is_locked_ExpectWithArrayAndReturn(ppu, ppu_Depth, cmock_retval) ppu_v1_is_locked_CMockExpectWithArrayAndReturn(__LINE__, ppu, ppu_Depth, cmock_retval) -void ppu_v1_is_locked_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, bool cmock_to_return); -#define ppu_v1_is_locked_ReturnThruPtr_ppu(ppu) ppu_v1_is_locked_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_is_locked_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, bool cmock_to_return); +#define ppu_v1_is_locked_ReturnThruPtr_ppu(ppu) ppu_v1_is_locked_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_is_locked_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_is_locked_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_is_locked_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_is_locked_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_is_locked_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_is_locked_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_is_locked_IgnoreArg_ppu() ppu_v1_is_locked_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_is_locked_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_is_power_devactive_high_IgnoreAndReturn(cmock_retval) ppu_v1_is_power_devactive_high_CMockIgnoreAndReturn(__LINE__, cmock_retval) @@ -364,17 +364,17 @@ void ppu_v1_is_power_devactive_high_CMockStopIgnore(void); #define ppu_v1_is_power_devactive_high_ExpectAnyArgsAndReturn(cmock_retval) ppu_v1_is_power_devactive_high_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) void ppu_v1_is_power_devactive_high_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return); #define ppu_v1_is_power_devactive_high_ExpectAndReturn(ppu, ppu_mode, cmock_retval) ppu_v1_is_power_devactive_high_CMockExpectAndReturn(__LINE__, ppu, ppu_mode, cmock_retval) -void ppu_v1_is_power_devactive_high_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, bool cmock_to_return); -typedef bool (* CMOCK_ppu_v1_is_power_devactive_high_CALLBACK)(struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, int cmock_num_calls); +void ppu_v1_is_power_devactive_high_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode, bool cmock_to_return); +typedef bool (* CMOCK_ppu_v1_is_power_devactive_high_CALLBACK)(struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode, int cmock_num_calls); void ppu_v1_is_power_devactive_high_AddCallback(CMOCK_ppu_v1_is_power_devactive_high_CALLBACK Callback); void ppu_v1_is_power_devactive_high_Stub(CMOCK_ppu_v1_is_power_devactive_high_CALLBACK Callback); #define ppu_v1_is_power_devactive_high_StubWithCallback ppu_v1_is_power_devactive_high_Stub #define ppu_v1_is_power_devactive_high_ExpectWithArrayAndReturn(ppu, ppu_Depth, ppu_mode, cmock_retval) ppu_v1_is_power_devactive_high_CMockExpectWithArrayAndReturn(__LINE__, ppu, ppu_Depth, ppu_mode, cmock_retval) -void ppu_v1_is_power_devactive_high_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, bool cmock_to_return); -#define ppu_v1_is_power_devactive_high_ReturnThruPtr_ppu(ppu) ppu_v1_is_power_devactive_high_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_is_power_devactive_high_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, bool cmock_to_return); +#define ppu_v1_is_power_devactive_high_ReturnThruPtr_ppu(ppu) ppu_v1_is_power_devactive_high_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_is_power_devactive_high_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_is_power_devactive_high_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_is_power_devactive_high_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_is_power_devactive_high_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_is_power_devactive_high_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_is_power_devactive_high_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_is_power_devactive_high_IgnoreArg_ppu() ppu_v1_is_power_devactive_high_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_is_power_devactive_high_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_is_power_devactive_high_IgnoreArg_ppu_mode() ppu_v1_is_power_devactive_high_CMockIgnoreArg_ppu_mode(__LINE__) @@ -386,17 +386,17 @@ void ppu_v1_is_op_devactive_high_CMockStopIgnore(void); #define ppu_v1_is_op_devactive_high_ExpectAnyArgsAndReturn(cmock_retval) ppu_v1_is_op_devactive_high_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) void ppu_v1_is_op_devactive_high_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return); #define ppu_v1_is_op_devactive_high_ExpectAndReturn(ppu, op_devactive, cmock_retval) ppu_v1_is_op_devactive_high_CMockExpectAndReturn(__LINE__, ppu, op_devactive, cmock_retval) -void ppu_v1_is_op_devactive_high_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_op_devactive op_devactive, bool cmock_to_return); -typedef bool (* CMOCK_ppu_v1_is_op_devactive_high_CALLBACK)(struct ppu_v1_reg* ppu, enum ppu_v1_op_devactive op_devactive, int cmock_num_calls); +void ppu_v1_is_op_devactive_high_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_op_devactive op_devactive, bool cmock_to_return); +typedef bool (* CMOCK_ppu_v1_is_op_devactive_high_CALLBACK)(struct ppu_v1_regs* ppu, enum ppu_v1_op_devactive op_devactive, int cmock_num_calls); void ppu_v1_is_op_devactive_high_AddCallback(CMOCK_ppu_v1_is_op_devactive_high_CALLBACK Callback); void ppu_v1_is_op_devactive_high_Stub(CMOCK_ppu_v1_is_op_devactive_high_CALLBACK Callback); #define ppu_v1_is_op_devactive_high_StubWithCallback ppu_v1_is_op_devactive_high_Stub #define ppu_v1_is_op_devactive_high_ExpectWithArrayAndReturn(ppu, ppu_Depth, op_devactive, cmock_retval) ppu_v1_is_op_devactive_high_CMockExpectWithArrayAndReturn(__LINE__, ppu, ppu_Depth, op_devactive, cmock_retval) -void ppu_v1_is_op_devactive_high_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive, bool cmock_to_return); -#define ppu_v1_is_op_devactive_high_ReturnThruPtr_ppu(ppu) ppu_v1_is_op_devactive_high_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_is_op_devactive_high_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive, bool cmock_to_return); +#define ppu_v1_is_op_devactive_high_ReturnThruPtr_ppu(ppu) ppu_v1_is_op_devactive_high_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_is_op_devactive_high_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_is_op_devactive_high_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_is_op_devactive_high_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_is_op_devactive_high_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_is_op_devactive_high_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_is_op_devactive_high_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_is_op_devactive_high_IgnoreArg_ppu() ppu_v1_is_op_devactive_high_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_is_op_devactive_high_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_is_op_devactive_high_IgnoreArg_op_devactive() ppu_v1_is_op_devactive_high_CMockIgnoreArg_op_devactive(__LINE__) @@ -408,17 +408,17 @@ void ppu_v1_off_unlock_CMockStopIgnore(void); #define ppu_v1_off_unlock_ExpectAnyArgs() ppu_v1_off_unlock_CMockExpectAnyArgs(__LINE__) void ppu_v1_off_unlock_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); #define ppu_v1_off_unlock_Expect(ppu) ppu_v1_off_unlock_CMockExpect(__LINE__, ppu) -void ppu_v1_off_unlock_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu); -typedef void (* CMOCK_ppu_v1_off_unlock_CALLBACK)(struct ppu_v1_reg* ppu, int cmock_num_calls); +void ppu_v1_off_unlock_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu); +typedef void (* CMOCK_ppu_v1_off_unlock_CALLBACK)(struct ppu_v1_regs* ppu, int cmock_num_calls); void ppu_v1_off_unlock_AddCallback(CMOCK_ppu_v1_off_unlock_CALLBACK Callback); void ppu_v1_off_unlock_Stub(CMOCK_ppu_v1_off_unlock_CALLBACK Callback); #define ppu_v1_off_unlock_StubWithCallback ppu_v1_off_unlock_Stub #define ppu_v1_off_unlock_ExpectWithArray(ppu, ppu_Depth) ppu_v1_off_unlock_CMockExpectWithArray(__LINE__, ppu, ppu_Depth) -void ppu_v1_off_unlock_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth); -#define ppu_v1_off_unlock_ReturnThruPtr_ppu(ppu) ppu_v1_off_unlock_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_off_unlock_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth); +#define ppu_v1_off_unlock_ReturnThruPtr_ppu(ppu) ppu_v1_off_unlock_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_off_unlock_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_off_unlock_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_off_unlock_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_off_unlock_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_off_unlock_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_off_unlock_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_off_unlock_IgnoreArg_ppu() ppu_v1_off_unlock_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_off_unlock_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_disable_devactive_Ignore() ppu_v1_disable_devactive_CMockIgnore() @@ -428,17 +428,17 @@ void ppu_v1_disable_devactive_CMockStopIgnore(void); #define ppu_v1_disable_devactive_ExpectAnyArgs() ppu_v1_disable_devactive_CMockExpectAnyArgs(__LINE__) void ppu_v1_disable_devactive_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); #define ppu_v1_disable_devactive_Expect(ppu) ppu_v1_disable_devactive_CMockExpect(__LINE__, ppu) -void ppu_v1_disable_devactive_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu); -typedef void (* CMOCK_ppu_v1_disable_devactive_CALLBACK)(struct ppu_v1_reg* ppu, int cmock_num_calls); +void ppu_v1_disable_devactive_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu); +typedef void (* CMOCK_ppu_v1_disable_devactive_CALLBACK)(struct ppu_v1_regs* ppu, int cmock_num_calls); void ppu_v1_disable_devactive_AddCallback(CMOCK_ppu_v1_disable_devactive_CALLBACK Callback); void ppu_v1_disable_devactive_Stub(CMOCK_ppu_v1_disable_devactive_CALLBACK Callback); #define ppu_v1_disable_devactive_StubWithCallback ppu_v1_disable_devactive_Stub #define ppu_v1_disable_devactive_ExpectWithArray(ppu, ppu_Depth) ppu_v1_disable_devactive_CMockExpectWithArray(__LINE__, ppu, ppu_Depth) -void ppu_v1_disable_devactive_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth); -#define ppu_v1_disable_devactive_ReturnThruPtr_ppu(ppu) ppu_v1_disable_devactive_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_disable_devactive_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth); +#define ppu_v1_disable_devactive_ReturnThruPtr_ppu(ppu) ppu_v1_disable_devactive_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_disable_devactive_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_disable_devactive_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_disable_devactive_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_disable_devactive_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_disable_devactive_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_disable_devactive_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_disable_devactive_IgnoreArg_ppu() ppu_v1_disable_devactive_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_disable_devactive_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_disable_handshake_Ignore() ppu_v1_disable_handshake_CMockIgnore() @@ -448,17 +448,17 @@ void ppu_v1_disable_handshake_CMockStopIgnore(void); #define ppu_v1_disable_handshake_ExpectAnyArgs() ppu_v1_disable_handshake_CMockExpectAnyArgs(__LINE__) void ppu_v1_disable_handshake_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); #define ppu_v1_disable_handshake_Expect(ppu) ppu_v1_disable_handshake_CMockExpect(__LINE__, ppu) -void ppu_v1_disable_handshake_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu); -typedef void (* CMOCK_ppu_v1_disable_handshake_CALLBACK)(struct ppu_v1_reg* ppu, int cmock_num_calls); +void ppu_v1_disable_handshake_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu); +typedef void (* CMOCK_ppu_v1_disable_handshake_CALLBACK)(struct ppu_v1_regs* ppu, int cmock_num_calls); void ppu_v1_disable_handshake_AddCallback(CMOCK_ppu_v1_disable_handshake_CALLBACK Callback); void ppu_v1_disable_handshake_Stub(CMOCK_ppu_v1_disable_handshake_CALLBACK Callback); #define ppu_v1_disable_handshake_StubWithCallback ppu_v1_disable_handshake_Stub #define ppu_v1_disable_handshake_ExpectWithArray(ppu, ppu_Depth) ppu_v1_disable_handshake_CMockExpectWithArray(__LINE__, ppu, ppu_Depth) -void ppu_v1_disable_handshake_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth); -#define ppu_v1_disable_handshake_ReturnThruPtr_ppu(ppu) ppu_v1_disable_handshake_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_disable_handshake_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth); +#define ppu_v1_disable_handshake_ReturnThruPtr_ppu(ppu) ppu_v1_disable_handshake_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_disable_handshake_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_disable_handshake_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_disable_handshake_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_disable_handshake_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_disable_handshake_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_disable_handshake_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_disable_handshake_IgnoreArg_ppu() ppu_v1_disable_handshake_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_disable_handshake_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_interrupt_mask_Ignore() ppu_v1_interrupt_mask_CMockIgnore() @@ -468,17 +468,17 @@ void ppu_v1_interrupt_mask_CMockStopIgnore(void); #define ppu_v1_interrupt_mask_ExpectAnyArgs() ppu_v1_interrupt_mask_CMockExpectAnyArgs(__LINE__) void ppu_v1_interrupt_mask_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); #define ppu_v1_interrupt_mask_Expect(ppu, mask) ppu_v1_interrupt_mask_CMockExpect(__LINE__, ppu, mask) -void ppu_v1_interrupt_mask_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, unsigned int mask); -typedef void (* CMOCK_ppu_v1_interrupt_mask_CALLBACK)(struct ppu_v1_reg* ppu, unsigned int mask, int cmock_num_calls); +void ppu_v1_interrupt_mask_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, unsigned int mask); +typedef void (* CMOCK_ppu_v1_interrupt_mask_CALLBACK)(struct ppu_v1_regs* ppu, unsigned int mask, int cmock_num_calls); void ppu_v1_interrupt_mask_AddCallback(CMOCK_ppu_v1_interrupt_mask_CALLBACK Callback); void ppu_v1_interrupt_mask_Stub(CMOCK_ppu_v1_interrupt_mask_CALLBACK Callback); #define ppu_v1_interrupt_mask_StubWithCallback ppu_v1_interrupt_mask_Stub #define ppu_v1_interrupt_mask_ExpectWithArray(ppu, ppu_Depth, mask) ppu_v1_interrupt_mask_CMockExpectWithArray(__LINE__, ppu, ppu_Depth, mask) -void ppu_v1_interrupt_mask_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask); -#define ppu_v1_interrupt_mask_ReturnThruPtr_ppu(ppu) ppu_v1_interrupt_mask_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_interrupt_mask_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask); +#define ppu_v1_interrupt_mask_ReturnThruPtr_ppu(ppu) ppu_v1_interrupt_mask_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_interrupt_mask_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_interrupt_mask_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_interrupt_mask_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_interrupt_mask_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_interrupt_mask_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_interrupt_mask_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_interrupt_mask_IgnoreArg_ppu() ppu_v1_interrupt_mask_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_interrupt_mask_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_interrupt_mask_IgnoreArg_mask() ppu_v1_interrupt_mask_CMockIgnoreArg_mask(__LINE__) @@ -490,17 +490,17 @@ void ppu_v1_additional_interrupt_mask_CMockStopIgnore(void); #define ppu_v1_additional_interrupt_mask_ExpectAnyArgs() ppu_v1_additional_interrupt_mask_CMockExpectAnyArgs(__LINE__) void ppu_v1_additional_interrupt_mask_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); #define ppu_v1_additional_interrupt_mask_Expect(ppu, mask) ppu_v1_additional_interrupt_mask_CMockExpect(__LINE__, ppu, mask) -void ppu_v1_additional_interrupt_mask_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, unsigned int mask); -typedef void (* CMOCK_ppu_v1_additional_interrupt_mask_CALLBACK)(struct ppu_v1_reg* ppu, unsigned int mask, int cmock_num_calls); +void ppu_v1_additional_interrupt_mask_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, unsigned int mask); +typedef void (* CMOCK_ppu_v1_additional_interrupt_mask_CALLBACK)(struct ppu_v1_regs* ppu, unsigned int mask, int cmock_num_calls); void ppu_v1_additional_interrupt_mask_AddCallback(CMOCK_ppu_v1_additional_interrupt_mask_CALLBACK Callback); void ppu_v1_additional_interrupt_mask_Stub(CMOCK_ppu_v1_additional_interrupt_mask_CALLBACK Callback); #define ppu_v1_additional_interrupt_mask_StubWithCallback ppu_v1_additional_interrupt_mask_Stub #define ppu_v1_additional_interrupt_mask_ExpectWithArray(ppu, ppu_Depth, mask) ppu_v1_additional_interrupt_mask_CMockExpectWithArray(__LINE__, ppu, ppu_Depth, mask) -void ppu_v1_additional_interrupt_mask_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask); -#define ppu_v1_additional_interrupt_mask_ReturnThruPtr_ppu(ppu) ppu_v1_additional_interrupt_mask_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_additional_interrupt_mask_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask); +#define ppu_v1_additional_interrupt_mask_ReturnThruPtr_ppu(ppu) ppu_v1_additional_interrupt_mask_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_additional_interrupt_mask_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_additional_interrupt_mask_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_additional_interrupt_mask_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_additional_interrupt_mask_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_additional_interrupt_mask_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_additional_interrupt_mask_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_additional_interrupt_mask_IgnoreArg_ppu() ppu_v1_additional_interrupt_mask_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_additional_interrupt_mask_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_additional_interrupt_mask_IgnoreArg_mask() ppu_v1_additional_interrupt_mask_CMockIgnoreArg_mask(__LINE__) @@ -512,17 +512,17 @@ void ppu_v1_interrupt_unmask_CMockStopIgnore(void); #define ppu_v1_interrupt_unmask_ExpectAnyArgs() ppu_v1_interrupt_unmask_CMockExpectAnyArgs(__LINE__) void ppu_v1_interrupt_unmask_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); #define ppu_v1_interrupt_unmask_Expect(ppu, mask) ppu_v1_interrupt_unmask_CMockExpect(__LINE__, ppu, mask) -void ppu_v1_interrupt_unmask_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, unsigned int mask); -typedef void (* CMOCK_ppu_v1_interrupt_unmask_CALLBACK)(struct ppu_v1_reg* ppu, unsigned int mask, int cmock_num_calls); +void ppu_v1_interrupt_unmask_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, unsigned int mask); +typedef void (* CMOCK_ppu_v1_interrupt_unmask_CALLBACK)(struct ppu_v1_regs* ppu, unsigned int mask, int cmock_num_calls); void ppu_v1_interrupt_unmask_AddCallback(CMOCK_ppu_v1_interrupt_unmask_CALLBACK Callback); void ppu_v1_interrupt_unmask_Stub(CMOCK_ppu_v1_interrupt_unmask_CALLBACK Callback); #define ppu_v1_interrupt_unmask_StubWithCallback ppu_v1_interrupt_unmask_Stub #define ppu_v1_interrupt_unmask_ExpectWithArray(ppu, ppu_Depth, mask) ppu_v1_interrupt_unmask_CMockExpectWithArray(__LINE__, ppu, ppu_Depth, mask) -void ppu_v1_interrupt_unmask_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask); -#define ppu_v1_interrupt_unmask_ReturnThruPtr_ppu(ppu) ppu_v1_interrupt_unmask_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_interrupt_unmask_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask); +#define ppu_v1_interrupt_unmask_ReturnThruPtr_ppu(ppu) ppu_v1_interrupt_unmask_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_interrupt_unmask_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_interrupt_unmask_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_interrupt_unmask_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_interrupt_unmask_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_interrupt_unmask_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_interrupt_unmask_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_interrupt_unmask_IgnoreArg_ppu() ppu_v1_interrupt_unmask_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_interrupt_unmask_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_interrupt_unmask_IgnoreArg_mask() ppu_v1_interrupt_unmask_CMockIgnoreArg_mask(__LINE__) @@ -534,17 +534,17 @@ void ppu_v1_additional_interrupt_unmask_CMockStopIgnore(void); #define ppu_v1_additional_interrupt_unmask_ExpectAnyArgs() ppu_v1_additional_interrupt_unmask_CMockExpectAnyArgs(__LINE__) void ppu_v1_additional_interrupt_unmask_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); #define ppu_v1_additional_interrupt_unmask_Expect(ppu, mask) ppu_v1_additional_interrupt_unmask_CMockExpect(__LINE__, ppu, mask) -void ppu_v1_additional_interrupt_unmask_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, unsigned int mask); -typedef void (* CMOCK_ppu_v1_additional_interrupt_unmask_CALLBACK)(struct ppu_v1_reg* ppu, unsigned int mask, int cmock_num_calls); +void ppu_v1_additional_interrupt_unmask_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, unsigned int mask); +typedef void (* CMOCK_ppu_v1_additional_interrupt_unmask_CALLBACK)(struct ppu_v1_regs* ppu, unsigned int mask, int cmock_num_calls); void ppu_v1_additional_interrupt_unmask_AddCallback(CMOCK_ppu_v1_additional_interrupt_unmask_CALLBACK Callback); void ppu_v1_additional_interrupt_unmask_Stub(CMOCK_ppu_v1_additional_interrupt_unmask_CALLBACK Callback); #define ppu_v1_additional_interrupt_unmask_StubWithCallback ppu_v1_additional_interrupt_unmask_Stub #define ppu_v1_additional_interrupt_unmask_ExpectWithArray(ppu, ppu_Depth, mask) ppu_v1_additional_interrupt_unmask_CMockExpectWithArray(__LINE__, ppu, ppu_Depth, mask) -void ppu_v1_additional_interrupt_unmask_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask); -#define ppu_v1_additional_interrupt_unmask_ReturnThruPtr_ppu(ppu) ppu_v1_additional_interrupt_unmask_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_additional_interrupt_unmask_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask); +#define ppu_v1_additional_interrupt_unmask_ReturnThruPtr_ppu(ppu) ppu_v1_additional_interrupt_unmask_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_additional_interrupt_unmask_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_additional_interrupt_unmask_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_additional_interrupt_unmask_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_additional_interrupt_unmask_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_additional_interrupt_unmask_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_additional_interrupt_unmask_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_additional_interrupt_unmask_IgnoreArg_ppu() ppu_v1_additional_interrupt_unmask_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_additional_interrupt_unmask_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_additional_interrupt_unmask_IgnoreArg_mask() ppu_v1_additional_interrupt_unmask_CMockIgnoreArg_mask(__LINE__) @@ -556,17 +556,17 @@ void ppu_v1_is_additional_interrupt_pending_CMockStopIgnore(void); #define ppu_v1_is_additional_interrupt_pending_ExpectAnyArgsAndReturn(cmock_retval) ppu_v1_is_additional_interrupt_pending_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) void ppu_v1_is_additional_interrupt_pending_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return); #define ppu_v1_is_additional_interrupt_pending_ExpectAndReturn(ppu, mask, cmock_retval) ppu_v1_is_additional_interrupt_pending_CMockExpectAndReturn(__LINE__, ppu, mask, cmock_retval) -void ppu_v1_is_additional_interrupt_pending_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, unsigned int mask, bool cmock_to_return); -typedef bool (* CMOCK_ppu_v1_is_additional_interrupt_pending_CALLBACK)(struct ppu_v1_reg* ppu, unsigned int mask, int cmock_num_calls); +void ppu_v1_is_additional_interrupt_pending_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, unsigned int mask, bool cmock_to_return); +typedef bool (* CMOCK_ppu_v1_is_additional_interrupt_pending_CALLBACK)(struct ppu_v1_regs* ppu, unsigned int mask, int cmock_num_calls); void ppu_v1_is_additional_interrupt_pending_AddCallback(CMOCK_ppu_v1_is_additional_interrupt_pending_CALLBACK Callback); void ppu_v1_is_additional_interrupt_pending_Stub(CMOCK_ppu_v1_is_additional_interrupt_pending_CALLBACK Callback); #define ppu_v1_is_additional_interrupt_pending_StubWithCallback ppu_v1_is_additional_interrupt_pending_Stub #define ppu_v1_is_additional_interrupt_pending_ExpectWithArrayAndReturn(ppu, ppu_Depth, mask, cmock_retval) ppu_v1_is_additional_interrupt_pending_CMockExpectWithArrayAndReturn(__LINE__, ppu, ppu_Depth, mask, cmock_retval) -void ppu_v1_is_additional_interrupt_pending_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask, bool cmock_to_return); -#define ppu_v1_is_additional_interrupt_pending_ReturnThruPtr_ppu(ppu) ppu_v1_is_additional_interrupt_pending_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_is_additional_interrupt_pending_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask, bool cmock_to_return); +#define ppu_v1_is_additional_interrupt_pending_ReturnThruPtr_ppu(ppu) ppu_v1_is_additional_interrupt_pending_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_is_additional_interrupt_pending_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_is_additional_interrupt_pending_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_is_additional_interrupt_pending_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_is_additional_interrupt_pending_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_is_additional_interrupt_pending_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_is_additional_interrupt_pending_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_is_additional_interrupt_pending_IgnoreArg_ppu() ppu_v1_is_additional_interrupt_pending_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_is_additional_interrupt_pending_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_is_additional_interrupt_pending_IgnoreArg_mask() ppu_v1_is_additional_interrupt_pending_CMockIgnoreArg_mask(__LINE__) @@ -578,17 +578,17 @@ void ppu_v1_ack_interrupt_CMockStopIgnore(void); #define ppu_v1_ack_interrupt_ExpectAnyArgs() ppu_v1_ack_interrupt_CMockExpectAnyArgs(__LINE__) void ppu_v1_ack_interrupt_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); #define ppu_v1_ack_interrupt_Expect(ppu, mask) ppu_v1_ack_interrupt_CMockExpect(__LINE__, ppu, mask) -void ppu_v1_ack_interrupt_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, unsigned int mask); -typedef void (* CMOCK_ppu_v1_ack_interrupt_CALLBACK)(struct ppu_v1_reg* ppu, unsigned int mask, int cmock_num_calls); +void ppu_v1_ack_interrupt_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, unsigned int mask); +typedef void (* CMOCK_ppu_v1_ack_interrupt_CALLBACK)(struct ppu_v1_regs* ppu, unsigned int mask, int cmock_num_calls); void ppu_v1_ack_interrupt_AddCallback(CMOCK_ppu_v1_ack_interrupt_CALLBACK Callback); void ppu_v1_ack_interrupt_Stub(CMOCK_ppu_v1_ack_interrupt_CALLBACK Callback); #define ppu_v1_ack_interrupt_StubWithCallback ppu_v1_ack_interrupt_Stub #define ppu_v1_ack_interrupt_ExpectWithArray(ppu, ppu_Depth, mask) ppu_v1_ack_interrupt_CMockExpectWithArray(__LINE__, ppu, ppu_Depth, mask) -void ppu_v1_ack_interrupt_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask); -#define ppu_v1_ack_interrupt_ReturnThruPtr_ppu(ppu) ppu_v1_ack_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_ack_interrupt_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask); +#define ppu_v1_ack_interrupt_ReturnThruPtr_ppu(ppu) ppu_v1_ack_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_ack_interrupt_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_ack_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_ack_interrupt_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_ack_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_ack_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_ack_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_ack_interrupt_IgnoreArg_ppu() ppu_v1_ack_interrupt_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_ack_interrupt_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_ack_interrupt_IgnoreArg_mask() ppu_v1_ack_interrupt_CMockIgnoreArg_mask(__LINE__) @@ -600,17 +600,17 @@ void ppu_v1_ack_additional_interrupt_CMockStopIgnore(void); #define ppu_v1_ack_additional_interrupt_ExpectAnyArgs() ppu_v1_ack_additional_interrupt_CMockExpectAnyArgs(__LINE__) void ppu_v1_ack_additional_interrupt_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); #define ppu_v1_ack_additional_interrupt_Expect(ppu, mask) ppu_v1_ack_additional_interrupt_CMockExpect(__LINE__, ppu, mask) -void ppu_v1_ack_additional_interrupt_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, unsigned int mask); -typedef void (* CMOCK_ppu_v1_ack_additional_interrupt_CALLBACK)(struct ppu_v1_reg* ppu, unsigned int mask, int cmock_num_calls); +void ppu_v1_ack_additional_interrupt_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, unsigned int mask); +typedef void (* CMOCK_ppu_v1_ack_additional_interrupt_CALLBACK)(struct ppu_v1_regs* ppu, unsigned int mask, int cmock_num_calls); void ppu_v1_ack_additional_interrupt_AddCallback(CMOCK_ppu_v1_ack_additional_interrupt_CALLBACK Callback); void ppu_v1_ack_additional_interrupt_Stub(CMOCK_ppu_v1_ack_additional_interrupt_CALLBACK Callback); #define ppu_v1_ack_additional_interrupt_StubWithCallback ppu_v1_ack_additional_interrupt_Stub #define ppu_v1_ack_additional_interrupt_ExpectWithArray(ppu, ppu_Depth, mask) ppu_v1_ack_additional_interrupt_CMockExpectWithArray(__LINE__, ppu, ppu_Depth, mask) -void ppu_v1_ack_additional_interrupt_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask); -#define ppu_v1_ack_additional_interrupt_ReturnThruPtr_ppu(ppu) ppu_v1_ack_additional_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_ack_additional_interrupt_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask); +#define ppu_v1_ack_additional_interrupt_ReturnThruPtr_ppu(ppu) ppu_v1_ack_additional_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_ack_additional_interrupt_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_ack_additional_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_ack_additional_interrupt_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_ack_additional_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_ack_additional_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_ack_additional_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_ack_additional_interrupt_IgnoreArg_ppu() ppu_v1_ack_additional_interrupt_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_ack_additional_interrupt_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_ack_additional_interrupt_IgnoreArg_mask() ppu_v1_ack_additional_interrupt_CMockIgnoreArg_mask(__LINE__) @@ -622,17 +622,17 @@ void ppu_v1_set_input_edge_sensitivity_CMockStopIgnore(void); #define ppu_v1_set_input_edge_sensitivity_ExpectAnyArgs() ppu_v1_set_input_edge_sensitivity_CMockExpectAnyArgs(__LINE__) void ppu_v1_set_input_edge_sensitivity_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); #define ppu_v1_set_input_edge_sensitivity_Expect(ppu, ppu_mode, edge_sensitivity) ppu_v1_set_input_edge_sensitivity_CMockExpect(__LINE__, ppu, ppu_mode, edge_sensitivity) -void ppu_v1_set_input_edge_sensitivity_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity edge_sensitivity); -typedef void (* CMOCK_ppu_v1_set_input_edge_sensitivity_CALLBACK)(struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity edge_sensitivity, int cmock_num_calls); +void ppu_v1_set_input_edge_sensitivity_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity edge_sensitivity); +typedef void (* CMOCK_ppu_v1_set_input_edge_sensitivity_CALLBACK)(struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity edge_sensitivity, int cmock_num_calls); void ppu_v1_set_input_edge_sensitivity_AddCallback(CMOCK_ppu_v1_set_input_edge_sensitivity_CALLBACK Callback); void ppu_v1_set_input_edge_sensitivity_Stub(CMOCK_ppu_v1_set_input_edge_sensitivity_CALLBACK Callback); #define ppu_v1_set_input_edge_sensitivity_StubWithCallback ppu_v1_set_input_edge_sensitivity_Stub #define ppu_v1_set_input_edge_sensitivity_ExpectWithArray(ppu, ppu_Depth, ppu_mode, edge_sensitivity) ppu_v1_set_input_edge_sensitivity_CMockExpectWithArray(__LINE__, ppu, ppu_Depth, ppu_mode, edge_sensitivity) -void ppu_v1_set_input_edge_sensitivity_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity edge_sensitivity); -#define ppu_v1_set_input_edge_sensitivity_ReturnThruPtr_ppu(ppu) ppu_v1_set_input_edge_sensitivity_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_set_input_edge_sensitivity_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity edge_sensitivity); +#define ppu_v1_set_input_edge_sensitivity_ReturnThruPtr_ppu(ppu) ppu_v1_set_input_edge_sensitivity_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_set_input_edge_sensitivity_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_set_input_edge_sensitivity_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_set_input_edge_sensitivity_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_set_input_edge_sensitivity_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_set_input_edge_sensitivity_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_set_input_edge_sensitivity_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_set_input_edge_sensitivity_IgnoreArg_ppu() ppu_v1_set_input_edge_sensitivity_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_set_input_edge_sensitivity_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_set_input_edge_sensitivity_IgnoreArg_ppu_mode() ppu_v1_set_input_edge_sensitivity_CMockIgnoreArg_ppu_mode(__LINE__) @@ -646,17 +646,17 @@ void ppu_v1_get_input_edge_sensitivity_CMockStopIgnore(void); #define ppu_v1_get_input_edge_sensitivity_ExpectAnyArgsAndReturn(cmock_retval) ppu_v1_get_input_edge_sensitivity_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) void ppu_v1_get_input_edge_sensitivity_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, enum ppu_v1_edge_sensitivity cmock_to_return); #define ppu_v1_get_input_edge_sensitivity_ExpectAndReturn(ppu, ppu_mode, cmock_retval) ppu_v1_get_input_edge_sensitivity_CMockExpectAndReturn(__LINE__, ppu, ppu_mode, cmock_retval) -void ppu_v1_get_input_edge_sensitivity_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity cmock_to_return); -typedef enum ppu_v1_edge_sensitivity (* CMOCK_ppu_v1_get_input_edge_sensitivity_CALLBACK)(struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, int cmock_num_calls); +void ppu_v1_get_input_edge_sensitivity_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity cmock_to_return); +typedef enum ppu_v1_edge_sensitivity (* CMOCK_ppu_v1_get_input_edge_sensitivity_CALLBACK)(struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode, int cmock_num_calls); void ppu_v1_get_input_edge_sensitivity_AddCallback(CMOCK_ppu_v1_get_input_edge_sensitivity_CALLBACK Callback); void ppu_v1_get_input_edge_sensitivity_Stub(CMOCK_ppu_v1_get_input_edge_sensitivity_CALLBACK Callback); #define ppu_v1_get_input_edge_sensitivity_StubWithCallback ppu_v1_get_input_edge_sensitivity_Stub #define ppu_v1_get_input_edge_sensitivity_ExpectWithArrayAndReturn(ppu, ppu_Depth, ppu_mode, cmock_retval) ppu_v1_get_input_edge_sensitivity_CMockExpectWithArrayAndReturn(__LINE__, ppu, ppu_Depth, ppu_mode, cmock_retval) -void ppu_v1_get_input_edge_sensitivity_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity cmock_to_return); -#define ppu_v1_get_input_edge_sensitivity_ReturnThruPtr_ppu(ppu) ppu_v1_get_input_edge_sensitivity_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_get_input_edge_sensitivity_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity cmock_to_return); +#define ppu_v1_get_input_edge_sensitivity_ReturnThruPtr_ppu(ppu) ppu_v1_get_input_edge_sensitivity_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_get_input_edge_sensitivity_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_get_input_edge_sensitivity_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_get_input_edge_sensitivity_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_get_input_edge_sensitivity_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_get_input_edge_sensitivity_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_get_input_edge_sensitivity_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_get_input_edge_sensitivity_IgnoreArg_ppu() ppu_v1_get_input_edge_sensitivity_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_get_input_edge_sensitivity_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_get_input_edge_sensitivity_IgnoreArg_ppu_mode() ppu_v1_get_input_edge_sensitivity_CMockIgnoreArg_ppu_mode(__LINE__) @@ -668,17 +668,17 @@ void ppu_v1_ack_power_active_edge_interrupt_CMockStopIgnore(void); #define ppu_v1_ack_power_active_edge_interrupt_ExpectAnyArgs() ppu_v1_ack_power_active_edge_interrupt_CMockExpectAnyArgs(__LINE__) void ppu_v1_ack_power_active_edge_interrupt_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); #define ppu_v1_ack_power_active_edge_interrupt_Expect(ppu, ppu_mode) ppu_v1_ack_power_active_edge_interrupt_CMockExpect(__LINE__, ppu, ppu_mode) -void ppu_v1_ack_power_active_edge_interrupt_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode); -typedef void (* CMOCK_ppu_v1_ack_power_active_edge_interrupt_CALLBACK)(struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, int cmock_num_calls); +void ppu_v1_ack_power_active_edge_interrupt_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode); +typedef void (* CMOCK_ppu_v1_ack_power_active_edge_interrupt_CALLBACK)(struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode, int cmock_num_calls); void ppu_v1_ack_power_active_edge_interrupt_AddCallback(CMOCK_ppu_v1_ack_power_active_edge_interrupt_CALLBACK Callback); void ppu_v1_ack_power_active_edge_interrupt_Stub(CMOCK_ppu_v1_ack_power_active_edge_interrupt_CALLBACK Callback); #define ppu_v1_ack_power_active_edge_interrupt_StubWithCallback ppu_v1_ack_power_active_edge_interrupt_Stub #define ppu_v1_ack_power_active_edge_interrupt_ExpectWithArray(ppu, ppu_Depth, ppu_mode) ppu_v1_ack_power_active_edge_interrupt_CMockExpectWithArray(__LINE__, ppu, ppu_Depth, ppu_mode) -void ppu_v1_ack_power_active_edge_interrupt_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode); -#define ppu_v1_ack_power_active_edge_interrupt_ReturnThruPtr_ppu(ppu) ppu_v1_ack_power_active_edge_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_ack_power_active_edge_interrupt_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode); +#define ppu_v1_ack_power_active_edge_interrupt_ReturnThruPtr_ppu(ppu) ppu_v1_ack_power_active_edge_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_ack_power_active_edge_interrupt_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_ack_power_active_edge_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_ack_power_active_edge_interrupt_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_ack_power_active_edge_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_ack_power_active_edge_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_ack_power_active_edge_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_ack_power_active_edge_interrupt_IgnoreArg_ppu() ppu_v1_ack_power_active_edge_interrupt_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_ack_power_active_edge_interrupt_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_ack_power_active_edge_interrupt_IgnoreArg_ppu_mode() ppu_v1_ack_power_active_edge_interrupt_CMockIgnoreArg_ppu_mode(__LINE__) @@ -690,17 +690,17 @@ void ppu_v1_is_power_active_edge_interrupt_CMockStopIgnore(void); #define ppu_v1_is_power_active_edge_interrupt_ExpectAnyArgsAndReturn(cmock_retval) ppu_v1_is_power_active_edge_interrupt_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) void ppu_v1_is_power_active_edge_interrupt_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return); #define ppu_v1_is_power_active_edge_interrupt_ExpectAndReturn(ppu, ppu_mode, cmock_retval) ppu_v1_is_power_active_edge_interrupt_CMockExpectAndReturn(__LINE__, ppu, ppu_mode, cmock_retval) -void ppu_v1_is_power_active_edge_interrupt_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, bool cmock_to_return); -typedef bool (* CMOCK_ppu_v1_is_power_active_edge_interrupt_CALLBACK)(struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, int cmock_num_calls); +void ppu_v1_is_power_active_edge_interrupt_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode, bool cmock_to_return); +typedef bool (* CMOCK_ppu_v1_is_power_active_edge_interrupt_CALLBACK)(struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode, int cmock_num_calls); void ppu_v1_is_power_active_edge_interrupt_AddCallback(CMOCK_ppu_v1_is_power_active_edge_interrupt_CALLBACK Callback); void ppu_v1_is_power_active_edge_interrupt_Stub(CMOCK_ppu_v1_is_power_active_edge_interrupt_CALLBACK Callback); #define ppu_v1_is_power_active_edge_interrupt_StubWithCallback ppu_v1_is_power_active_edge_interrupt_Stub #define ppu_v1_is_power_active_edge_interrupt_ExpectWithArrayAndReturn(ppu, ppu_Depth, ppu_mode, cmock_retval) ppu_v1_is_power_active_edge_interrupt_CMockExpectWithArrayAndReturn(__LINE__, ppu, ppu_Depth, ppu_mode, cmock_retval) -void ppu_v1_is_power_active_edge_interrupt_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, bool cmock_to_return); -#define ppu_v1_is_power_active_edge_interrupt_ReturnThruPtr_ppu(ppu) ppu_v1_is_power_active_edge_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_is_power_active_edge_interrupt_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, bool cmock_to_return); +#define ppu_v1_is_power_active_edge_interrupt_ReturnThruPtr_ppu(ppu) ppu_v1_is_power_active_edge_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_is_power_active_edge_interrupt_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_is_power_active_edge_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_is_power_active_edge_interrupt_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_is_power_active_edge_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_is_power_active_edge_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_is_power_active_edge_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_is_power_active_edge_interrupt_IgnoreArg_ppu() ppu_v1_is_power_active_edge_interrupt_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_is_power_active_edge_interrupt_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_is_power_active_edge_interrupt_IgnoreArg_ppu_mode() ppu_v1_is_power_active_edge_interrupt_CMockIgnoreArg_ppu_mode(__LINE__) @@ -712,17 +712,17 @@ void ppu_v1_set_op_active_edge_sensitivity_CMockStopIgnore(void); #define ppu_v1_set_op_active_edge_sensitivity_ExpectAnyArgs() ppu_v1_set_op_active_edge_sensitivity_CMockExpectAnyArgs(__LINE__) void ppu_v1_set_op_active_edge_sensitivity_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); #define ppu_v1_set_op_active_edge_sensitivity_Expect(ppu, op_devactive, edge_sensitivity) ppu_v1_set_op_active_edge_sensitivity_CMockExpect(__LINE__, ppu, op_devactive, edge_sensitivity) -void ppu_v1_set_op_active_edge_sensitivity_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity edge_sensitivity); -typedef void (* CMOCK_ppu_v1_set_op_active_edge_sensitivity_CALLBACK)(struct ppu_v1_reg* ppu, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity edge_sensitivity, int cmock_num_calls); +void ppu_v1_set_op_active_edge_sensitivity_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity edge_sensitivity); +typedef void (* CMOCK_ppu_v1_set_op_active_edge_sensitivity_CALLBACK)(struct ppu_v1_regs* ppu, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity edge_sensitivity, int cmock_num_calls); void ppu_v1_set_op_active_edge_sensitivity_AddCallback(CMOCK_ppu_v1_set_op_active_edge_sensitivity_CALLBACK Callback); void ppu_v1_set_op_active_edge_sensitivity_Stub(CMOCK_ppu_v1_set_op_active_edge_sensitivity_CALLBACK Callback); #define ppu_v1_set_op_active_edge_sensitivity_StubWithCallback ppu_v1_set_op_active_edge_sensitivity_Stub #define ppu_v1_set_op_active_edge_sensitivity_ExpectWithArray(ppu, ppu_Depth, op_devactive, edge_sensitivity) ppu_v1_set_op_active_edge_sensitivity_CMockExpectWithArray(__LINE__, ppu, ppu_Depth, op_devactive, edge_sensitivity) -void ppu_v1_set_op_active_edge_sensitivity_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity edge_sensitivity); -#define ppu_v1_set_op_active_edge_sensitivity_ReturnThruPtr_ppu(ppu) ppu_v1_set_op_active_edge_sensitivity_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_set_op_active_edge_sensitivity_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity edge_sensitivity); +#define ppu_v1_set_op_active_edge_sensitivity_ReturnThruPtr_ppu(ppu) ppu_v1_set_op_active_edge_sensitivity_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_set_op_active_edge_sensitivity_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_set_op_active_edge_sensitivity_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_set_op_active_edge_sensitivity_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_set_op_active_edge_sensitivity_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_set_op_active_edge_sensitivity_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_set_op_active_edge_sensitivity_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_set_op_active_edge_sensitivity_IgnoreArg_ppu() ppu_v1_set_op_active_edge_sensitivity_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_set_op_active_edge_sensitivity_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_set_op_active_edge_sensitivity_IgnoreArg_op_devactive() ppu_v1_set_op_active_edge_sensitivity_CMockIgnoreArg_op_devactive(__LINE__) @@ -736,17 +736,17 @@ void ppu_v1_get_op_active_edge_sensitivity_CMockStopIgnore(void); #define ppu_v1_get_op_active_edge_sensitivity_ExpectAnyArgsAndReturn(cmock_retval) ppu_v1_get_op_active_edge_sensitivity_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) void ppu_v1_get_op_active_edge_sensitivity_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, enum ppu_v1_edge_sensitivity cmock_to_return); #define ppu_v1_get_op_active_edge_sensitivity_ExpectAndReturn(ppu, op_devactive, cmock_retval) ppu_v1_get_op_active_edge_sensitivity_CMockExpectAndReturn(__LINE__, ppu, op_devactive, cmock_retval) -void ppu_v1_get_op_active_edge_sensitivity_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity cmock_to_return); -typedef enum ppu_v1_edge_sensitivity (* CMOCK_ppu_v1_get_op_active_edge_sensitivity_CALLBACK)(struct ppu_v1_reg* ppu, enum ppu_v1_op_devactive op_devactive, int cmock_num_calls); +void ppu_v1_get_op_active_edge_sensitivity_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity cmock_to_return); +typedef enum ppu_v1_edge_sensitivity (* CMOCK_ppu_v1_get_op_active_edge_sensitivity_CALLBACK)(struct ppu_v1_regs* ppu, enum ppu_v1_op_devactive op_devactive, int cmock_num_calls); void ppu_v1_get_op_active_edge_sensitivity_AddCallback(CMOCK_ppu_v1_get_op_active_edge_sensitivity_CALLBACK Callback); void ppu_v1_get_op_active_edge_sensitivity_Stub(CMOCK_ppu_v1_get_op_active_edge_sensitivity_CALLBACK Callback); #define ppu_v1_get_op_active_edge_sensitivity_StubWithCallback ppu_v1_get_op_active_edge_sensitivity_Stub #define ppu_v1_get_op_active_edge_sensitivity_ExpectWithArrayAndReturn(ppu, ppu_Depth, op_devactive, cmock_retval) ppu_v1_get_op_active_edge_sensitivity_CMockExpectWithArrayAndReturn(__LINE__, ppu, ppu_Depth, op_devactive, cmock_retval) -void ppu_v1_get_op_active_edge_sensitivity_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity cmock_to_return); -#define ppu_v1_get_op_active_edge_sensitivity_ReturnThruPtr_ppu(ppu) ppu_v1_get_op_active_edge_sensitivity_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_get_op_active_edge_sensitivity_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity cmock_to_return); +#define ppu_v1_get_op_active_edge_sensitivity_ReturnThruPtr_ppu(ppu) ppu_v1_get_op_active_edge_sensitivity_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_get_op_active_edge_sensitivity_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_get_op_active_edge_sensitivity_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_get_op_active_edge_sensitivity_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_get_op_active_edge_sensitivity_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_get_op_active_edge_sensitivity_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_get_op_active_edge_sensitivity_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_get_op_active_edge_sensitivity_IgnoreArg_ppu() ppu_v1_get_op_active_edge_sensitivity_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_get_op_active_edge_sensitivity_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_get_op_active_edge_sensitivity_IgnoreArg_op_devactive() ppu_v1_get_op_active_edge_sensitivity_CMockIgnoreArg_op_devactive(__LINE__) @@ -758,17 +758,17 @@ void ppu_v1_ack_op_active_edge_interrupt_CMockStopIgnore(void); #define ppu_v1_ack_op_active_edge_interrupt_ExpectAnyArgs() ppu_v1_ack_op_active_edge_interrupt_CMockExpectAnyArgs(__LINE__) void ppu_v1_ack_op_active_edge_interrupt_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); #define ppu_v1_ack_op_active_edge_interrupt_Expect(ppu, op_devactive) ppu_v1_ack_op_active_edge_interrupt_CMockExpect(__LINE__, ppu, op_devactive) -void ppu_v1_ack_op_active_edge_interrupt_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_op_devactive op_devactive); -typedef void (* CMOCK_ppu_v1_ack_op_active_edge_interrupt_CALLBACK)(struct ppu_v1_reg* ppu, enum ppu_v1_op_devactive op_devactive, int cmock_num_calls); +void ppu_v1_ack_op_active_edge_interrupt_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_op_devactive op_devactive); +typedef void (* CMOCK_ppu_v1_ack_op_active_edge_interrupt_CALLBACK)(struct ppu_v1_regs* ppu, enum ppu_v1_op_devactive op_devactive, int cmock_num_calls); void ppu_v1_ack_op_active_edge_interrupt_AddCallback(CMOCK_ppu_v1_ack_op_active_edge_interrupt_CALLBACK Callback); void ppu_v1_ack_op_active_edge_interrupt_Stub(CMOCK_ppu_v1_ack_op_active_edge_interrupt_CALLBACK Callback); #define ppu_v1_ack_op_active_edge_interrupt_StubWithCallback ppu_v1_ack_op_active_edge_interrupt_Stub #define ppu_v1_ack_op_active_edge_interrupt_ExpectWithArray(ppu, ppu_Depth, op_devactive) ppu_v1_ack_op_active_edge_interrupt_CMockExpectWithArray(__LINE__, ppu, ppu_Depth, op_devactive) -void ppu_v1_ack_op_active_edge_interrupt_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive); -#define ppu_v1_ack_op_active_edge_interrupt_ReturnThruPtr_ppu(ppu) ppu_v1_ack_op_active_edge_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_ack_op_active_edge_interrupt_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive); +#define ppu_v1_ack_op_active_edge_interrupt_ReturnThruPtr_ppu(ppu) ppu_v1_ack_op_active_edge_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_ack_op_active_edge_interrupt_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_ack_op_active_edge_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_ack_op_active_edge_interrupt_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_ack_op_active_edge_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_ack_op_active_edge_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_ack_op_active_edge_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_ack_op_active_edge_interrupt_IgnoreArg_ppu() ppu_v1_ack_op_active_edge_interrupt_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_ack_op_active_edge_interrupt_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_ack_op_active_edge_interrupt_IgnoreArg_op_devactive() ppu_v1_ack_op_active_edge_interrupt_CMockIgnoreArg_op_devactive(__LINE__) @@ -780,17 +780,17 @@ void ppu_v1_is_op_active_edge_interrupt_CMockStopIgnore(void); #define ppu_v1_is_op_active_edge_interrupt_ExpectAnyArgsAndReturn(cmock_retval) ppu_v1_is_op_active_edge_interrupt_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) void ppu_v1_is_op_active_edge_interrupt_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return); #define ppu_v1_is_op_active_edge_interrupt_ExpectAndReturn(ppu, op_devactive, cmock_retval) ppu_v1_is_op_active_edge_interrupt_CMockExpectAndReturn(__LINE__, ppu, op_devactive, cmock_retval) -void ppu_v1_is_op_active_edge_interrupt_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_op_devactive op_devactive, bool cmock_to_return); -typedef bool (* CMOCK_ppu_v1_is_op_active_edge_interrupt_CALLBACK)(struct ppu_v1_reg* ppu, enum ppu_v1_op_devactive op_devactive, int cmock_num_calls); +void ppu_v1_is_op_active_edge_interrupt_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_op_devactive op_devactive, bool cmock_to_return); +typedef bool (* CMOCK_ppu_v1_is_op_active_edge_interrupt_CALLBACK)(struct ppu_v1_regs* ppu, enum ppu_v1_op_devactive op_devactive, int cmock_num_calls); void ppu_v1_is_op_active_edge_interrupt_AddCallback(CMOCK_ppu_v1_is_op_active_edge_interrupt_CALLBACK Callback); void ppu_v1_is_op_active_edge_interrupt_Stub(CMOCK_ppu_v1_is_op_active_edge_interrupt_CALLBACK Callback); #define ppu_v1_is_op_active_edge_interrupt_StubWithCallback ppu_v1_is_op_active_edge_interrupt_Stub #define ppu_v1_is_op_active_edge_interrupt_ExpectWithArrayAndReturn(ppu, ppu_Depth, op_devactive, cmock_retval) ppu_v1_is_op_active_edge_interrupt_CMockExpectWithArrayAndReturn(__LINE__, ppu, ppu_Depth, op_devactive, cmock_retval) -void ppu_v1_is_op_active_edge_interrupt_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive, bool cmock_to_return); -#define ppu_v1_is_op_active_edge_interrupt_ReturnThruPtr_ppu(ppu) ppu_v1_is_op_active_edge_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_is_op_active_edge_interrupt_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive, bool cmock_to_return); +#define ppu_v1_is_op_active_edge_interrupt_ReturnThruPtr_ppu(ppu) ppu_v1_is_op_active_edge_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_is_op_active_edge_interrupt_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_is_op_active_edge_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_is_op_active_edge_interrupt_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_is_op_active_edge_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_is_op_active_edge_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_is_op_active_edge_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_is_op_active_edge_interrupt_IgnoreArg_ppu() ppu_v1_is_op_active_edge_interrupt_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_is_op_active_edge_interrupt_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_is_op_active_edge_interrupt_IgnoreArg_op_devactive() ppu_v1_is_op_active_edge_interrupt_CMockIgnoreArg_op_devactive(__LINE__) @@ -802,17 +802,17 @@ void ppu_v1_is_dyn_policy_min_interrupt_CMockStopIgnore(void); #define ppu_v1_is_dyn_policy_min_interrupt_ExpectAnyArgsAndReturn(cmock_retval) ppu_v1_is_dyn_policy_min_interrupt_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) void ppu_v1_is_dyn_policy_min_interrupt_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return); #define ppu_v1_is_dyn_policy_min_interrupt_ExpectAndReturn(ppu, cmock_retval) ppu_v1_is_dyn_policy_min_interrupt_CMockExpectAndReturn(__LINE__, ppu, cmock_retval) -void ppu_v1_is_dyn_policy_min_interrupt_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, bool cmock_to_return); -typedef bool (* CMOCK_ppu_v1_is_dyn_policy_min_interrupt_CALLBACK)(struct ppu_v1_reg* ppu, int cmock_num_calls); +void ppu_v1_is_dyn_policy_min_interrupt_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, bool cmock_to_return); +typedef bool (* CMOCK_ppu_v1_is_dyn_policy_min_interrupt_CALLBACK)(struct ppu_v1_regs* ppu, int cmock_num_calls); void ppu_v1_is_dyn_policy_min_interrupt_AddCallback(CMOCK_ppu_v1_is_dyn_policy_min_interrupt_CALLBACK Callback); void ppu_v1_is_dyn_policy_min_interrupt_Stub(CMOCK_ppu_v1_is_dyn_policy_min_interrupt_CALLBACK Callback); #define ppu_v1_is_dyn_policy_min_interrupt_StubWithCallback ppu_v1_is_dyn_policy_min_interrupt_Stub #define ppu_v1_is_dyn_policy_min_interrupt_ExpectWithArrayAndReturn(ppu, ppu_Depth, cmock_retval) ppu_v1_is_dyn_policy_min_interrupt_CMockExpectWithArrayAndReturn(__LINE__, ppu, ppu_Depth, cmock_retval) -void ppu_v1_is_dyn_policy_min_interrupt_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, bool cmock_to_return); -#define ppu_v1_is_dyn_policy_min_interrupt_ReturnThruPtr_ppu(ppu) ppu_v1_is_dyn_policy_min_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_is_dyn_policy_min_interrupt_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, bool cmock_to_return); +#define ppu_v1_is_dyn_policy_min_interrupt_ReturnThruPtr_ppu(ppu) ppu_v1_is_dyn_policy_min_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_is_dyn_policy_min_interrupt_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_is_dyn_policy_min_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_is_dyn_policy_min_interrupt_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_is_dyn_policy_min_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_is_dyn_policy_min_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_is_dyn_policy_min_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_is_dyn_policy_min_interrupt_IgnoreArg_ppu() ppu_v1_is_dyn_policy_min_interrupt_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_is_dyn_policy_min_interrupt_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_get_num_opmode_IgnoreAndReturn(cmock_retval) ppu_v1_get_num_opmode_CMockIgnoreAndReturn(__LINE__, cmock_retval) @@ -822,17 +822,17 @@ void ppu_v1_get_num_opmode_CMockStopIgnore(void); #define ppu_v1_get_num_opmode_ExpectAnyArgsAndReturn(cmock_retval) ppu_v1_get_num_opmode_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) void ppu_v1_get_num_opmode_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, unsigned int cmock_to_return); #define ppu_v1_get_num_opmode_ExpectAndReturn(ppu, cmock_retval) ppu_v1_get_num_opmode_CMockExpectAndReturn(__LINE__, ppu, cmock_retval) -void ppu_v1_get_num_opmode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, unsigned int cmock_to_return); -typedef unsigned int (* CMOCK_ppu_v1_get_num_opmode_CALLBACK)(struct ppu_v1_reg* ppu, int cmock_num_calls); +void ppu_v1_get_num_opmode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, unsigned int cmock_to_return); +typedef unsigned int (* CMOCK_ppu_v1_get_num_opmode_CALLBACK)(struct ppu_v1_regs* ppu, int cmock_num_calls); void ppu_v1_get_num_opmode_AddCallback(CMOCK_ppu_v1_get_num_opmode_CALLBACK Callback); void ppu_v1_get_num_opmode_Stub(CMOCK_ppu_v1_get_num_opmode_CALLBACK Callback); #define ppu_v1_get_num_opmode_StubWithCallback ppu_v1_get_num_opmode_Stub #define ppu_v1_get_num_opmode_ExpectWithArrayAndReturn(ppu, ppu_Depth, cmock_retval) ppu_v1_get_num_opmode_CMockExpectWithArrayAndReturn(__LINE__, ppu, ppu_Depth, cmock_retval) -void ppu_v1_get_num_opmode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int cmock_to_return); -#define ppu_v1_get_num_opmode_ReturnThruPtr_ppu(ppu) ppu_v1_get_num_opmode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_get_num_opmode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int cmock_to_return); +#define ppu_v1_get_num_opmode_ReturnThruPtr_ppu(ppu) ppu_v1_get_num_opmode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_get_num_opmode_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_get_num_opmode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_get_num_opmode_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_get_num_opmode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_get_num_opmode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_get_num_opmode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_get_num_opmode_IgnoreArg_ppu() ppu_v1_get_num_opmode_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_get_num_opmode_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_get_arch_id_IgnoreAndReturn(cmock_retval) ppu_v1_get_arch_id_CMockIgnoreAndReturn(__LINE__, cmock_retval) @@ -842,17 +842,17 @@ void ppu_v1_get_arch_id_CMockStopIgnore(void); #define ppu_v1_get_arch_id_ExpectAnyArgsAndReturn(cmock_retval) ppu_v1_get_arch_id_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) void ppu_v1_get_arch_id_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, unsigned int cmock_to_return); #define ppu_v1_get_arch_id_ExpectAndReturn(ppu, cmock_retval) ppu_v1_get_arch_id_CMockExpectAndReturn(__LINE__, ppu, cmock_retval) -void ppu_v1_get_arch_id_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, unsigned int cmock_to_return); -typedef unsigned int (* CMOCK_ppu_v1_get_arch_id_CALLBACK)(struct ppu_v1_reg* ppu, int cmock_num_calls); +void ppu_v1_get_arch_id_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, unsigned int cmock_to_return); +typedef unsigned int (* CMOCK_ppu_v1_get_arch_id_CALLBACK)(struct ppu_v1_regs* ppu, int cmock_num_calls); void ppu_v1_get_arch_id_AddCallback(CMOCK_ppu_v1_get_arch_id_CALLBACK Callback); void ppu_v1_get_arch_id_Stub(CMOCK_ppu_v1_get_arch_id_CALLBACK Callback); #define ppu_v1_get_arch_id_StubWithCallback ppu_v1_get_arch_id_Stub #define ppu_v1_get_arch_id_ExpectWithArrayAndReturn(ppu, ppu_Depth, cmock_retval) ppu_v1_get_arch_id_CMockExpectWithArrayAndReturn(__LINE__, ppu, ppu_Depth, cmock_retval) -void ppu_v1_get_arch_id_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int cmock_to_return); -#define ppu_v1_get_arch_id_ReturnThruPtr_ppu(ppu) ppu_v1_get_arch_id_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_get_arch_id_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int cmock_to_return); +#define ppu_v1_get_arch_id_ReturnThruPtr_ppu(ppu) ppu_v1_get_arch_id_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_get_arch_id_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_get_arch_id_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_get_arch_id_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_get_arch_id_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_get_arch_id_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_get_arch_id_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_get_arch_id_IgnoreArg_ppu() ppu_v1_get_arch_id_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_get_arch_id_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); diff --git a/module/ppu_v1/test/mocks/Mockppu_v1.c b/module/ppu_v1/test/mocks/Mockppu_v1.c index 0e6b53c9d..a9a83e1e8 100644 --- a/module/ppu_v1/test/mocks/Mockppu_v1.c +++ b/module/ppu_v1/test/mocks/Mockppu_v1.c @@ -56,10 +56,10 @@ typedef struct _CMOCK_ppu_v1_init_CALL_INSTANCE { UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; @@ -70,13 +70,13 @@ typedef struct _CMOCK_ppu_v1_set_power_mode_CALL_INSTANCE UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; int ReturnVal; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; enum ppu_v1_mode Expected_ppu_mode; struct ppu_v1_timer_ctx* Expected_timer_ctx; int Expected_ppu_Depth; int Expected_timer_ctx_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char ReturnThruPtr_timer_ctx_Used; struct ppu_v1_timer_ctx* ReturnThruPtr_timer_ctx_Val; @@ -92,11 +92,11 @@ typedef struct _CMOCK_ppu_v1_request_power_mode_CALL_INSTANCE UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; int ReturnVal; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; enum ppu_v1_mode Expected_ppu_mode; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; char IgnoreArg_ppu_mode; @@ -108,11 +108,11 @@ typedef struct _CMOCK_ppu_v1_request_operating_mode_CALL_INSTANCE UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; int ReturnVal; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; enum ppu_v1_opmode Expected_op_mode; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; char IgnoreArg_op_mode; @@ -123,11 +123,11 @@ typedef struct _CMOCK_ppu_v1_opmode_dynamic_enable_CALL_INSTANCE { UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; enum ppu_v1_opmode Expected_min_dyn_mode; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; char IgnoreArg_min_dyn_mode; @@ -138,11 +138,11 @@ typedef struct _CMOCK_ppu_v1_dynamic_enable_CALL_INSTANCE { UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; enum ppu_v1_mode Expected_min_dyn_state; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; char IgnoreArg_min_dyn_state; @@ -153,10 +153,10 @@ typedef struct _CMOCK_ppu_v1_lock_off_enable_CALL_INSTANCE { UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; @@ -166,10 +166,10 @@ typedef struct _CMOCK_ppu_v1_lock_off_disable_CALL_INSTANCE { UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; @@ -180,10 +180,10 @@ typedef struct _CMOCK_ppu_v1_get_power_mode_CALL_INSTANCE UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; enum ppu_v1_mode ReturnVal; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; @@ -194,10 +194,10 @@ typedef struct _CMOCK_ppu_v1_get_programmed_power_mode_CALL_INSTANCE UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; enum ppu_v1_mode ReturnVal; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; @@ -208,10 +208,10 @@ typedef struct _CMOCK_ppu_v1_get_operating_mode_CALL_INSTANCE UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; enum ppu_v1_opmode ReturnVal; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; @@ -222,10 +222,10 @@ typedef struct _CMOCK_ppu_v1_get_programmed_operating_mode_CALL_INSTANCE UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; enum ppu_v1_opmode ReturnVal; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; @@ -236,10 +236,10 @@ typedef struct _CMOCK_ppu_v1_is_dynamic_enabled_CALL_INSTANCE UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; bool ReturnVal; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; @@ -250,10 +250,10 @@ typedef struct _CMOCK_ppu_v1_is_locked_CALL_INSTANCE UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; bool ReturnVal; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; @@ -264,11 +264,11 @@ typedef struct _CMOCK_ppu_v1_is_power_devactive_high_CALL_INSTANCE UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; bool ReturnVal; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; enum ppu_v1_mode Expected_ppu_mode; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; char IgnoreArg_ppu_mode; @@ -280,11 +280,11 @@ typedef struct _CMOCK_ppu_v1_is_op_devactive_high_CALL_INSTANCE UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; bool ReturnVal; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; enum ppu_v1_op_devactive Expected_op_devactive; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; char IgnoreArg_op_devactive; @@ -295,10 +295,10 @@ typedef struct _CMOCK_ppu_v1_off_unlock_CALL_INSTANCE { UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; @@ -308,10 +308,10 @@ typedef struct _CMOCK_ppu_v1_disable_devactive_CALL_INSTANCE { UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; @@ -321,10 +321,10 @@ typedef struct _CMOCK_ppu_v1_disable_handshake_CALL_INSTANCE { UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; @@ -334,11 +334,11 @@ typedef struct _CMOCK_ppu_v1_interrupt_mask_CALL_INSTANCE { UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; unsigned int Expected_mask; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; char IgnoreArg_mask; @@ -349,11 +349,11 @@ typedef struct _CMOCK_ppu_v1_additional_interrupt_mask_CALL_INSTANCE { UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; unsigned int Expected_mask; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; char IgnoreArg_mask; @@ -364,11 +364,11 @@ typedef struct _CMOCK_ppu_v1_interrupt_unmask_CALL_INSTANCE { UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; unsigned int Expected_mask; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; char IgnoreArg_mask; @@ -379,11 +379,11 @@ typedef struct _CMOCK_ppu_v1_additional_interrupt_unmask_CALL_INSTANCE { UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; unsigned int Expected_mask; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; char IgnoreArg_mask; @@ -395,11 +395,11 @@ typedef struct _CMOCK_ppu_v1_is_additional_interrupt_pending_CALL_INSTANCE UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; bool ReturnVal; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; unsigned int Expected_mask; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; char IgnoreArg_mask; @@ -410,11 +410,11 @@ typedef struct _CMOCK_ppu_v1_ack_interrupt_CALL_INSTANCE { UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; unsigned int Expected_mask; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; char IgnoreArg_mask; @@ -425,11 +425,11 @@ typedef struct _CMOCK_ppu_v1_ack_additional_interrupt_CALL_INSTANCE { UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; unsigned int Expected_mask; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; char IgnoreArg_mask; @@ -440,12 +440,12 @@ typedef struct _CMOCK_ppu_v1_set_input_edge_sensitivity_CALL_INSTANCE { UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; enum ppu_v1_mode Expected_ppu_mode; enum ppu_v1_edge_sensitivity Expected_edge_sensitivity; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; char IgnoreArg_ppu_mode; @@ -458,11 +458,11 @@ typedef struct _CMOCK_ppu_v1_get_input_edge_sensitivity_CALL_INSTANCE UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; enum ppu_v1_edge_sensitivity ReturnVal; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; enum ppu_v1_mode Expected_ppu_mode; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; char IgnoreArg_ppu_mode; @@ -473,11 +473,11 @@ typedef struct _CMOCK_ppu_v1_ack_power_active_edge_interrupt_CALL_INSTANCE { UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; enum ppu_v1_mode Expected_ppu_mode; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; char IgnoreArg_ppu_mode; @@ -489,11 +489,11 @@ typedef struct _CMOCK_ppu_v1_is_power_active_edge_interrupt_CALL_INSTANCE UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; bool ReturnVal; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; enum ppu_v1_mode Expected_ppu_mode; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; char IgnoreArg_ppu_mode; @@ -504,12 +504,12 @@ typedef struct _CMOCK_ppu_v1_set_op_active_edge_sensitivity_CALL_INSTANCE { UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; enum ppu_v1_op_devactive Expected_op_devactive; enum ppu_v1_edge_sensitivity Expected_edge_sensitivity; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; char IgnoreArg_op_devactive; @@ -522,11 +522,11 @@ typedef struct _CMOCK_ppu_v1_get_op_active_edge_sensitivity_CALL_INSTANCE UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; enum ppu_v1_edge_sensitivity ReturnVal; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; enum ppu_v1_op_devactive Expected_op_devactive; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; char IgnoreArg_op_devactive; @@ -537,11 +537,11 @@ typedef struct _CMOCK_ppu_v1_ack_op_active_edge_interrupt_CALL_INSTANCE { UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; enum ppu_v1_op_devactive Expected_op_devactive; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; char IgnoreArg_op_devactive; @@ -553,11 +553,11 @@ typedef struct _CMOCK_ppu_v1_is_op_active_edge_interrupt_CALL_INSTANCE UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; bool ReturnVal; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; enum ppu_v1_op_devactive Expected_op_devactive; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; char IgnoreArg_op_devactive; @@ -569,10 +569,10 @@ typedef struct _CMOCK_ppu_v1_is_dyn_policy_min_interrupt_CALL_INSTANCE UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; bool ReturnVal; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; @@ -583,10 +583,10 @@ typedef struct _CMOCK_ppu_v1_get_num_opmode_CALL_INSTANCE UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; unsigned int ReturnVal; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; @@ -597,10 +597,10 @@ typedef struct _CMOCK_ppu_v1_get_arch_id_CALL_INSTANCE UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; unsigned int ReturnVal; - struct ppu_v1_reg* Expected_ppu; + struct ppu_v1_regs* Expected_ppu; int Expected_ppu_Depth; char ReturnThruPtr_ppu_Used; - struct ppu_v1_reg* ReturnThruPtr_ppu_Val; + struct ppu_v1_regs* ReturnThruPtr_ppu_Val; size_t ReturnThruPtr_ppu_Size; char IgnoreArg_ppu; @@ -1314,7 +1314,7 @@ void Mockppu_v1_Destroy(void) memset(&Mock, 0, sizeof(Mock)); } -void ppu_v1_init(struct ppu_v1_reg* ppu) +void ppu_v1_init(struct ppu_v1_regs* ppu) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_init_CALL_INSTANCE* cmock_call_instance; @@ -1343,7 +1343,7 @@ void ppu_v1_init(struct ppu_v1_reg* ppu) if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } } if (Mock.ppu_v1_init_CallbackFunctionPointer != NULL) @@ -1359,8 +1359,8 @@ void ppu_v1_init(struct ppu_v1_reg* ppu) UNITY_CLR_DETAILS(); } -void CMockExpectParameters_ppu_v1_init(CMOCK_ppu_v1_init_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth); -void CMockExpectParameters_ppu_v1_init(CMOCK_ppu_v1_init_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth) +void CMockExpectParameters_ppu_v1_init(CMOCK_ppu_v1_init_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth); +void CMockExpectParameters_ppu_v1_init(CMOCK_ppu_v1_init_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -1391,7 +1391,7 @@ void ppu_v1_init_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_init_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu) +void ppu_v1_init_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_init_CALL_INSTANCE)); CMOCK_ppu_v1_init_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_init_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -1418,7 +1418,7 @@ void ppu_v1_init_Stub(CMOCK_ppu_v1_init_CALLBACK Callback) Mock.ppu_v1_init_CallbackFunctionPointer = Callback; } -void ppu_v1_init_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth) +void ppu_v1_init_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_init_CALL_INSTANCE)); CMOCK_ppu_v1_init_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_init_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -1431,7 +1431,7 @@ void ppu_v1_init_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_ CMockExpectParameters_ppu_v1_init(cmock_call_instance, ppu, ppu_Depth); } -void ppu_v1_init_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_init_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_init_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_init_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_init_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -1447,7 +1447,7 @@ void ppu_v1_init_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line) cmock_call_instance->IgnoreArg_ppu = 1; } -int ppu_v1_set_power_mode(struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, struct ppu_v1_timer_ctx* timer_ctx) +int ppu_v1_set_power_mode(struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode, struct ppu_v1_timer_ctx* timer_ctx) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_set_power_mode_CALL_INSTANCE* cmock_call_instance; @@ -1479,7 +1479,7 @@ int ppu_v1_set_power_mode(struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, str if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_ppu_mode) { @@ -1515,8 +1515,8 @@ int ppu_v1_set_power_mode(struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, str return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_ppu_v1_set_power_mode(CMOCK_ppu_v1_set_power_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, struct ppu_v1_timer_ctx* timer_ctx, int timer_ctx_Depth); -void CMockExpectParameters_ppu_v1_set_power_mode(CMOCK_ppu_v1_set_power_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, struct ppu_v1_timer_ctx* timer_ctx, int timer_ctx_Depth) +void CMockExpectParameters_ppu_v1_set_power_mode(CMOCK_ppu_v1_set_power_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, struct ppu_v1_timer_ctx* timer_ctx, int timer_ctx_Depth); +void CMockExpectParameters_ppu_v1_set_power_mode(CMOCK_ppu_v1_set_power_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, struct ppu_v1_timer_ctx* timer_ctx, int timer_ctx_Depth) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -1566,7 +1566,7 @@ void ppu_v1_set_power_mode_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_lin cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_set_power_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, struct ppu_v1_timer_ctx* timer_ctx, int cmock_to_return) +void ppu_v1_set_power_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode, struct ppu_v1_timer_ctx* timer_ctx, int cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_set_power_mode_CALL_INSTANCE)); CMOCK_ppu_v1_set_power_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_set_power_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -1594,7 +1594,7 @@ void ppu_v1_set_power_mode_Stub(CMOCK_ppu_v1_set_power_mode_CALLBACK Callback) Mock.ppu_v1_set_power_mode_CallbackFunctionPointer = Callback; } -void ppu_v1_set_power_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, struct ppu_v1_timer_ctx* timer_ctx, int timer_ctx_Depth, int cmock_to_return) +void ppu_v1_set_power_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, struct ppu_v1_timer_ctx* timer_ctx, int timer_ctx_Depth, int cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_set_power_mode_CALL_INSTANCE)); CMOCK_ppu_v1_set_power_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_set_power_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -1608,7 +1608,7 @@ void ppu_v1_set_power_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_l cmock_call_instance->ReturnVal = cmock_to_return; } -void ppu_v1_set_power_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_set_power_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_set_power_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_set_power_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_set_power_mode_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -1647,7 +1647,7 @@ void ppu_v1_set_power_mode_CMockIgnoreArg_timer_ctx(UNITY_LINE_TYPE cmock_line) cmock_call_instance->IgnoreArg_timer_ctx = 1; } -int ppu_v1_request_power_mode(struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode) +int ppu_v1_request_power_mode(struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_request_power_mode_CALL_INSTANCE* cmock_call_instance; @@ -1679,7 +1679,7 @@ int ppu_v1_request_power_mode(struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode) if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_ppu_mode) { @@ -1701,8 +1701,8 @@ int ppu_v1_request_power_mode(struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode) return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_ppu_v1_request_power_mode(CMOCK_ppu_v1_request_power_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode); -void CMockExpectParameters_ppu_v1_request_power_mode(CMOCK_ppu_v1_request_power_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode) +void CMockExpectParameters_ppu_v1_request_power_mode(CMOCK_ppu_v1_request_power_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode); +void CMockExpectParameters_ppu_v1_request_power_mode(CMOCK_ppu_v1_request_power_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -1748,7 +1748,7 @@ void ppu_v1_request_power_mode_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_request_power_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, int cmock_to_return) +void ppu_v1_request_power_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode, int cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_request_power_mode_CALL_INSTANCE)); CMOCK_ppu_v1_request_power_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_request_power_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -1776,7 +1776,7 @@ void ppu_v1_request_power_mode_Stub(CMOCK_ppu_v1_request_power_mode_CALLBACK Cal Mock.ppu_v1_request_power_mode_CallbackFunctionPointer = Callback; } -void ppu_v1_request_power_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, int cmock_to_return) +void ppu_v1_request_power_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, int cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_request_power_mode_CALL_INSTANCE)); CMOCK_ppu_v1_request_power_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_request_power_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -1790,7 +1790,7 @@ void ppu_v1_request_power_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmo cmock_call_instance->ReturnVal = cmock_to_return; } -void ppu_v1_request_power_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_request_power_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_request_power_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_request_power_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_request_power_mode_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -1813,7 +1813,7 @@ void ppu_v1_request_power_mode_CMockIgnoreArg_ppu_mode(UNITY_LINE_TYPE cmock_lin cmock_call_instance->IgnoreArg_ppu_mode = 1; } -int ppu_v1_request_operating_mode(struct ppu_v1_reg* ppu, enum ppu_v1_opmode op_mode) +int ppu_v1_request_operating_mode(struct ppu_v1_regs* ppu, enum ppu_v1_opmode op_mode) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_request_operating_mode_CALL_INSTANCE* cmock_call_instance; @@ -1845,7 +1845,7 @@ int ppu_v1_request_operating_mode(struct ppu_v1_reg* ppu, enum ppu_v1_opmode op_ if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_op_mode) { @@ -1867,8 +1867,8 @@ int ppu_v1_request_operating_mode(struct ppu_v1_reg* ppu, enum ppu_v1_opmode op_ return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_ppu_v1_request_operating_mode(CMOCK_ppu_v1_request_operating_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_opmode op_mode); -void CMockExpectParameters_ppu_v1_request_operating_mode(CMOCK_ppu_v1_request_operating_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_opmode op_mode) +void CMockExpectParameters_ppu_v1_request_operating_mode(CMOCK_ppu_v1_request_operating_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_opmode op_mode); +void CMockExpectParameters_ppu_v1_request_operating_mode(CMOCK_ppu_v1_request_operating_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_opmode op_mode) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -1914,7 +1914,7 @@ void ppu_v1_request_operating_mode_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE c cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_request_operating_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_opmode op_mode, int cmock_to_return) +void ppu_v1_request_operating_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_opmode op_mode, int cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_request_operating_mode_CALL_INSTANCE)); CMOCK_ppu_v1_request_operating_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_request_operating_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -1942,7 +1942,7 @@ void ppu_v1_request_operating_mode_Stub(CMOCK_ppu_v1_request_operating_mode_CALL Mock.ppu_v1_request_operating_mode_CallbackFunctionPointer = Callback; } -void ppu_v1_request_operating_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_opmode op_mode, int cmock_to_return) +void ppu_v1_request_operating_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_opmode op_mode, int cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_request_operating_mode_CALL_INSTANCE)); CMOCK_ppu_v1_request_operating_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_request_operating_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -1956,7 +1956,7 @@ void ppu_v1_request_operating_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_call_instance->ReturnVal = cmock_to_return; } -void ppu_v1_request_operating_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_request_operating_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_request_operating_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_request_operating_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_request_operating_mode_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -1979,7 +1979,7 @@ void ppu_v1_request_operating_mode_CMockIgnoreArg_op_mode(UNITY_LINE_TYPE cmock_ cmock_call_instance->IgnoreArg_op_mode = 1; } -void ppu_v1_opmode_dynamic_enable(struct ppu_v1_reg* ppu, enum ppu_v1_opmode min_dyn_mode) +void ppu_v1_opmode_dynamic_enable(struct ppu_v1_regs* ppu, enum ppu_v1_opmode min_dyn_mode) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_opmode_dynamic_enable_CALL_INSTANCE* cmock_call_instance; @@ -2008,7 +2008,7 @@ void ppu_v1_opmode_dynamic_enable(struct ppu_v1_reg* ppu, enum ppu_v1_opmode min if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_min_dyn_mode) { @@ -2029,8 +2029,8 @@ void ppu_v1_opmode_dynamic_enable(struct ppu_v1_reg* ppu, enum ppu_v1_opmode min UNITY_CLR_DETAILS(); } -void CMockExpectParameters_ppu_v1_opmode_dynamic_enable(CMOCK_ppu_v1_opmode_dynamic_enable_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_opmode min_dyn_mode); -void CMockExpectParameters_ppu_v1_opmode_dynamic_enable(CMOCK_ppu_v1_opmode_dynamic_enable_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_opmode min_dyn_mode) +void CMockExpectParameters_ppu_v1_opmode_dynamic_enable(CMOCK_ppu_v1_opmode_dynamic_enable_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_opmode min_dyn_mode); +void CMockExpectParameters_ppu_v1_opmode_dynamic_enable(CMOCK_ppu_v1_opmode_dynamic_enable_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_opmode min_dyn_mode) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -2064,7 +2064,7 @@ void ppu_v1_opmode_dynamic_enable_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_opmode_dynamic_enable_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_opmode min_dyn_mode) +void ppu_v1_opmode_dynamic_enable_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_opmode min_dyn_mode) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_opmode_dynamic_enable_CALL_INSTANCE)); CMOCK_ppu_v1_opmode_dynamic_enable_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_opmode_dynamic_enable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -2091,7 +2091,7 @@ void ppu_v1_opmode_dynamic_enable_Stub(CMOCK_ppu_v1_opmode_dynamic_enable_CALLBA Mock.ppu_v1_opmode_dynamic_enable_CallbackFunctionPointer = Callback; } -void ppu_v1_opmode_dynamic_enable_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_opmode min_dyn_mode) +void ppu_v1_opmode_dynamic_enable_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_opmode min_dyn_mode) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_opmode_dynamic_enable_CALL_INSTANCE)); CMOCK_ppu_v1_opmode_dynamic_enable_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_opmode_dynamic_enable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -2104,7 +2104,7 @@ void ppu_v1_opmode_dynamic_enable_CMockExpectWithArray(UNITY_LINE_TYPE cmock_lin CMockExpectParameters_ppu_v1_opmode_dynamic_enable(cmock_call_instance, ppu, ppu_Depth, min_dyn_mode); } -void ppu_v1_opmode_dynamic_enable_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_opmode_dynamic_enable_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_opmode_dynamic_enable_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_opmode_dynamic_enable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_opmode_dynamic_enable_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -2127,7 +2127,7 @@ void ppu_v1_opmode_dynamic_enable_CMockIgnoreArg_min_dyn_mode(UNITY_LINE_TYPE cm cmock_call_instance->IgnoreArg_min_dyn_mode = 1; } -void ppu_v1_dynamic_enable(struct ppu_v1_reg* ppu, enum ppu_v1_mode min_dyn_state) +void ppu_v1_dynamic_enable(struct ppu_v1_regs* ppu, enum ppu_v1_mode min_dyn_state) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_dynamic_enable_CALL_INSTANCE* cmock_call_instance; @@ -2156,7 +2156,7 @@ void ppu_v1_dynamic_enable(struct ppu_v1_reg* ppu, enum ppu_v1_mode min_dyn_stat if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_min_dyn_state) { @@ -2177,8 +2177,8 @@ void ppu_v1_dynamic_enable(struct ppu_v1_reg* ppu, enum ppu_v1_mode min_dyn_stat UNITY_CLR_DETAILS(); } -void CMockExpectParameters_ppu_v1_dynamic_enable(CMOCK_ppu_v1_dynamic_enable_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode min_dyn_state); -void CMockExpectParameters_ppu_v1_dynamic_enable(CMOCK_ppu_v1_dynamic_enable_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode min_dyn_state) +void CMockExpectParameters_ppu_v1_dynamic_enable(CMOCK_ppu_v1_dynamic_enable_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode min_dyn_state); +void CMockExpectParameters_ppu_v1_dynamic_enable(CMOCK_ppu_v1_dynamic_enable_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode min_dyn_state) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -2212,7 +2212,7 @@ void ppu_v1_dynamic_enable_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_dynamic_enable_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_mode min_dyn_state) +void ppu_v1_dynamic_enable_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_mode min_dyn_state) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_dynamic_enable_CALL_INSTANCE)); CMOCK_ppu_v1_dynamic_enable_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_dynamic_enable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -2239,7 +2239,7 @@ void ppu_v1_dynamic_enable_Stub(CMOCK_ppu_v1_dynamic_enable_CALLBACK Callback) Mock.ppu_v1_dynamic_enable_CallbackFunctionPointer = Callback; } -void ppu_v1_dynamic_enable_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode min_dyn_state) +void ppu_v1_dynamic_enable_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode min_dyn_state) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_dynamic_enable_CALL_INSTANCE)); CMOCK_ppu_v1_dynamic_enable_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_dynamic_enable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -2252,7 +2252,7 @@ void ppu_v1_dynamic_enable_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, stru CMockExpectParameters_ppu_v1_dynamic_enable(cmock_call_instance, ppu, ppu_Depth, min_dyn_state); } -void ppu_v1_dynamic_enable_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_dynamic_enable_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_dynamic_enable_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_dynamic_enable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_dynamic_enable_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -2275,7 +2275,7 @@ void ppu_v1_dynamic_enable_CMockIgnoreArg_min_dyn_state(UNITY_LINE_TYPE cmock_li cmock_call_instance->IgnoreArg_min_dyn_state = 1; } -void ppu_v1_lock_off_enable(struct ppu_v1_reg* ppu) +void ppu_v1_lock_off_enable(struct ppu_v1_regs* ppu) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_lock_off_enable_CALL_INSTANCE* cmock_call_instance; @@ -2304,7 +2304,7 @@ void ppu_v1_lock_off_enable(struct ppu_v1_reg* ppu) if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } } if (Mock.ppu_v1_lock_off_enable_CallbackFunctionPointer != NULL) @@ -2320,8 +2320,8 @@ void ppu_v1_lock_off_enable(struct ppu_v1_reg* ppu) UNITY_CLR_DETAILS(); } -void CMockExpectParameters_ppu_v1_lock_off_enable(CMOCK_ppu_v1_lock_off_enable_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth); -void CMockExpectParameters_ppu_v1_lock_off_enable(CMOCK_ppu_v1_lock_off_enable_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth) +void CMockExpectParameters_ppu_v1_lock_off_enable(CMOCK_ppu_v1_lock_off_enable_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth); +void CMockExpectParameters_ppu_v1_lock_off_enable(CMOCK_ppu_v1_lock_off_enable_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -2352,7 +2352,7 @@ void ppu_v1_lock_off_enable_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_lock_off_enable_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu) +void ppu_v1_lock_off_enable_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_lock_off_enable_CALL_INSTANCE)); CMOCK_ppu_v1_lock_off_enable_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_lock_off_enable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -2379,7 +2379,7 @@ void ppu_v1_lock_off_enable_Stub(CMOCK_ppu_v1_lock_off_enable_CALLBACK Callback) Mock.ppu_v1_lock_off_enable_CallbackFunctionPointer = Callback; } -void ppu_v1_lock_off_enable_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth) +void ppu_v1_lock_off_enable_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_lock_off_enable_CALL_INSTANCE)); CMOCK_ppu_v1_lock_off_enable_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_lock_off_enable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -2392,7 +2392,7 @@ void ppu_v1_lock_off_enable_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, str CMockExpectParameters_ppu_v1_lock_off_enable(cmock_call_instance, ppu, ppu_Depth); } -void ppu_v1_lock_off_enable_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_lock_off_enable_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_lock_off_enable_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_lock_off_enable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_lock_off_enable_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -2408,7 +2408,7 @@ void ppu_v1_lock_off_enable_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line) cmock_call_instance->IgnoreArg_ppu = 1; } -void ppu_v1_lock_off_disable(struct ppu_v1_reg* ppu) +void ppu_v1_lock_off_disable(struct ppu_v1_regs* ppu) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_lock_off_disable_CALL_INSTANCE* cmock_call_instance; @@ -2437,7 +2437,7 @@ void ppu_v1_lock_off_disable(struct ppu_v1_reg* ppu) if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } } if (Mock.ppu_v1_lock_off_disable_CallbackFunctionPointer != NULL) @@ -2453,8 +2453,8 @@ void ppu_v1_lock_off_disable(struct ppu_v1_reg* ppu) UNITY_CLR_DETAILS(); } -void CMockExpectParameters_ppu_v1_lock_off_disable(CMOCK_ppu_v1_lock_off_disable_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth); -void CMockExpectParameters_ppu_v1_lock_off_disable(CMOCK_ppu_v1_lock_off_disable_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth) +void CMockExpectParameters_ppu_v1_lock_off_disable(CMOCK_ppu_v1_lock_off_disable_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth); +void CMockExpectParameters_ppu_v1_lock_off_disable(CMOCK_ppu_v1_lock_off_disable_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -2485,7 +2485,7 @@ void ppu_v1_lock_off_disable_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_lock_off_disable_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu) +void ppu_v1_lock_off_disable_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_lock_off_disable_CALL_INSTANCE)); CMOCK_ppu_v1_lock_off_disable_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_lock_off_disable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -2512,7 +2512,7 @@ void ppu_v1_lock_off_disable_Stub(CMOCK_ppu_v1_lock_off_disable_CALLBACK Callbac Mock.ppu_v1_lock_off_disable_CallbackFunctionPointer = Callback; } -void ppu_v1_lock_off_disable_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth) +void ppu_v1_lock_off_disable_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_lock_off_disable_CALL_INSTANCE)); CMOCK_ppu_v1_lock_off_disable_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_lock_off_disable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -2525,7 +2525,7 @@ void ppu_v1_lock_off_disable_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, st CMockExpectParameters_ppu_v1_lock_off_disable(cmock_call_instance, ppu, ppu_Depth); } -void ppu_v1_lock_off_disable_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_lock_off_disable_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_lock_off_disable_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_lock_off_disable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_lock_off_disable_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -2541,7 +2541,7 @@ void ppu_v1_lock_off_disable_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line) cmock_call_instance->IgnoreArg_ppu = 1; } -enum ppu_v1_mode ppu_v1_get_power_mode(struct ppu_v1_reg* ppu) +enum ppu_v1_mode ppu_v1_get_power_mode(struct ppu_v1_regs* ppu) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_get_power_mode_CALL_INSTANCE* cmock_call_instance; @@ -2574,7 +2574,7 @@ enum ppu_v1_mode ppu_v1_get_power_mode(struct ppu_v1_reg* ppu) if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } } if (Mock.ppu_v1_get_power_mode_CallbackFunctionPointer != NULL) @@ -2591,8 +2591,8 @@ enum ppu_v1_mode ppu_v1_get_power_mode(struct ppu_v1_reg* ppu) return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_ppu_v1_get_power_mode(CMOCK_ppu_v1_get_power_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth); -void CMockExpectParameters_ppu_v1_get_power_mode(CMOCK_ppu_v1_get_power_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth) +void CMockExpectParameters_ppu_v1_get_power_mode(CMOCK_ppu_v1_get_power_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth); +void CMockExpectParameters_ppu_v1_get_power_mode(CMOCK_ppu_v1_get_power_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -2635,7 +2635,7 @@ void ppu_v1_get_power_mode_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_lin cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_get_power_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_mode cmock_to_return) +void ppu_v1_get_power_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_mode cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_get_power_mode_CALL_INSTANCE)); CMOCK_ppu_v1_get_power_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_power_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -2664,7 +2664,7 @@ void ppu_v1_get_power_mode_Stub(CMOCK_ppu_v1_get_power_mode_CALLBACK Callback) Mock.ppu_v1_get_power_mode_CallbackFunctionPointer = Callback; } -void ppu_v1_get_power_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode cmock_to_return) +void ppu_v1_get_power_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_get_power_mode_CALL_INSTANCE)); CMOCK_ppu_v1_get_power_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_power_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -2678,7 +2678,7 @@ void ppu_v1_get_power_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_l cmock_call_instance->ReturnVal = cmock_to_return; } -void ppu_v1_get_power_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_get_power_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_get_power_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_power_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_get_power_mode_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -2694,7 +2694,7 @@ void ppu_v1_get_power_mode_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line) cmock_call_instance->IgnoreArg_ppu = 1; } -enum ppu_v1_mode ppu_v1_get_programmed_power_mode(struct ppu_v1_reg* ppu) +enum ppu_v1_mode ppu_v1_get_programmed_power_mode(struct ppu_v1_regs* ppu) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_get_programmed_power_mode_CALL_INSTANCE* cmock_call_instance; @@ -2727,7 +2727,7 @@ enum ppu_v1_mode ppu_v1_get_programmed_power_mode(struct ppu_v1_reg* ppu) if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } } if (Mock.ppu_v1_get_programmed_power_mode_CallbackFunctionPointer != NULL) @@ -2744,8 +2744,8 @@ enum ppu_v1_mode ppu_v1_get_programmed_power_mode(struct ppu_v1_reg* ppu) return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_ppu_v1_get_programmed_power_mode(CMOCK_ppu_v1_get_programmed_power_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth); -void CMockExpectParameters_ppu_v1_get_programmed_power_mode(CMOCK_ppu_v1_get_programmed_power_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth) +void CMockExpectParameters_ppu_v1_get_programmed_power_mode(CMOCK_ppu_v1_get_programmed_power_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth); +void CMockExpectParameters_ppu_v1_get_programmed_power_mode(CMOCK_ppu_v1_get_programmed_power_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -2788,7 +2788,7 @@ void ppu_v1_get_programmed_power_mode_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYP cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_get_programmed_power_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_mode cmock_to_return) +void ppu_v1_get_programmed_power_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_mode cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_get_programmed_power_mode_CALL_INSTANCE)); CMOCK_ppu_v1_get_programmed_power_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_programmed_power_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -2817,7 +2817,7 @@ void ppu_v1_get_programmed_power_mode_Stub(CMOCK_ppu_v1_get_programmed_power_mod Mock.ppu_v1_get_programmed_power_mode_CallbackFunctionPointer = Callback; } -void ppu_v1_get_programmed_power_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode cmock_to_return) +void ppu_v1_get_programmed_power_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_get_programmed_power_mode_CALL_INSTANCE)); CMOCK_ppu_v1_get_programmed_power_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_programmed_power_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -2831,7 +2831,7 @@ void ppu_v1_get_programmed_power_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_T cmock_call_instance->ReturnVal = cmock_to_return; } -void ppu_v1_get_programmed_power_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_get_programmed_power_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_get_programmed_power_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_programmed_power_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_get_programmed_power_mode_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -2847,7 +2847,7 @@ void ppu_v1_get_programmed_power_mode_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_l cmock_call_instance->IgnoreArg_ppu = 1; } -enum ppu_v1_opmode ppu_v1_get_operating_mode(struct ppu_v1_reg* ppu) +enum ppu_v1_opmode ppu_v1_get_operating_mode(struct ppu_v1_regs* ppu) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_get_operating_mode_CALL_INSTANCE* cmock_call_instance; @@ -2880,7 +2880,7 @@ enum ppu_v1_opmode ppu_v1_get_operating_mode(struct ppu_v1_reg* ppu) if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } } if (Mock.ppu_v1_get_operating_mode_CallbackFunctionPointer != NULL) @@ -2897,8 +2897,8 @@ enum ppu_v1_opmode ppu_v1_get_operating_mode(struct ppu_v1_reg* ppu) return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_ppu_v1_get_operating_mode(CMOCK_ppu_v1_get_operating_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth); -void CMockExpectParameters_ppu_v1_get_operating_mode(CMOCK_ppu_v1_get_operating_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth) +void CMockExpectParameters_ppu_v1_get_operating_mode(CMOCK_ppu_v1_get_operating_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth); +void CMockExpectParameters_ppu_v1_get_operating_mode(CMOCK_ppu_v1_get_operating_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -2941,7 +2941,7 @@ void ppu_v1_get_operating_mode_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_get_operating_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_opmode cmock_to_return) +void ppu_v1_get_operating_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_opmode cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_get_operating_mode_CALL_INSTANCE)); CMOCK_ppu_v1_get_operating_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_operating_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -2970,7 +2970,7 @@ void ppu_v1_get_operating_mode_Stub(CMOCK_ppu_v1_get_operating_mode_CALLBACK Cal Mock.ppu_v1_get_operating_mode_CallbackFunctionPointer = Callback; } -void ppu_v1_get_operating_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_opmode cmock_to_return) +void ppu_v1_get_operating_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_opmode cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_get_operating_mode_CALL_INSTANCE)); CMOCK_ppu_v1_get_operating_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_operating_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -2984,7 +2984,7 @@ void ppu_v1_get_operating_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmo cmock_call_instance->ReturnVal = cmock_to_return; } -void ppu_v1_get_operating_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_get_operating_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_get_operating_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_operating_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_get_operating_mode_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -3000,7 +3000,7 @@ void ppu_v1_get_operating_mode_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line) cmock_call_instance->IgnoreArg_ppu = 1; } -enum ppu_v1_opmode ppu_v1_get_programmed_operating_mode(struct ppu_v1_reg* ppu) +enum ppu_v1_opmode ppu_v1_get_programmed_operating_mode(struct ppu_v1_regs* ppu) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_get_programmed_operating_mode_CALL_INSTANCE* cmock_call_instance; @@ -3033,7 +3033,7 @@ enum ppu_v1_opmode ppu_v1_get_programmed_operating_mode(struct ppu_v1_reg* ppu) if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } } if (Mock.ppu_v1_get_programmed_operating_mode_CallbackFunctionPointer != NULL) @@ -3050,8 +3050,8 @@ enum ppu_v1_opmode ppu_v1_get_programmed_operating_mode(struct ppu_v1_reg* ppu) return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_ppu_v1_get_programmed_operating_mode(CMOCK_ppu_v1_get_programmed_operating_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth); -void CMockExpectParameters_ppu_v1_get_programmed_operating_mode(CMOCK_ppu_v1_get_programmed_operating_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth) +void CMockExpectParameters_ppu_v1_get_programmed_operating_mode(CMOCK_ppu_v1_get_programmed_operating_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth); +void CMockExpectParameters_ppu_v1_get_programmed_operating_mode(CMOCK_ppu_v1_get_programmed_operating_mode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -3094,7 +3094,7 @@ void ppu_v1_get_programmed_operating_mode_CMockExpectAnyArgsAndReturn(UNITY_LINE cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_get_programmed_operating_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_opmode cmock_to_return) +void ppu_v1_get_programmed_operating_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_opmode cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_get_programmed_operating_mode_CALL_INSTANCE)); CMOCK_ppu_v1_get_programmed_operating_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_programmed_operating_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -3123,7 +3123,7 @@ void ppu_v1_get_programmed_operating_mode_Stub(CMOCK_ppu_v1_get_programmed_opera Mock.ppu_v1_get_programmed_operating_mode_CallbackFunctionPointer = Callback; } -void ppu_v1_get_programmed_operating_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_opmode cmock_to_return) +void ppu_v1_get_programmed_operating_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_opmode cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_get_programmed_operating_mode_CALL_INSTANCE)); CMOCK_ppu_v1_get_programmed_operating_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_programmed_operating_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -3137,7 +3137,7 @@ void ppu_v1_get_programmed_operating_mode_CMockExpectWithArrayAndReturn(UNITY_LI cmock_call_instance->ReturnVal = cmock_to_return; } -void ppu_v1_get_programmed_operating_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_get_programmed_operating_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_get_programmed_operating_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_programmed_operating_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_get_programmed_operating_mode_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -3153,7 +3153,7 @@ void ppu_v1_get_programmed_operating_mode_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmo cmock_call_instance->IgnoreArg_ppu = 1; } -bool ppu_v1_is_dynamic_enabled(struct ppu_v1_reg* ppu) +bool ppu_v1_is_dynamic_enabled(struct ppu_v1_regs* ppu) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_is_dynamic_enabled_CALL_INSTANCE* cmock_call_instance; @@ -3185,7 +3185,7 @@ bool ppu_v1_is_dynamic_enabled(struct ppu_v1_reg* ppu) if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } } if (Mock.ppu_v1_is_dynamic_enabled_CallbackFunctionPointer != NULL) @@ -3202,8 +3202,8 @@ bool ppu_v1_is_dynamic_enabled(struct ppu_v1_reg* ppu) return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_ppu_v1_is_dynamic_enabled(CMOCK_ppu_v1_is_dynamic_enabled_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth); -void CMockExpectParameters_ppu_v1_is_dynamic_enabled(CMOCK_ppu_v1_is_dynamic_enabled_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth) +void CMockExpectParameters_ppu_v1_is_dynamic_enabled(CMOCK_ppu_v1_is_dynamic_enabled_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth); +void CMockExpectParameters_ppu_v1_is_dynamic_enabled(CMOCK_ppu_v1_is_dynamic_enabled_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -3246,7 +3246,7 @@ void ppu_v1_is_dynamic_enabled_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_is_dynamic_enabled_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, bool cmock_to_return) +void ppu_v1_is_dynamic_enabled_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, bool cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_is_dynamic_enabled_CALL_INSTANCE)); CMOCK_ppu_v1_is_dynamic_enabled_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_dynamic_enabled_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -3274,7 +3274,7 @@ void ppu_v1_is_dynamic_enabled_Stub(CMOCK_ppu_v1_is_dynamic_enabled_CALLBACK Cal Mock.ppu_v1_is_dynamic_enabled_CallbackFunctionPointer = Callback; } -void ppu_v1_is_dynamic_enabled_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, bool cmock_to_return) +void ppu_v1_is_dynamic_enabled_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, bool cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_is_dynamic_enabled_CALL_INSTANCE)); CMOCK_ppu_v1_is_dynamic_enabled_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_dynamic_enabled_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -3288,7 +3288,7 @@ void ppu_v1_is_dynamic_enabled_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmo cmock_call_instance->ReturnVal = cmock_to_return; } -void ppu_v1_is_dynamic_enabled_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_is_dynamic_enabled_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_is_dynamic_enabled_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_dynamic_enabled_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_is_dynamic_enabled_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -3304,7 +3304,7 @@ void ppu_v1_is_dynamic_enabled_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line) cmock_call_instance->IgnoreArg_ppu = 1; } -bool ppu_v1_is_locked(struct ppu_v1_reg* ppu) +bool ppu_v1_is_locked(struct ppu_v1_regs* ppu) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_is_locked_CALL_INSTANCE* cmock_call_instance; @@ -3336,7 +3336,7 @@ bool ppu_v1_is_locked(struct ppu_v1_reg* ppu) if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } } if (Mock.ppu_v1_is_locked_CallbackFunctionPointer != NULL) @@ -3353,8 +3353,8 @@ bool ppu_v1_is_locked(struct ppu_v1_reg* ppu) return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_ppu_v1_is_locked(CMOCK_ppu_v1_is_locked_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth); -void CMockExpectParameters_ppu_v1_is_locked(CMOCK_ppu_v1_is_locked_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth) +void CMockExpectParameters_ppu_v1_is_locked(CMOCK_ppu_v1_is_locked_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth); +void CMockExpectParameters_ppu_v1_is_locked(CMOCK_ppu_v1_is_locked_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -3397,7 +3397,7 @@ void ppu_v1_is_locked_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, bo cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_is_locked_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, bool cmock_to_return) +void ppu_v1_is_locked_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, bool cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_is_locked_CALL_INSTANCE)); CMOCK_ppu_v1_is_locked_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_locked_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -3425,7 +3425,7 @@ void ppu_v1_is_locked_Stub(CMOCK_ppu_v1_is_locked_CALLBACK Callback) Mock.ppu_v1_is_locked_CallbackFunctionPointer = Callback; } -void ppu_v1_is_locked_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, bool cmock_to_return) +void ppu_v1_is_locked_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, bool cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_is_locked_CALL_INSTANCE)); CMOCK_ppu_v1_is_locked_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_locked_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -3439,7 +3439,7 @@ void ppu_v1_is_locked_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, cmock_call_instance->ReturnVal = cmock_to_return; } -void ppu_v1_is_locked_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_is_locked_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_is_locked_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_locked_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_is_locked_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -3455,7 +3455,7 @@ void ppu_v1_is_locked_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line) cmock_call_instance->IgnoreArg_ppu = 1; } -bool ppu_v1_is_power_devactive_high(struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode) +bool ppu_v1_is_power_devactive_high(struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_is_power_devactive_high_CALL_INSTANCE* cmock_call_instance; @@ -3487,7 +3487,7 @@ bool ppu_v1_is_power_devactive_high(struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_ppu_mode) { @@ -3509,8 +3509,8 @@ bool ppu_v1_is_power_devactive_high(struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_ppu_v1_is_power_devactive_high(CMOCK_ppu_v1_is_power_devactive_high_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode); -void CMockExpectParameters_ppu_v1_is_power_devactive_high(CMOCK_ppu_v1_is_power_devactive_high_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode) +void CMockExpectParameters_ppu_v1_is_power_devactive_high(CMOCK_ppu_v1_is_power_devactive_high_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode); +void CMockExpectParameters_ppu_v1_is_power_devactive_high(CMOCK_ppu_v1_is_power_devactive_high_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -3556,7 +3556,7 @@ void ppu_v1_is_power_devactive_high_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_is_power_devactive_high_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, bool cmock_to_return) +void ppu_v1_is_power_devactive_high_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode, bool cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_is_power_devactive_high_CALL_INSTANCE)); CMOCK_ppu_v1_is_power_devactive_high_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_power_devactive_high_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -3584,7 +3584,7 @@ void ppu_v1_is_power_devactive_high_Stub(CMOCK_ppu_v1_is_power_devactive_high_CA Mock.ppu_v1_is_power_devactive_high_CallbackFunctionPointer = Callback; } -void ppu_v1_is_power_devactive_high_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, bool cmock_to_return) +void ppu_v1_is_power_devactive_high_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, bool cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_is_power_devactive_high_CALL_INSTANCE)); CMOCK_ppu_v1_is_power_devactive_high_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_power_devactive_high_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -3598,7 +3598,7 @@ void ppu_v1_is_power_devactive_high_CMockExpectWithArrayAndReturn(UNITY_LINE_TYP cmock_call_instance->ReturnVal = cmock_to_return; } -void ppu_v1_is_power_devactive_high_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_is_power_devactive_high_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_is_power_devactive_high_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_power_devactive_high_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_is_power_devactive_high_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -3621,7 +3621,7 @@ void ppu_v1_is_power_devactive_high_CMockIgnoreArg_ppu_mode(UNITY_LINE_TYPE cmoc cmock_call_instance->IgnoreArg_ppu_mode = 1; } -bool ppu_v1_is_op_devactive_high(struct ppu_v1_reg* ppu, enum ppu_v1_op_devactive op_devactive) +bool ppu_v1_is_op_devactive_high(struct ppu_v1_regs* ppu, enum ppu_v1_op_devactive op_devactive) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_is_op_devactive_high_CALL_INSTANCE* cmock_call_instance; @@ -3653,7 +3653,7 @@ bool ppu_v1_is_op_devactive_high(struct ppu_v1_reg* ppu, enum ppu_v1_op_devactiv if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_op_devactive) { @@ -3675,8 +3675,8 @@ bool ppu_v1_is_op_devactive_high(struct ppu_v1_reg* ppu, enum ppu_v1_op_devactiv return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_ppu_v1_is_op_devactive_high(CMOCK_ppu_v1_is_op_devactive_high_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive); -void CMockExpectParameters_ppu_v1_is_op_devactive_high(CMOCK_ppu_v1_is_op_devactive_high_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive) +void CMockExpectParameters_ppu_v1_is_op_devactive_high(CMOCK_ppu_v1_is_op_devactive_high_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive); +void CMockExpectParameters_ppu_v1_is_op_devactive_high(CMOCK_ppu_v1_is_op_devactive_high_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -3722,7 +3722,7 @@ void ppu_v1_is_op_devactive_high_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmo cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_is_op_devactive_high_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_op_devactive op_devactive, bool cmock_to_return) +void ppu_v1_is_op_devactive_high_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_op_devactive op_devactive, bool cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_is_op_devactive_high_CALL_INSTANCE)); CMOCK_ppu_v1_is_op_devactive_high_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_op_devactive_high_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -3750,7 +3750,7 @@ void ppu_v1_is_op_devactive_high_Stub(CMOCK_ppu_v1_is_op_devactive_high_CALLBACK Mock.ppu_v1_is_op_devactive_high_CallbackFunctionPointer = Callback; } -void ppu_v1_is_op_devactive_high_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive, bool cmock_to_return) +void ppu_v1_is_op_devactive_high_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive, bool cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_is_op_devactive_high_CALL_INSTANCE)); CMOCK_ppu_v1_is_op_devactive_high_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_op_devactive_high_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -3764,7 +3764,7 @@ void ppu_v1_is_op_devactive_high_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE c cmock_call_instance->ReturnVal = cmock_to_return; } -void ppu_v1_is_op_devactive_high_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_is_op_devactive_high_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_is_op_devactive_high_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_op_devactive_high_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_is_op_devactive_high_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -3787,7 +3787,7 @@ void ppu_v1_is_op_devactive_high_CMockIgnoreArg_op_devactive(UNITY_LINE_TYPE cmo cmock_call_instance->IgnoreArg_op_devactive = 1; } -void ppu_v1_off_unlock(struct ppu_v1_reg* ppu) +void ppu_v1_off_unlock(struct ppu_v1_regs* ppu) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_off_unlock_CALL_INSTANCE* cmock_call_instance; @@ -3816,7 +3816,7 @@ void ppu_v1_off_unlock(struct ppu_v1_reg* ppu) if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } } if (Mock.ppu_v1_off_unlock_CallbackFunctionPointer != NULL) @@ -3832,8 +3832,8 @@ void ppu_v1_off_unlock(struct ppu_v1_reg* ppu) UNITY_CLR_DETAILS(); } -void CMockExpectParameters_ppu_v1_off_unlock(CMOCK_ppu_v1_off_unlock_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth); -void CMockExpectParameters_ppu_v1_off_unlock(CMOCK_ppu_v1_off_unlock_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth) +void CMockExpectParameters_ppu_v1_off_unlock(CMOCK_ppu_v1_off_unlock_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth); +void CMockExpectParameters_ppu_v1_off_unlock(CMOCK_ppu_v1_off_unlock_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -3864,7 +3864,7 @@ void ppu_v1_off_unlock_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_off_unlock_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu) +void ppu_v1_off_unlock_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_off_unlock_CALL_INSTANCE)); CMOCK_ppu_v1_off_unlock_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_off_unlock_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -3891,7 +3891,7 @@ void ppu_v1_off_unlock_Stub(CMOCK_ppu_v1_off_unlock_CALLBACK Callback) Mock.ppu_v1_off_unlock_CallbackFunctionPointer = Callback; } -void ppu_v1_off_unlock_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth) +void ppu_v1_off_unlock_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_off_unlock_CALL_INSTANCE)); CMOCK_ppu_v1_off_unlock_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_off_unlock_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -3904,7 +3904,7 @@ void ppu_v1_off_unlock_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct p CMockExpectParameters_ppu_v1_off_unlock(cmock_call_instance, ppu, ppu_Depth); } -void ppu_v1_off_unlock_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_off_unlock_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_off_unlock_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_off_unlock_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_off_unlock_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -3920,7 +3920,7 @@ void ppu_v1_off_unlock_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line) cmock_call_instance->IgnoreArg_ppu = 1; } -void ppu_v1_disable_devactive(struct ppu_v1_reg* ppu) +void ppu_v1_disable_devactive(struct ppu_v1_regs* ppu) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_disable_devactive_CALL_INSTANCE* cmock_call_instance; @@ -3949,7 +3949,7 @@ void ppu_v1_disable_devactive(struct ppu_v1_reg* ppu) if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } } if (Mock.ppu_v1_disable_devactive_CallbackFunctionPointer != NULL) @@ -3965,8 +3965,8 @@ void ppu_v1_disable_devactive(struct ppu_v1_reg* ppu) UNITY_CLR_DETAILS(); } -void CMockExpectParameters_ppu_v1_disable_devactive(CMOCK_ppu_v1_disable_devactive_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth); -void CMockExpectParameters_ppu_v1_disable_devactive(CMOCK_ppu_v1_disable_devactive_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth) +void CMockExpectParameters_ppu_v1_disable_devactive(CMOCK_ppu_v1_disable_devactive_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth); +void CMockExpectParameters_ppu_v1_disable_devactive(CMOCK_ppu_v1_disable_devactive_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -3997,7 +3997,7 @@ void ppu_v1_disable_devactive_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_disable_devactive_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu) +void ppu_v1_disable_devactive_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_disable_devactive_CALL_INSTANCE)); CMOCK_ppu_v1_disable_devactive_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_disable_devactive_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -4024,7 +4024,7 @@ void ppu_v1_disable_devactive_Stub(CMOCK_ppu_v1_disable_devactive_CALLBACK Callb Mock.ppu_v1_disable_devactive_CallbackFunctionPointer = Callback; } -void ppu_v1_disable_devactive_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth) +void ppu_v1_disable_devactive_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_disable_devactive_CALL_INSTANCE)); CMOCK_ppu_v1_disable_devactive_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_disable_devactive_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -4037,7 +4037,7 @@ void ppu_v1_disable_devactive_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, s CMockExpectParameters_ppu_v1_disable_devactive(cmock_call_instance, ppu, ppu_Depth); } -void ppu_v1_disable_devactive_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_disable_devactive_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_disable_devactive_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_disable_devactive_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_disable_devactive_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -4053,7 +4053,7 @@ void ppu_v1_disable_devactive_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line) cmock_call_instance->IgnoreArg_ppu = 1; } -void ppu_v1_disable_handshake(struct ppu_v1_reg* ppu) +void ppu_v1_disable_handshake(struct ppu_v1_regs* ppu) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_disable_handshake_CALL_INSTANCE* cmock_call_instance; @@ -4082,7 +4082,7 @@ void ppu_v1_disable_handshake(struct ppu_v1_reg* ppu) if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } } if (Mock.ppu_v1_disable_handshake_CallbackFunctionPointer != NULL) @@ -4098,8 +4098,8 @@ void ppu_v1_disable_handshake(struct ppu_v1_reg* ppu) UNITY_CLR_DETAILS(); } -void CMockExpectParameters_ppu_v1_disable_handshake(CMOCK_ppu_v1_disable_handshake_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth); -void CMockExpectParameters_ppu_v1_disable_handshake(CMOCK_ppu_v1_disable_handshake_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth) +void CMockExpectParameters_ppu_v1_disable_handshake(CMOCK_ppu_v1_disable_handshake_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth); +void CMockExpectParameters_ppu_v1_disable_handshake(CMOCK_ppu_v1_disable_handshake_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -4130,7 +4130,7 @@ void ppu_v1_disable_handshake_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_disable_handshake_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu) +void ppu_v1_disable_handshake_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_disable_handshake_CALL_INSTANCE)); CMOCK_ppu_v1_disable_handshake_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_disable_handshake_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -4157,7 +4157,7 @@ void ppu_v1_disable_handshake_Stub(CMOCK_ppu_v1_disable_handshake_CALLBACK Callb Mock.ppu_v1_disable_handshake_CallbackFunctionPointer = Callback; } -void ppu_v1_disable_handshake_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth) +void ppu_v1_disable_handshake_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_disable_handshake_CALL_INSTANCE)); CMOCK_ppu_v1_disable_handshake_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_disable_handshake_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -4170,7 +4170,7 @@ void ppu_v1_disable_handshake_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, s CMockExpectParameters_ppu_v1_disable_handshake(cmock_call_instance, ppu, ppu_Depth); } -void ppu_v1_disable_handshake_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_disable_handshake_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_disable_handshake_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_disable_handshake_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_disable_handshake_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -4186,7 +4186,7 @@ void ppu_v1_disable_handshake_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line) cmock_call_instance->IgnoreArg_ppu = 1; } -void ppu_v1_interrupt_mask(struct ppu_v1_reg* ppu, unsigned int mask) +void ppu_v1_interrupt_mask(struct ppu_v1_regs* ppu, unsigned int mask) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_interrupt_mask_CALL_INSTANCE* cmock_call_instance; @@ -4215,7 +4215,7 @@ void ppu_v1_interrupt_mask(struct ppu_v1_reg* ppu, unsigned int mask) if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_mask) { @@ -4236,8 +4236,8 @@ void ppu_v1_interrupt_mask(struct ppu_v1_reg* ppu, unsigned int mask) UNITY_CLR_DETAILS(); } -void CMockExpectParameters_ppu_v1_interrupt_mask(CMOCK_ppu_v1_interrupt_mask_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask); -void CMockExpectParameters_ppu_v1_interrupt_mask(CMOCK_ppu_v1_interrupt_mask_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask) +void CMockExpectParameters_ppu_v1_interrupt_mask(CMOCK_ppu_v1_interrupt_mask_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask); +void CMockExpectParameters_ppu_v1_interrupt_mask(CMOCK_ppu_v1_interrupt_mask_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -4270,7 +4270,7 @@ void ppu_v1_interrupt_mask_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_interrupt_mask_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, unsigned int mask) +void ppu_v1_interrupt_mask_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, unsigned int mask) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_interrupt_mask_CALL_INSTANCE)); CMOCK_ppu_v1_interrupt_mask_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_interrupt_mask_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -4297,7 +4297,7 @@ void ppu_v1_interrupt_mask_Stub(CMOCK_ppu_v1_interrupt_mask_CALLBACK Callback) Mock.ppu_v1_interrupt_mask_CallbackFunctionPointer = Callback; } -void ppu_v1_interrupt_mask_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask) +void ppu_v1_interrupt_mask_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_interrupt_mask_CALL_INSTANCE)); CMOCK_ppu_v1_interrupt_mask_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_interrupt_mask_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -4310,7 +4310,7 @@ void ppu_v1_interrupt_mask_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, stru CMockExpectParameters_ppu_v1_interrupt_mask(cmock_call_instance, ppu, ppu_Depth, mask); } -void ppu_v1_interrupt_mask_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_interrupt_mask_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_interrupt_mask_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_interrupt_mask_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_interrupt_mask_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -4333,7 +4333,7 @@ void ppu_v1_interrupt_mask_CMockIgnoreArg_mask(UNITY_LINE_TYPE cmock_line) cmock_call_instance->IgnoreArg_mask = 1; } -void ppu_v1_additional_interrupt_mask(struct ppu_v1_reg* ppu, unsigned int mask) +void ppu_v1_additional_interrupt_mask(struct ppu_v1_regs* ppu, unsigned int mask) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_additional_interrupt_mask_CALL_INSTANCE* cmock_call_instance; @@ -4362,7 +4362,7 @@ void ppu_v1_additional_interrupt_mask(struct ppu_v1_reg* ppu, unsigned int mask) if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_mask) { @@ -4383,8 +4383,8 @@ void ppu_v1_additional_interrupt_mask(struct ppu_v1_reg* ppu, unsigned int mask) UNITY_CLR_DETAILS(); } -void CMockExpectParameters_ppu_v1_additional_interrupt_mask(CMOCK_ppu_v1_additional_interrupt_mask_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask); -void CMockExpectParameters_ppu_v1_additional_interrupt_mask(CMOCK_ppu_v1_additional_interrupt_mask_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask) +void CMockExpectParameters_ppu_v1_additional_interrupt_mask(CMOCK_ppu_v1_additional_interrupt_mask_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask); +void CMockExpectParameters_ppu_v1_additional_interrupt_mask(CMOCK_ppu_v1_additional_interrupt_mask_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -4417,7 +4417,7 @@ void ppu_v1_additional_interrupt_mask_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_l cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_additional_interrupt_mask_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, unsigned int mask) +void ppu_v1_additional_interrupt_mask_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, unsigned int mask) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_additional_interrupt_mask_CALL_INSTANCE)); CMOCK_ppu_v1_additional_interrupt_mask_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_additional_interrupt_mask_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -4444,7 +4444,7 @@ void ppu_v1_additional_interrupt_mask_Stub(CMOCK_ppu_v1_additional_interrupt_mas Mock.ppu_v1_additional_interrupt_mask_CallbackFunctionPointer = Callback; } -void ppu_v1_additional_interrupt_mask_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask) +void ppu_v1_additional_interrupt_mask_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_additional_interrupt_mask_CALL_INSTANCE)); CMOCK_ppu_v1_additional_interrupt_mask_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_additional_interrupt_mask_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -4457,7 +4457,7 @@ void ppu_v1_additional_interrupt_mask_CMockExpectWithArray(UNITY_LINE_TYPE cmock CMockExpectParameters_ppu_v1_additional_interrupt_mask(cmock_call_instance, ppu, ppu_Depth, mask); } -void ppu_v1_additional_interrupt_mask_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_additional_interrupt_mask_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_additional_interrupt_mask_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_additional_interrupt_mask_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_additional_interrupt_mask_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -4480,7 +4480,7 @@ void ppu_v1_additional_interrupt_mask_CMockIgnoreArg_mask(UNITY_LINE_TYPE cmock_ cmock_call_instance->IgnoreArg_mask = 1; } -void ppu_v1_interrupt_unmask(struct ppu_v1_reg* ppu, unsigned int mask) +void ppu_v1_interrupt_unmask(struct ppu_v1_regs* ppu, unsigned int mask) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_interrupt_unmask_CALL_INSTANCE* cmock_call_instance; @@ -4509,7 +4509,7 @@ void ppu_v1_interrupt_unmask(struct ppu_v1_reg* ppu, unsigned int mask) if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_mask) { @@ -4530,8 +4530,8 @@ void ppu_v1_interrupt_unmask(struct ppu_v1_reg* ppu, unsigned int mask) UNITY_CLR_DETAILS(); } -void CMockExpectParameters_ppu_v1_interrupt_unmask(CMOCK_ppu_v1_interrupt_unmask_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask); -void CMockExpectParameters_ppu_v1_interrupt_unmask(CMOCK_ppu_v1_interrupt_unmask_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask) +void CMockExpectParameters_ppu_v1_interrupt_unmask(CMOCK_ppu_v1_interrupt_unmask_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask); +void CMockExpectParameters_ppu_v1_interrupt_unmask(CMOCK_ppu_v1_interrupt_unmask_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -4564,7 +4564,7 @@ void ppu_v1_interrupt_unmask_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_interrupt_unmask_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, unsigned int mask) +void ppu_v1_interrupt_unmask_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, unsigned int mask) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_interrupt_unmask_CALL_INSTANCE)); CMOCK_ppu_v1_interrupt_unmask_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_interrupt_unmask_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -4591,7 +4591,7 @@ void ppu_v1_interrupt_unmask_Stub(CMOCK_ppu_v1_interrupt_unmask_CALLBACK Callbac Mock.ppu_v1_interrupt_unmask_CallbackFunctionPointer = Callback; } -void ppu_v1_interrupt_unmask_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask) +void ppu_v1_interrupt_unmask_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_interrupt_unmask_CALL_INSTANCE)); CMOCK_ppu_v1_interrupt_unmask_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_interrupt_unmask_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -4604,7 +4604,7 @@ void ppu_v1_interrupt_unmask_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, st CMockExpectParameters_ppu_v1_interrupt_unmask(cmock_call_instance, ppu, ppu_Depth, mask); } -void ppu_v1_interrupt_unmask_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_interrupt_unmask_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_interrupt_unmask_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_interrupt_unmask_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_interrupt_unmask_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -4627,7 +4627,7 @@ void ppu_v1_interrupt_unmask_CMockIgnoreArg_mask(UNITY_LINE_TYPE cmock_line) cmock_call_instance->IgnoreArg_mask = 1; } -void ppu_v1_additional_interrupt_unmask(struct ppu_v1_reg* ppu, unsigned int mask) +void ppu_v1_additional_interrupt_unmask(struct ppu_v1_regs* ppu, unsigned int mask) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_additional_interrupt_unmask_CALL_INSTANCE* cmock_call_instance; @@ -4656,7 +4656,7 @@ void ppu_v1_additional_interrupt_unmask(struct ppu_v1_reg* ppu, unsigned int mas if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_mask) { @@ -4677,8 +4677,8 @@ void ppu_v1_additional_interrupt_unmask(struct ppu_v1_reg* ppu, unsigned int mas UNITY_CLR_DETAILS(); } -void CMockExpectParameters_ppu_v1_additional_interrupt_unmask(CMOCK_ppu_v1_additional_interrupt_unmask_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask); -void CMockExpectParameters_ppu_v1_additional_interrupt_unmask(CMOCK_ppu_v1_additional_interrupt_unmask_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask) +void CMockExpectParameters_ppu_v1_additional_interrupt_unmask(CMOCK_ppu_v1_additional_interrupt_unmask_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask); +void CMockExpectParameters_ppu_v1_additional_interrupt_unmask(CMOCK_ppu_v1_additional_interrupt_unmask_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -4711,7 +4711,7 @@ void ppu_v1_additional_interrupt_unmask_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_additional_interrupt_unmask_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, unsigned int mask) +void ppu_v1_additional_interrupt_unmask_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, unsigned int mask) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_additional_interrupt_unmask_CALL_INSTANCE)); CMOCK_ppu_v1_additional_interrupt_unmask_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_additional_interrupt_unmask_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -4738,7 +4738,7 @@ void ppu_v1_additional_interrupt_unmask_Stub(CMOCK_ppu_v1_additional_interrupt_u Mock.ppu_v1_additional_interrupt_unmask_CallbackFunctionPointer = Callback; } -void ppu_v1_additional_interrupt_unmask_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask) +void ppu_v1_additional_interrupt_unmask_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_additional_interrupt_unmask_CALL_INSTANCE)); CMOCK_ppu_v1_additional_interrupt_unmask_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_additional_interrupt_unmask_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -4751,7 +4751,7 @@ void ppu_v1_additional_interrupt_unmask_CMockExpectWithArray(UNITY_LINE_TYPE cmo CMockExpectParameters_ppu_v1_additional_interrupt_unmask(cmock_call_instance, ppu, ppu_Depth, mask); } -void ppu_v1_additional_interrupt_unmask_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_additional_interrupt_unmask_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_additional_interrupt_unmask_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_additional_interrupt_unmask_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_additional_interrupt_unmask_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -4774,7 +4774,7 @@ void ppu_v1_additional_interrupt_unmask_CMockIgnoreArg_mask(UNITY_LINE_TYPE cmoc cmock_call_instance->IgnoreArg_mask = 1; } -bool ppu_v1_is_additional_interrupt_pending(struct ppu_v1_reg* ppu, unsigned int mask) +bool ppu_v1_is_additional_interrupt_pending(struct ppu_v1_regs* ppu, unsigned int mask) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_is_additional_interrupt_pending_CALL_INSTANCE* cmock_call_instance; @@ -4806,7 +4806,7 @@ bool ppu_v1_is_additional_interrupt_pending(struct ppu_v1_reg* ppu, unsigned int if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_mask) { @@ -4828,8 +4828,8 @@ bool ppu_v1_is_additional_interrupt_pending(struct ppu_v1_reg* ppu, unsigned int return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_ppu_v1_is_additional_interrupt_pending(CMOCK_ppu_v1_is_additional_interrupt_pending_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask); -void CMockExpectParameters_ppu_v1_is_additional_interrupt_pending(CMOCK_ppu_v1_is_additional_interrupt_pending_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask) +void CMockExpectParameters_ppu_v1_is_additional_interrupt_pending(CMOCK_ppu_v1_is_additional_interrupt_pending_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask); +void CMockExpectParameters_ppu_v1_is_additional_interrupt_pending(CMOCK_ppu_v1_is_additional_interrupt_pending_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -4874,7 +4874,7 @@ void ppu_v1_is_additional_interrupt_pending_CMockExpectAnyArgsAndReturn(UNITY_LI cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_is_additional_interrupt_pending_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, unsigned int mask, bool cmock_to_return) +void ppu_v1_is_additional_interrupt_pending_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, unsigned int mask, bool cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_is_additional_interrupt_pending_CALL_INSTANCE)); CMOCK_ppu_v1_is_additional_interrupt_pending_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_additional_interrupt_pending_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -4902,7 +4902,7 @@ void ppu_v1_is_additional_interrupt_pending_Stub(CMOCK_ppu_v1_is_additional_inte Mock.ppu_v1_is_additional_interrupt_pending_CallbackFunctionPointer = Callback; } -void ppu_v1_is_additional_interrupt_pending_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask, bool cmock_to_return) +void ppu_v1_is_additional_interrupt_pending_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask, bool cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_is_additional_interrupt_pending_CALL_INSTANCE)); CMOCK_ppu_v1_is_additional_interrupt_pending_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_additional_interrupt_pending_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -4916,7 +4916,7 @@ void ppu_v1_is_additional_interrupt_pending_CMockExpectWithArrayAndReturn(UNITY_ cmock_call_instance->ReturnVal = cmock_to_return; } -void ppu_v1_is_additional_interrupt_pending_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_is_additional_interrupt_pending_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_is_additional_interrupt_pending_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_additional_interrupt_pending_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_is_additional_interrupt_pending_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -4939,7 +4939,7 @@ void ppu_v1_is_additional_interrupt_pending_CMockIgnoreArg_mask(UNITY_LINE_TYPE cmock_call_instance->IgnoreArg_mask = 1; } -void ppu_v1_ack_interrupt(struct ppu_v1_reg* ppu, unsigned int mask) +void ppu_v1_ack_interrupt(struct ppu_v1_regs* ppu, unsigned int mask) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_ack_interrupt_CALL_INSTANCE* cmock_call_instance; @@ -4968,7 +4968,7 @@ void ppu_v1_ack_interrupt(struct ppu_v1_reg* ppu, unsigned int mask) if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_mask) { @@ -4989,8 +4989,8 @@ void ppu_v1_ack_interrupt(struct ppu_v1_reg* ppu, unsigned int mask) UNITY_CLR_DETAILS(); } -void CMockExpectParameters_ppu_v1_ack_interrupt(CMOCK_ppu_v1_ack_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask); -void CMockExpectParameters_ppu_v1_ack_interrupt(CMOCK_ppu_v1_ack_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask) +void CMockExpectParameters_ppu_v1_ack_interrupt(CMOCK_ppu_v1_ack_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask); +void CMockExpectParameters_ppu_v1_ack_interrupt(CMOCK_ppu_v1_ack_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -5023,7 +5023,7 @@ void ppu_v1_ack_interrupt_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_ack_interrupt_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, unsigned int mask) +void ppu_v1_ack_interrupt_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, unsigned int mask) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_ack_interrupt_CALL_INSTANCE)); CMOCK_ppu_v1_ack_interrupt_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_ack_interrupt_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -5050,7 +5050,7 @@ void ppu_v1_ack_interrupt_Stub(CMOCK_ppu_v1_ack_interrupt_CALLBACK Callback) Mock.ppu_v1_ack_interrupt_CallbackFunctionPointer = Callback; } -void ppu_v1_ack_interrupt_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask) +void ppu_v1_ack_interrupt_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_ack_interrupt_CALL_INSTANCE)); CMOCK_ppu_v1_ack_interrupt_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_ack_interrupt_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -5063,7 +5063,7 @@ void ppu_v1_ack_interrupt_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struc CMockExpectParameters_ppu_v1_ack_interrupt(cmock_call_instance, ppu, ppu_Depth, mask); } -void ppu_v1_ack_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_ack_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_ack_interrupt_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_ack_interrupt_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_ack_interrupt_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -5086,7 +5086,7 @@ void ppu_v1_ack_interrupt_CMockIgnoreArg_mask(UNITY_LINE_TYPE cmock_line) cmock_call_instance->IgnoreArg_mask = 1; } -void ppu_v1_ack_additional_interrupt(struct ppu_v1_reg* ppu, unsigned int mask) +void ppu_v1_ack_additional_interrupt(struct ppu_v1_regs* ppu, unsigned int mask) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_ack_additional_interrupt_CALL_INSTANCE* cmock_call_instance; @@ -5115,7 +5115,7 @@ void ppu_v1_ack_additional_interrupt(struct ppu_v1_reg* ppu, unsigned int mask) if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_mask) { @@ -5136,8 +5136,8 @@ void ppu_v1_ack_additional_interrupt(struct ppu_v1_reg* ppu, unsigned int mask) UNITY_CLR_DETAILS(); } -void CMockExpectParameters_ppu_v1_ack_additional_interrupt(CMOCK_ppu_v1_ack_additional_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask); -void CMockExpectParameters_ppu_v1_ack_additional_interrupt(CMOCK_ppu_v1_ack_additional_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask) +void CMockExpectParameters_ppu_v1_ack_additional_interrupt(CMOCK_ppu_v1_ack_additional_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask); +void CMockExpectParameters_ppu_v1_ack_additional_interrupt(CMOCK_ppu_v1_ack_additional_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -5170,7 +5170,7 @@ void ppu_v1_ack_additional_interrupt_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_li cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_ack_additional_interrupt_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, unsigned int mask) +void ppu_v1_ack_additional_interrupt_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, unsigned int mask) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_ack_additional_interrupt_CALL_INSTANCE)); CMOCK_ppu_v1_ack_additional_interrupt_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_ack_additional_interrupt_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -5197,7 +5197,7 @@ void ppu_v1_ack_additional_interrupt_Stub(CMOCK_ppu_v1_ack_additional_interrupt_ Mock.ppu_v1_ack_additional_interrupt_CallbackFunctionPointer = Callback; } -void ppu_v1_ack_additional_interrupt_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask) +void ppu_v1_ack_additional_interrupt_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_ack_additional_interrupt_CALL_INSTANCE)); CMOCK_ppu_v1_ack_additional_interrupt_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_ack_additional_interrupt_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -5210,7 +5210,7 @@ void ppu_v1_ack_additional_interrupt_CMockExpectWithArray(UNITY_LINE_TYPE cmock_ CMockExpectParameters_ppu_v1_ack_additional_interrupt(cmock_call_instance, ppu, ppu_Depth, mask); } -void ppu_v1_ack_additional_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_ack_additional_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_ack_additional_interrupt_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_ack_additional_interrupt_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_ack_additional_interrupt_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -5233,7 +5233,7 @@ void ppu_v1_ack_additional_interrupt_CMockIgnoreArg_mask(UNITY_LINE_TYPE cmock_l cmock_call_instance->IgnoreArg_mask = 1; } -void ppu_v1_set_input_edge_sensitivity(struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity edge_sensitivity) +void ppu_v1_set_input_edge_sensitivity(struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity edge_sensitivity) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_set_input_edge_sensitivity_CALL_INSTANCE* cmock_call_instance; @@ -5262,7 +5262,7 @@ void ppu_v1_set_input_edge_sensitivity(struct ppu_v1_reg* ppu, enum ppu_v1_mode if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_ppu_mode) { @@ -5288,8 +5288,8 @@ void ppu_v1_set_input_edge_sensitivity(struct ppu_v1_reg* ppu, enum ppu_v1_mode UNITY_CLR_DETAILS(); } -void CMockExpectParameters_ppu_v1_set_input_edge_sensitivity(CMOCK_ppu_v1_set_input_edge_sensitivity_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity edge_sensitivity); -void CMockExpectParameters_ppu_v1_set_input_edge_sensitivity(CMOCK_ppu_v1_set_input_edge_sensitivity_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity edge_sensitivity) +void CMockExpectParameters_ppu_v1_set_input_edge_sensitivity(CMOCK_ppu_v1_set_input_edge_sensitivity_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity edge_sensitivity); +void CMockExpectParameters_ppu_v1_set_input_edge_sensitivity(CMOCK_ppu_v1_set_input_edge_sensitivity_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity edge_sensitivity) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -5326,7 +5326,7 @@ void ppu_v1_set_input_edge_sensitivity_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_ cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_set_input_edge_sensitivity_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity edge_sensitivity) +void ppu_v1_set_input_edge_sensitivity_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity edge_sensitivity) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_set_input_edge_sensitivity_CALL_INSTANCE)); CMOCK_ppu_v1_set_input_edge_sensitivity_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_set_input_edge_sensitivity_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -5353,7 +5353,7 @@ void ppu_v1_set_input_edge_sensitivity_Stub(CMOCK_ppu_v1_set_input_edge_sensitiv Mock.ppu_v1_set_input_edge_sensitivity_CallbackFunctionPointer = Callback; } -void ppu_v1_set_input_edge_sensitivity_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity edge_sensitivity) +void ppu_v1_set_input_edge_sensitivity_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity edge_sensitivity) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_set_input_edge_sensitivity_CALL_INSTANCE)); CMOCK_ppu_v1_set_input_edge_sensitivity_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_set_input_edge_sensitivity_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -5366,7 +5366,7 @@ void ppu_v1_set_input_edge_sensitivity_CMockExpectWithArray(UNITY_LINE_TYPE cmoc CMockExpectParameters_ppu_v1_set_input_edge_sensitivity(cmock_call_instance, ppu, ppu_Depth, ppu_mode, edge_sensitivity); } -void ppu_v1_set_input_edge_sensitivity_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_set_input_edge_sensitivity_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_set_input_edge_sensitivity_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_set_input_edge_sensitivity_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_set_input_edge_sensitivity_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -5396,7 +5396,7 @@ void ppu_v1_set_input_edge_sensitivity_CMockIgnoreArg_edge_sensitivity(UNITY_LIN cmock_call_instance->IgnoreArg_edge_sensitivity = 1; } -enum ppu_v1_edge_sensitivity ppu_v1_get_input_edge_sensitivity(struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode) +enum ppu_v1_edge_sensitivity ppu_v1_get_input_edge_sensitivity(struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_get_input_edge_sensitivity_CALL_INSTANCE* cmock_call_instance; @@ -5429,7 +5429,7 @@ enum ppu_v1_edge_sensitivity ppu_v1_get_input_edge_sensitivity(struct ppu_v1_reg if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_ppu_mode) { @@ -5451,8 +5451,8 @@ enum ppu_v1_edge_sensitivity ppu_v1_get_input_edge_sensitivity(struct ppu_v1_reg return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_ppu_v1_get_input_edge_sensitivity(CMOCK_ppu_v1_get_input_edge_sensitivity_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode); -void CMockExpectParameters_ppu_v1_get_input_edge_sensitivity(CMOCK_ppu_v1_get_input_edge_sensitivity_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode) +void CMockExpectParameters_ppu_v1_get_input_edge_sensitivity(CMOCK_ppu_v1_get_input_edge_sensitivity_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode); +void CMockExpectParameters_ppu_v1_get_input_edge_sensitivity(CMOCK_ppu_v1_get_input_edge_sensitivity_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -5498,7 +5498,7 @@ void ppu_v1_get_input_edge_sensitivity_CMockExpectAnyArgsAndReturn(UNITY_LINE_TY cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_get_input_edge_sensitivity_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity cmock_to_return) +void ppu_v1_get_input_edge_sensitivity_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_get_input_edge_sensitivity_CALL_INSTANCE)); CMOCK_ppu_v1_get_input_edge_sensitivity_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_input_edge_sensitivity_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -5527,7 +5527,7 @@ void ppu_v1_get_input_edge_sensitivity_Stub(CMOCK_ppu_v1_get_input_edge_sensitiv Mock.ppu_v1_get_input_edge_sensitivity_CallbackFunctionPointer = Callback; } -void ppu_v1_get_input_edge_sensitivity_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity cmock_to_return) +void ppu_v1_get_input_edge_sensitivity_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_get_input_edge_sensitivity_CALL_INSTANCE)); CMOCK_ppu_v1_get_input_edge_sensitivity_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_input_edge_sensitivity_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -5541,7 +5541,7 @@ void ppu_v1_get_input_edge_sensitivity_CMockExpectWithArrayAndReturn(UNITY_LINE_ cmock_call_instance->ReturnVal = cmock_to_return; } -void ppu_v1_get_input_edge_sensitivity_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_get_input_edge_sensitivity_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_get_input_edge_sensitivity_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_input_edge_sensitivity_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_get_input_edge_sensitivity_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -5564,7 +5564,7 @@ void ppu_v1_get_input_edge_sensitivity_CMockIgnoreArg_ppu_mode(UNITY_LINE_TYPE c cmock_call_instance->IgnoreArg_ppu_mode = 1; } -void ppu_v1_ack_power_active_edge_interrupt(struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode) +void ppu_v1_ack_power_active_edge_interrupt(struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_ack_power_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance; @@ -5593,7 +5593,7 @@ void ppu_v1_ack_power_active_edge_interrupt(struct ppu_v1_reg* ppu, enum ppu_v1_ if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_ppu_mode) { @@ -5614,8 +5614,8 @@ void ppu_v1_ack_power_active_edge_interrupt(struct ppu_v1_reg* ppu, enum ppu_v1_ UNITY_CLR_DETAILS(); } -void CMockExpectParameters_ppu_v1_ack_power_active_edge_interrupt(CMOCK_ppu_v1_ack_power_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode); -void CMockExpectParameters_ppu_v1_ack_power_active_edge_interrupt(CMOCK_ppu_v1_ack_power_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode) +void CMockExpectParameters_ppu_v1_ack_power_active_edge_interrupt(CMOCK_ppu_v1_ack_power_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode); +void CMockExpectParameters_ppu_v1_ack_power_active_edge_interrupt(CMOCK_ppu_v1_ack_power_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -5649,7 +5649,7 @@ void ppu_v1_ack_power_active_edge_interrupt_CMockExpectAnyArgs(UNITY_LINE_TYPE c cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_ack_power_active_edge_interrupt_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode) +void ppu_v1_ack_power_active_edge_interrupt_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_ack_power_active_edge_interrupt_CALL_INSTANCE)); CMOCK_ppu_v1_ack_power_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_ack_power_active_edge_interrupt_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -5676,7 +5676,7 @@ void ppu_v1_ack_power_active_edge_interrupt_Stub(CMOCK_ppu_v1_ack_power_active_e Mock.ppu_v1_ack_power_active_edge_interrupt_CallbackFunctionPointer = Callback; } -void ppu_v1_ack_power_active_edge_interrupt_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode) +void ppu_v1_ack_power_active_edge_interrupt_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_ack_power_active_edge_interrupt_CALL_INSTANCE)); CMOCK_ppu_v1_ack_power_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_ack_power_active_edge_interrupt_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -5689,7 +5689,7 @@ void ppu_v1_ack_power_active_edge_interrupt_CMockExpectWithArray(UNITY_LINE_TYPE CMockExpectParameters_ppu_v1_ack_power_active_edge_interrupt(cmock_call_instance, ppu, ppu_Depth, ppu_mode); } -void ppu_v1_ack_power_active_edge_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_ack_power_active_edge_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_ack_power_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_ack_power_active_edge_interrupt_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_ack_power_active_edge_interrupt_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -5712,7 +5712,7 @@ void ppu_v1_ack_power_active_edge_interrupt_CMockIgnoreArg_ppu_mode(UNITY_LINE_T cmock_call_instance->IgnoreArg_ppu_mode = 1; } -bool ppu_v1_is_power_active_edge_interrupt(struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode) +bool ppu_v1_is_power_active_edge_interrupt(struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_is_power_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance; @@ -5744,7 +5744,7 @@ bool ppu_v1_is_power_active_edge_interrupt(struct ppu_v1_reg* ppu, enum ppu_v1_m if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_ppu_mode) { @@ -5766,8 +5766,8 @@ bool ppu_v1_is_power_active_edge_interrupt(struct ppu_v1_reg* ppu, enum ppu_v1_m return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_ppu_v1_is_power_active_edge_interrupt(CMOCK_ppu_v1_is_power_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode); -void CMockExpectParameters_ppu_v1_is_power_active_edge_interrupt(CMOCK_ppu_v1_is_power_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode) +void CMockExpectParameters_ppu_v1_is_power_active_edge_interrupt(CMOCK_ppu_v1_is_power_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode); +void CMockExpectParameters_ppu_v1_is_power_active_edge_interrupt(CMOCK_ppu_v1_is_power_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -5813,7 +5813,7 @@ void ppu_v1_is_power_active_edge_interrupt_CMockExpectAnyArgsAndReturn(UNITY_LIN cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_is_power_active_edge_interrupt_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, bool cmock_to_return) +void ppu_v1_is_power_active_edge_interrupt_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode, bool cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_is_power_active_edge_interrupt_CALL_INSTANCE)); CMOCK_ppu_v1_is_power_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_power_active_edge_interrupt_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -5841,7 +5841,7 @@ void ppu_v1_is_power_active_edge_interrupt_Stub(CMOCK_ppu_v1_is_power_active_edg Mock.ppu_v1_is_power_active_edge_interrupt_CallbackFunctionPointer = Callback; } -void ppu_v1_is_power_active_edge_interrupt_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, bool cmock_to_return) +void ppu_v1_is_power_active_edge_interrupt_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, bool cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_is_power_active_edge_interrupt_CALL_INSTANCE)); CMOCK_ppu_v1_is_power_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_power_active_edge_interrupt_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -5855,7 +5855,7 @@ void ppu_v1_is_power_active_edge_interrupt_CMockExpectWithArrayAndReturn(UNITY_L cmock_call_instance->ReturnVal = cmock_to_return; } -void ppu_v1_is_power_active_edge_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_is_power_active_edge_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_is_power_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_power_active_edge_interrupt_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_is_power_active_edge_interrupt_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -5878,7 +5878,7 @@ void ppu_v1_is_power_active_edge_interrupt_CMockIgnoreArg_ppu_mode(UNITY_LINE_TY cmock_call_instance->IgnoreArg_ppu_mode = 1; } -void ppu_v1_set_op_active_edge_sensitivity(struct ppu_v1_reg* ppu, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity edge_sensitivity) +void ppu_v1_set_op_active_edge_sensitivity(struct ppu_v1_regs* ppu, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity edge_sensitivity) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_set_op_active_edge_sensitivity_CALL_INSTANCE* cmock_call_instance; @@ -5907,7 +5907,7 @@ void ppu_v1_set_op_active_edge_sensitivity(struct ppu_v1_reg* ppu, enum ppu_v1_o if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_op_devactive) { @@ -5933,8 +5933,8 @@ void ppu_v1_set_op_active_edge_sensitivity(struct ppu_v1_reg* ppu, enum ppu_v1_o UNITY_CLR_DETAILS(); } -void CMockExpectParameters_ppu_v1_set_op_active_edge_sensitivity(CMOCK_ppu_v1_set_op_active_edge_sensitivity_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity edge_sensitivity); -void CMockExpectParameters_ppu_v1_set_op_active_edge_sensitivity(CMOCK_ppu_v1_set_op_active_edge_sensitivity_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity edge_sensitivity) +void CMockExpectParameters_ppu_v1_set_op_active_edge_sensitivity(CMOCK_ppu_v1_set_op_active_edge_sensitivity_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity edge_sensitivity); +void CMockExpectParameters_ppu_v1_set_op_active_edge_sensitivity(CMOCK_ppu_v1_set_op_active_edge_sensitivity_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity edge_sensitivity) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -5971,7 +5971,7 @@ void ppu_v1_set_op_active_edge_sensitivity_CMockExpectAnyArgs(UNITY_LINE_TYPE cm cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_set_op_active_edge_sensitivity_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity edge_sensitivity) +void ppu_v1_set_op_active_edge_sensitivity_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity edge_sensitivity) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_set_op_active_edge_sensitivity_CALL_INSTANCE)); CMOCK_ppu_v1_set_op_active_edge_sensitivity_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_set_op_active_edge_sensitivity_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -5998,7 +5998,7 @@ void ppu_v1_set_op_active_edge_sensitivity_Stub(CMOCK_ppu_v1_set_op_active_edge_ Mock.ppu_v1_set_op_active_edge_sensitivity_CallbackFunctionPointer = Callback; } -void ppu_v1_set_op_active_edge_sensitivity_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity edge_sensitivity) +void ppu_v1_set_op_active_edge_sensitivity_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity edge_sensitivity) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_set_op_active_edge_sensitivity_CALL_INSTANCE)); CMOCK_ppu_v1_set_op_active_edge_sensitivity_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_set_op_active_edge_sensitivity_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -6011,7 +6011,7 @@ void ppu_v1_set_op_active_edge_sensitivity_CMockExpectWithArray(UNITY_LINE_TYPE CMockExpectParameters_ppu_v1_set_op_active_edge_sensitivity(cmock_call_instance, ppu, ppu_Depth, op_devactive, edge_sensitivity); } -void ppu_v1_set_op_active_edge_sensitivity_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_set_op_active_edge_sensitivity_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_set_op_active_edge_sensitivity_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_set_op_active_edge_sensitivity_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_set_op_active_edge_sensitivity_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -6041,7 +6041,7 @@ void ppu_v1_set_op_active_edge_sensitivity_CMockIgnoreArg_edge_sensitivity(UNITY cmock_call_instance->IgnoreArg_edge_sensitivity = 1; } -enum ppu_v1_edge_sensitivity ppu_v1_get_op_active_edge_sensitivity(struct ppu_v1_reg* ppu, enum ppu_v1_op_devactive op_devactive) +enum ppu_v1_edge_sensitivity ppu_v1_get_op_active_edge_sensitivity(struct ppu_v1_regs* ppu, enum ppu_v1_op_devactive op_devactive) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_get_op_active_edge_sensitivity_CALL_INSTANCE* cmock_call_instance; @@ -6074,7 +6074,7 @@ enum ppu_v1_edge_sensitivity ppu_v1_get_op_active_edge_sensitivity(struct ppu_v1 if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_op_devactive) { @@ -6096,8 +6096,8 @@ enum ppu_v1_edge_sensitivity ppu_v1_get_op_active_edge_sensitivity(struct ppu_v1 return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_ppu_v1_get_op_active_edge_sensitivity(CMOCK_ppu_v1_get_op_active_edge_sensitivity_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive); -void CMockExpectParameters_ppu_v1_get_op_active_edge_sensitivity(CMOCK_ppu_v1_get_op_active_edge_sensitivity_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive) +void CMockExpectParameters_ppu_v1_get_op_active_edge_sensitivity(CMOCK_ppu_v1_get_op_active_edge_sensitivity_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive); +void CMockExpectParameters_ppu_v1_get_op_active_edge_sensitivity(CMOCK_ppu_v1_get_op_active_edge_sensitivity_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -6143,7 +6143,7 @@ void ppu_v1_get_op_active_edge_sensitivity_CMockExpectAnyArgsAndReturn(UNITY_LIN cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_get_op_active_edge_sensitivity_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity cmock_to_return) +void ppu_v1_get_op_active_edge_sensitivity_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_get_op_active_edge_sensitivity_CALL_INSTANCE)); CMOCK_ppu_v1_get_op_active_edge_sensitivity_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_op_active_edge_sensitivity_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -6172,7 +6172,7 @@ void ppu_v1_get_op_active_edge_sensitivity_Stub(CMOCK_ppu_v1_get_op_active_edge_ Mock.ppu_v1_get_op_active_edge_sensitivity_CallbackFunctionPointer = Callback; } -void ppu_v1_get_op_active_edge_sensitivity_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity cmock_to_return) +void ppu_v1_get_op_active_edge_sensitivity_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_get_op_active_edge_sensitivity_CALL_INSTANCE)); CMOCK_ppu_v1_get_op_active_edge_sensitivity_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_op_active_edge_sensitivity_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -6186,7 +6186,7 @@ void ppu_v1_get_op_active_edge_sensitivity_CMockExpectWithArrayAndReturn(UNITY_L cmock_call_instance->ReturnVal = cmock_to_return; } -void ppu_v1_get_op_active_edge_sensitivity_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_get_op_active_edge_sensitivity_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_get_op_active_edge_sensitivity_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_op_active_edge_sensitivity_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_get_op_active_edge_sensitivity_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -6209,7 +6209,7 @@ void ppu_v1_get_op_active_edge_sensitivity_CMockIgnoreArg_op_devactive(UNITY_LIN cmock_call_instance->IgnoreArg_op_devactive = 1; } -void ppu_v1_ack_op_active_edge_interrupt(struct ppu_v1_reg* ppu, enum ppu_v1_op_devactive op_devactive) +void ppu_v1_ack_op_active_edge_interrupt(struct ppu_v1_regs* ppu, enum ppu_v1_op_devactive op_devactive) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_ack_op_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance; @@ -6238,7 +6238,7 @@ void ppu_v1_ack_op_active_edge_interrupt(struct ppu_v1_reg* ppu, enum ppu_v1_op_ if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_op_devactive) { @@ -6259,8 +6259,8 @@ void ppu_v1_ack_op_active_edge_interrupt(struct ppu_v1_reg* ppu, enum ppu_v1_op_ UNITY_CLR_DETAILS(); } -void CMockExpectParameters_ppu_v1_ack_op_active_edge_interrupt(CMOCK_ppu_v1_ack_op_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive); -void CMockExpectParameters_ppu_v1_ack_op_active_edge_interrupt(CMOCK_ppu_v1_ack_op_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive) +void CMockExpectParameters_ppu_v1_ack_op_active_edge_interrupt(CMOCK_ppu_v1_ack_op_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive); +void CMockExpectParameters_ppu_v1_ack_op_active_edge_interrupt(CMOCK_ppu_v1_ack_op_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -6294,7 +6294,7 @@ void ppu_v1_ack_op_active_edge_interrupt_CMockExpectAnyArgs(UNITY_LINE_TYPE cmoc cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_ack_op_active_edge_interrupt_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_op_devactive op_devactive) +void ppu_v1_ack_op_active_edge_interrupt_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_op_devactive op_devactive) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_ack_op_active_edge_interrupt_CALL_INSTANCE)); CMOCK_ppu_v1_ack_op_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_ack_op_active_edge_interrupt_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -6321,7 +6321,7 @@ void ppu_v1_ack_op_active_edge_interrupt_Stub(CMOCK_ppu_v1_ack_op_active_edge_in Mock.ppu_v1_ack_op_active_edge_interrupt_CallbackFunctionPointer = Callback; } -void ppu_v1_ack_op_active_edge_interrupt_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive) +void ppu_v1_ack_op_active_edge_interrupt_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_ack_op_active_edge_interrupt_CALL_INSTANCE)); CMOCK_ppu_v1_ack_op_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_ack_op_active_edge_interrupt_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -6334,7 +6334,7 @@ void ppu_v1_ack_op_active_edge_interrupt_CMockExpectWithArray(UNITY_LINE_TYPE cm CMockExpectParameters_ppu_v1_ack_op_active_edge_interrupt(cmock_call_instance, ppu, ppu_Depth, op_devactive); } -void ppu_v1_ack_op_active_edge_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_ack_op_active_edge_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_ack_op_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_ack_op_active_edge_interrupt_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_ack_op_active_edge_interrupt_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -6357,7 +6357,7 @@ void ppu_v1_ack_op_active_edge_interrupt_CMockIgnoreArg_op_devactive(UNITY_LINE_ cmock_call_instance->IgnoreArg_op_devactive = 1; } -bool ppu_v1_is_op_active_edge_interrupt(struct ppu_v1_reg* ppu, enum ppu_v1_op_devactive op_devactive) +bool ppu_v1_is_op_active_edge_interrupt(struct ppu_v1_regs* ppu, enum ppu_v1_op_devactive op_devactive) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_is_op_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance; @@ -6389,7 +6389,7 @@ bool ppu_v1_is_op_active_edge_interrupt(struct ppu_v1_reg* ppu, enum ppu_v1_op_d if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } if (!cmock_call_instance->IgnoreArg_op_devactive) { @@ -6411,8 +6411,8 @@ bool ppu_v1_is_op_active_edge_interrupt(struct ppu_v1_reg* ppu, enum ppu_v1_op_d return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_ppu_v1_is_op_active_edge_interrupt(CMOCK_ppu_v1_is_op_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive); -void CMockExpectParameters_ppu_v1_is_op_active_edge_interrupt(CMOCK_ppu_v1_is_op_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive) +void CMockExpectParameters_ppu_v1_is_op_active_edge_interrupt(CMOCK_ppu_v1_is_op_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive); +void CMockExpectParameters_ppu_v1_is_op_active_edge_interrupt(CMOCK_ppu_v1_is_op_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -6458,7 +6458,7 @@ void ppu_v1_is_op_active_edge_interrupt_CMockExpectAnyArgsAndReturn(UNITY_LINE_T cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_is_op_active_edge_interrupt_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_op_devactive op_devactive, bool cmock_to_return) +void ppu_v1_is_op_active_edge_interrupt_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_op_devactive op_devactive, bool cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_is_op_active_edge_interrupt_CALL_INSTANCE)); CMOCK_ppu_v1_is_op_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_op_active_edge_interrupt_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -6486,7 +6486,7 @@ void ppu_v1_is_op_active_edge_interrupt_Stub(CMOCK_ppu_v1_is_op_active_edge_inte Mock.ppu_v1_is_op_active_edge_interrupt_CallbackFunctionPointer = Callback; } -void ppu_v1_is_op_active_edge_interrupt_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive, bool cmock_to_return) +void ppu_v1_is_op_active_edge_interrupt_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive, bool cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_is_op_active_edge_interrupt_CALL_INSTANCE)); CMOCK_ppu_v1_is_op_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_op_active_edge_interrupt_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -6500,7 +6500,7 @@ void ppu_v1_is_op_active_edge_interrupt_CMockExpectWithArrayAndReturn(UNITY_LINE cmock_call_instance->ReturnVal = cmock_to_return; } -void ppu_v1_is_op_active_edge_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_is_op_active_edge_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_is_op_active_edge_interrupt_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_op_active_edge_interrupt_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_is_op_active_edge_interrupt_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -6523,7 +6523,7 @@ void ppu_v1_is_op_active_edge_interrupt_CMockIgnoreArg_op_devactive(UNITY_LINE_T cmock_call_instance->IgnoreArg_op_devactive = 1; } -bool ppu_v1_is_dyn_policy_min_interrupt(struct ppu_v1_reg* ppu) +bool ppu_v1_is_dyn_policy_min_interrupt(struct ppu_v1_regs* ppu) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_is_dyn_policy_min_interrupt_CALL_INSTANCE* cmock_call_instance; @@ -6555,7 +6555,7 @@ bool ppu_v1_is_dyn_policy_min_interrupt(struct ppu_v1_reg* ppu) if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } } if (Mock.ppu_v1_is_dyn_policy_min_interrupt_CallbackFunctionPointer != NULL) @@ -6572,8 +6572,8 @@ bool ppu_v1_is_dyn_policy_min_interrupt(struct ppu_v1_reg* ppu) return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_ppu_v1_is_dyn_policy_min_interrupt(CMOCK_ppu_v1_is_dyn_policy_min_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth); -void CMockExpectParameters_ppu_v1_is_dyn_policy_min_interrupt(CMOCK_ppu_v1_is_dyn_policy_min_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth) +void CMockExpectParameters_ppu_v1_is_dyn_policy_min_interrupt(CMOCK_ppu_v1_is_dyn_policy_min_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth); +void CMockExpectParameters_ppu_v1_is_dyn_policy_min_interrupt(CMOCK_ppu_v1_is_dyn_policy_min_interrupt_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -6616,7 +6616,7 @@ void ppu_v1_is_dyn_policy_min_interrupt_CMockExpectAnyArgsAndReturn(UNITY_LINE_T cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_is_dyn_policy_min_interrupt_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, bool cmock_to_return) +void ppu_v1_is_dyn_policy_min_interrupt_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, bool cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_is_dyn_policy_min_interrupt_CALL_INSTANCE)); CMOCK_ppu_v1_is_dyn_policy_min_interrupt_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_dyn_policy_min_interrupt_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -6644,7 +6644,7 @@ void ppu_v1_is_dyn_policy_min_interrupt_Stub(CMOCK_ppu_v1_is_dyn_policy_min_inte Mock.ppu_v1_is_dyn_policy_min_interrupt_CallbackFunctionPointer = Callback; } -void ppu_v1_is_dyn_policy_min_interrupt_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, bool cmock_to_return) +void ppu_v1_is_dyn_policy_min_interrupt_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, bool cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_is_dyn_policy_min_interrupt_CALL_INSTANCE)); CMOCK_ppu_v1_is_dyn_policy_min_interrupt_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_dyn_policy_min_interrupt_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -6658,7 +6658,7 @@ void ppu_v1_is_dyn_policy_min_interrupt_CMockExpectWithArrayAndReturn(UNITY_LINE cmock_call_instance->ReturnVal = cmock_to_return; } -void ppu_v1_is_dyn_policy_min_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_is_dyn_policy_min_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_is_dyn_policy_min_interrupt_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_is_dyn_policy_min_interrupt_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_is_dyn_policy_min_interrupt_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -6674,7 +6674,7 @@ void ppu_v1_is_dyn_policy_min_interrupt_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock cmock_call_instance->IgnoreArg_ppu = 1; } -unsigned int ppu_v1_get_num_opmode(struct ppu_v1_reg* ppu) +unsigned int ppu_v1_get_num_opmode(struct ppu_v1_regs* ppu) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_get_num_opmode_CALL_INSTANCE* cmock_call_instance; @@ -6706,7 +6706,7 @@ unsigned int ppu_v1_get_num_opmode(struct ppu_v1_reg* ppu) if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } } if (Mock.ppu_v1_get_num_opmode_CallbackFunctionPointer != NULL) @@ -6723,8 +6723,8 @@ unsigned int ppu_v1_get_num_opmode(struct ppu_v1_reg* ppu) return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_ppu_v1_get_num_opmode(CMOCK_ppu_v1_get_num_opmode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth); -void CMockExpectParameters_ppu_v1_get_num_opmode(CMOCK_ppu_v1_get_num_opmode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth) +void CMockExpectParameters_ppu_v1_get_num_opmode(CMOCK_ppu_v1_get_num_opmode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth); +void CMockExpectParameters_ppu_v1_get_num_opmode(CMOCK_ppu_v1_get_num_opmode_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -6767,7 +6767,7 @@ void ppu_v1_get_num_opmode_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_lin cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_get_num_opmode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, unsigned int cmock_to_return) +void ppu_v1_get_num_opmode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, unsigned int cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_get_num_opmode_CALL_INSTANCE)); CMOCK_ppu_v1_get_num_opmode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_num_opmode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -6795,7 +6795,7 @@ void ppu_v1_get_num_opmode_Stub(CMOCK_ppu_v1_get_num_opmode_CALLBACK Callback) Mock.ppu_v1_get_num_opmode_CallbackFunctionPointer = Callback; } -void ppu_v1_get_num_opmode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int cmock_to_return) +void ppu_v1_get_num_opmode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_get_num_opmode_CALL_INSTANCE)); CMOCK_ppu_v1_get_num_opmode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_num_opmode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -6809,7 +6809,7 @@ void ppu_v1_get_num_opmode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_l cmock_call_instance->ReturnVal = cmock_to_return; } -void ppu_v1_get_num_opmode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_get_num_opmode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_get_num_opmode_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_num_opmode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_get_num_opmode_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); @@ -6825,7 +6825,7 @@ void ppu_v1_get_num_opmode_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line) cmock_call_instance->IgnoreArg_ppu = 1; } -unsigned int ppu_v1_get_arch_id(struct ppu_v1_reg* ppu) +unsigned int ppu_v1_get_arch_id(struct ppu_v1_regs* ppu) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ppu_v1_get_arch_id_CALL_INSTANCE* cmock_call_instance; @@ -6857,7 +6857,7 @@ unsigned int ppu_v1_get_arch_id(struct ppu_v1_reg* ppu) if (cmock_call_instance->Expected_ppu == NULL) { UNITY_TEST_ASSERT_NULL(ppu, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_reg), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_ppu), (void*)(ppu), sizeof(struct ppu_v1_regs), cmock_call_instance->Expected_ppu_Depth, cmock_line, CMockStringMismatch); } } } if (Mock.ppu_v1_get_arch_id_CallbackFunctionPointer != NULL) @@ -6874,8 +6874,8 @@ unsigned int ppu_v1_get_arch_id(struct ppu_v1_reg* ppu) return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_ppu_v1_get_arch_id(CMOCK_ppu_v1_get_arch_id_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth); -void CMockExpectParameters_ppu_v1_get_arch_id(CMOCK_ppu_v1_get_arch_id_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_reg* ppu, int ppu_Depth) +void CMockExpectParameters_ppu_v1_get_arch_id(CMOCK_ppu_v1_get_arch_id_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth); +void CMockExpectParameters_ppu_v1_get_arch_id(CMOCK_ppu_v1_get_arch_id_CALL_INSTANCE* cmock_call_instance, struct ppu_v1_regs* ppu, int ppu_Depth) { cmock_call_instance->Expected_ppu = ppu; cmock_call_instance->Expected_ppu_Depth = ppu_Depth; @@ -6918,7 +6918,7 @@ void ppu_v1_get_arch_id_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void ppu_v1_get_arch_id_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, unsigned int cmock_to_return) +void ppu_v1_get_arch_id_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, unsigned int cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_get_arch_id_CALL_INSTANCE)); CMOCK_ppu_v1_get_arch_id_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_arch_id_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -6946,7 +6946,7 @@ void ppu_v1_get_arch_id_Stub(CMOCK_ppu_v1_get_arch_id_CALLBACK Callback) Mock.ppu_v1_get_arch_id_CallbackFunctionPointer = Callback; } -void ppu_v1_get_arch_id_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int cmock_to_return) +void ppu_v1_get_arch_id_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int cmock_to_return) { CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ppu_v1_get_arch_id_CALL_INSTANCE)); CMOCK_ppu_v1_get_arch_id_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_arch_id_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); @@ -6960,7 +6960,7 @@ void ppu_v1_get_arch_id_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line cmock_call_instance->ReturnVal = cmock_to_return; } -void ppu_v1_get_arch_id_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size) +void ppu_v1_get_arch_id_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size) { CMOCK_ppu_v1_get_arch_id_CALL_INSTANCE* cmock_call_instance = (CMOCK_ppu_v1_get_arch_id_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ppu_v1_get_arch_id_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); diff --git a/module/ppu_v1/test/mocks/Mockppu_v1.h b/module/ppu_v1/test/mocks/Mockppu_v1.h index 0451244c0..e11308eb6 100644 --- a/module/ppu_v1/test/mocks/Mockppu_v1.h +++ b/module/ppu_v1/test/mocks/Mockppu_v1.h @@ -31,17 +31,17 @@ void ppu_v1_init_CMockStopIgnore(void); #define ppu_v1_init_ExpectAnyArgs() ppu_v1_init_CMockExpectAnyArgs(__LINE__) void ppu_v1_init_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); #define ppu_v1_init_Expect(ppu) ppu_v1_init_CMockExpect(__LINE__, ppu) -void ppu_v1_init_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu); -typedef void (* CMOCK_ppu_v1_init_CALLBACK)(struct ppu_v1_reg* ppu, int cmock_num_calls); +void ppu_v1_init_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu); +typedef void (* CMOCK_ppu_v1_init_CALLBACK)(struct ppu_v1_regs* ppu, int cmock_num_calls); void ppu_v1_init_AddCallback(CMOCK_ppu_v1_init_CALLBACK Callback); void ppu_v1_init_Stub(CMOCK_ppu_v1_init_CALLBACK Callback); #define ppu_v1_init_StubWithCallback ppu_v1_init_Stub #define ppu_v1_init_ExpectWithArray(ppu, ppu_Depth) ppu_v1_init_CMockExpectWithArray(__LINE__, ppu, ppu_Depth) -void ppu_v1_init_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth); -#define ppu_v1_init_ReturnThruPtr_ppu(ppu) ppu_v1_init_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_init_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth); +#define ppu_v1_init_ReturnThruPtr_ppu(ppu) ppu_v1_init_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_init_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_init_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_init_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_init_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_init_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_init_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_init_IgnoreArg_ppu() ppu_v1_init_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_init_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_set_power_mode_IgnoreAndReturn(cmock_retval) ppu_v1_set_power_mode_CMockIgnoreAndReturn(__LINE__, cmock_retval) @@ -51,17 +51,17 @@ void ppu_v1_set_power_mode_CMockStopIgnore(void); #define ppu_v1_set_power_mode_ExpectAnyArgsAndReturn(cmock_retval) ppu_v1_set_power_mode_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) void ppu_v1_set_power_mode_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); #define ppu_v1_set_power_mode_ExpectAndReturn(ppu, ppu_mode, timer_ctx, cmock_retval) ppu_v1_set_power_mode_CMockExpectAndReturn(__LINE__, ppu, ppu_mode, timer_ctx, cmock_retval) -void ppu_v1_set_power_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, struct ppu_v1_timer_ctx* timer_ctx, int cmock_to_return); -typedef int (* CMOCK_ppu_v1_set_power_mode_CALLBACK)(struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, struct ppu_v1_timer_ctx* timer_ctx, int cmock_num_calls); +void ppu_v1_set_power_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode, struct ppu_v1_timer_ctx* timer_ctx, int cmock_to_return); +typedef int (* CMOCK_ppu_v1_set_power_mode_CALLBACK)(struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode, struct ppu_v1_timer_ctx* timer_ctx, int cmock_num_calls); void ppu_v1_set_power_mode_AddCallback(CMOCK_ppu_v1_set_power_mode_CALLBACK Callback); void ppu_v1_set_power_mode_Stub(CMOCK_ppu_v1_set_power_mode_CALLBACK Callback); #define ppu_v1_set_power_mode_StubWithCallback ppu_v1_set_power_mode_Stub #define ppu_v1_set_power_mode_ExpectWithArrayAndReturn(ppu, ppu_Depth, ppu_mode, timer_ctx, timer_ctx_Depth, cmock_retval) ppu_v1_set_power_mode_CMockExpectWithArrayAndReturn(__LINE__, ppu, ppu_Depth, ppu_mode, timer_ctx, timer_ctx_Depth, cmock_retval) -void ppu_v1_set_power_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, struct ppu_v1_timer_ctx* timer_ctx, int timer_ctx_Depth, int cmock_to_return); -#define ppu_v1_set_power_mode_ReturnThruPtr_ppu(ppu) ppu_v1_set_power_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_set_power_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, struct ppu_v1_timer_ctx* timer_ctx, int timer_ctx_Depth, int cmock_to_return); +#define ppu_v1_set_power_mode_ReturnThruPtr_ppu(ppu) ppu_v1_set_power_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_set_power_mode_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_set_power_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_set_power_mode_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_set_power_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_set_power_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_set_power_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_set_power_mode_ReturnThruPtr_timer_ctx(timer_ctx) ppu_v1_set_power_mode_CMockReturnMemThruPtr_timer_ctx(__LINE__, timer_ctx, sizeof(struct ppu_v1_timer_ctx)) #define ppu_v1_set_power_mode_ReturnArrayThruPtr_timer_ctx(timer_ctx, cmock_len) ppu_v1_set_power_mode_CMockReturnMemThruPtr_timer_ctx(__LINE__, timer_ctx, cmock_len * sizeof(*timer_ctx)) #define ppu_v1_set_power_mode_ReturnMemThruPtr_timer_ctx(timer_ctx, cmock_size) ppu_v1_set_power_mode_CMockReturnMemThruPtr_timer_ctx(__LINE__, timer_ctx, cmock_size) @@ -79,17 +79,17 @@ void ppu_v1_request_power_mode_CMockStopIgnore(void); #define ppu_v1_request_power_mode_ExpectAnyArgsAndReturn(cmock_retval) ppu_v1_request_power_mode_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) void ppu_v1_request_power_mode_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); #define ppu_v1_request_power_mode_ExpectAndReturn(ppu, ppu_mode, cmock_retval) ppu_v1_request_power_mode_CMockExpectAndReturn(__LINE__, ppu, ppu_mode, cmock_retval) -void ppu_v1_request_power_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, int cmock_to_return); -typedef int (* CMOCK_ppu_v1_request_power_mode_CALLBACK)(struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, int cmock_num_calls); +void ppu_v1_request_power_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode, int cmock_to_return); +typedef int (* CMOCK_ppu_v1_request_power_mode_CALLBACK)(struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode, int cmock_num_calls); void ppu_v1_request_power_mode_AddCallback(CMOCK_ppu_v1_request_power_mode_CALLBACK Callback); void ppu_v1_request_power_mode_Stub(CMOCK_ppu_v1_request_power_mode_CALLBACK Callback); #define ppu_v1_request_power_mode_StubWithCallback ppu_v1_request_power_mode_Stub #define ppu_v1_request_power_mode_ExpectWithArrayAndReturn(ppu, ppu_Depth, ppu_mode, cmock_retval) ppu_v1_request_power_mode_CMockExpectWithArrayAndReturn(__LINE__, ppu, ppu_Depth, ppu_mode, cmock_retval) -void ppu_v1_request_power_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, int cmock_to_return); -#define ppu_v1_request_power_mode_ReturnThruPtr_ppu(ppu) ppu_v1_request_power_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_request_power_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, int cmock_to_return); +#define ppu_v1_request_power_mode_ReturnThruPtr_ppu(ppu) ppu_v1_request_power_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_request_power_mode_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_request_power_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_request_power_mode_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_request_power_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_request_power_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_request_power_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_request_power_mode_IgnoreArg_ppu() ppu_v1_request_power_mode_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_request_power_mode_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_request_power_mode_IgnoreArg_ppu_mode() ppu_v1_request_power_mode_CMockIgnoreArg_ppu_mode(__LINE__) @@ -101,17 +101,17 @@ void ppu_v1_request_operating_mode_CMockStopIgnore(void); #define ppu_v1_request_operating_mode_ExpectAnyArgsAndReturn(cmock_retval) ppu_v1_request_operating_mode_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) void ppu_v1_request_operating_mode_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); #define ppu_v1_request_operating_mode_ExpectAndReturn(ppu, op_mode, cmock_retval) ppu_v1_request_operating_mode_CMockExpectAndReturn(__LINE__, ppu, op_mode, cmock_retval) -void ppu_v1_request_operating_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_opmode op_mode, int cmock_to_return); -typedef int (* CMOCK_ppu_v1_request_operating_mode_CALLBACK)(struct ppu_v1_reg* ppu, enum ppu_v1_opmode op_mode, int cmock_num_calls); +void ppu_v1_request_operating_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_opmode op_mode, int cmock_to_return); +typedef int (* CMOCK_ppu_v1_request_operating_mode_CALLBACK)(struct ppu_v1_regs* ppu, enum ppu_v1_opmode op_mode, int cmock_num_calls); void ppu_v1_request_operating_mode_AddCallback(CMOCK_ppu_v1_request_operating_mode_CALLBACK Callback); void ppu_v1_request_operating_mode_Stub(CMOCK_ppu_v1_request_operating_mode_CALLBACK Callback); #define ppu_v1_request_operating_mode_StubWithCallback ppu_v1_request_operating_mode_Stub #define ppu_v1_request_operating_mode_ExpectWithArrayAndReturn(ppu, ppu_Depth, op_mode, cmock_retval) ppu_v1_request_operating_mode_CMockExpectWithArrayAndReturn(__LINE__, ppu, ppu_Depth, op_mode, cmock_retval) -void ppu_v1_request_operating_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_opmode op_mode, int cmock_to_return); -#define ppu_v1_request_operating_mode_ReturnThruPtr_ppu(ppu) ppu_v1_request_operating_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_request_operating_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_opmode op_mode, int cmock_to_return); +#define ppu_v1_request_operating_mode_ReturnThruPtr_ppu(ppu) ppu_v1_request_operating_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_request_operating_mode_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_request_operating_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_request_operating_mode_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_request_operating_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_request_operating_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_request_operating_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_request_operating_mode_IgnoreArg_ppu() ppu_v1_request_operating_mode_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_request_operating_mode_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_request_operating_mode_IgnoreArg_op_mode() ppu_v1_request_operating_mode_CMockIgnoreArg_op_mode(__LINE__) @@ -123,17 +123,17 @@ void ppu_v1_opmode_dynamic_enable_CMockStopIgnore(void); #define ppu_v1_opmode_dynamic_enable_ExpectAnyArgs() ppu_v1_opmode_dynamic_enable_CMockExpectAnyArgs(__LINE__) void ppu_v1_opmode_dynamic_enable_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); #define ppu_v1_opmode_dynamic_enable_Expect(ppu, min_dyn_mode) ppu_v1_opmode_dynamic_enable_CMockExpect(__LINE__, ppu, min_dyn_mode) -void ppu_v1_opmode_dynamic_enable_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_opmode min_dyn_mode); -typedef void (* CMOCK_ppu_v1_opmode_dynamic_enable_CALLBACK)(struct ppu_v1_reg* ppu, enum ppu_v1_opmode min_dyn_mode, int cmock_num_calls); +void ppu_v1_opmode_dynamic_enable_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_opmode min_dyn_mode); +typedef void (* CMOCK_ppu_v1_opmode_dynamic_enable_CALLBACK)(struct ppu_v1_regs* ppu, enum ppu_v1_opmode min_dyn_mode, int cmock_num_calls); void ppu_v1_opmode_dynamic_enable_AddCallback(CMOCK_ppu_v1_opmode_dynamic_enable_CALLBACK Callback); void ppu_v1_opmode_dynamic_enable_Stub(CMOCK_ppu_v1_opmode_dynamic_enable_CALLBACK Callback); #define ppu_v1_opmode_dynamic_enable_StubWithCallback ppu_v1_opmode_dynamic_enable_Stub #define ppu_v1_opmode_dynamic_enable_ExpectWithArray(ppu, ppu_Depth, min_dyn_mode) ppu_v1_opmode_dynamic_enable_CMockExpectWithArray(__LINE__, ppu, ppu_Depth, min_dyn_mode) -void ppu_v1_opmode_dynamic_enable_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_opmode min_dyn_mode); -#define ppu_v1_opmode_dynamic_enable_ReturnThruPtr_ppu(ppu) ppu_v1_opmode_dynamic_enable_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_opmode_dynamic_enable_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_opmode min_dyn_mode); +#define ppu_v1_opmode_dynamic_enable_ReturnThruPtr_ppu(ppu) ppu_v1_opmode_dynamic_enable_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_opmode_dynamic_enable_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_opmode_dynamic_enable_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_opmode_dynamic_enable_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_opmode_dynamic_enable_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_opmode_dynamic_enable_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_opmode_dynamic_enable_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_opmode_dynamic_enable_IgnoreArg_ppu() ppu_v1_opmode_dynamic_enable_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_opmode_dynamic_enable_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_opmode_dynamic_enable_IgnoreArg_min_dyn_mode() ppu_v1_opmode_dynamic_enable_CMockIgnoreArg_min_dyn_mode(__LINE__) @@ -145,17 +145,17 @@ void ppu_v1_dynamic_enable_CMockStopIgnore(void); #define ppu_v1_dynamic_enable_ExpectAnyArgs() ppu_v1_dynamic_enable_CMockExpectAnyArgs(__LINE__) void ppu_v1_dynamic_enable_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); #define ppu_v1_dynamic_enable_Expect(ppu, min_dyn_state) ppu_v1_dynamic_enable_CMockExpect(__LINE__, ppu, min_dyn_state) -void ppu_v1_dynamic_enable_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_mode min_dyn_state); -typedef void (* CMOCK_ppu_v1_dynamic_enable_CALLBACK)(struct ppu_v1_reg* ppu, enum ppu_v1_mode min_dyn_state, int cmock_num_calls); +void ppu_v1_dynamic_enable_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_mode min_dyn_state); +typedef void (* CMOCK_ppu_v1_dynamic_enable_CALLBACK)(struct ppu_v1_regs* ppu, enum ppu_v1_mode min_dyn_state, int cmock_num_calls); void ppu_v1_dynamic_enable_AddCallback(CMOCK_ppu_v1_dynamic_enable_CALLBACK Callback); void ppu_v1_dynamic_enable_Stub(CMOCK_ppu_v1_dynamic_enable_CALLBACK Callback); #define ppu_v1_dynamic_enable_StubWithCallback ppu_v1_dynamic_enable_Stub #define ppu_v1_dynamic_enable_ExpectWithArray(ppu, ppu_Depth, min_dyn_state) ppu_v1_dynamic_enable_CMockExpectWithArray(__LINE__, ppu, ppu_Depth, min_dyn_state) -void ppu_v1_dynamic_enable_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode min_dyn_state); -#define ppu_v1_dynamic_enable_ReturnThruPtr_ppu(ppu) ppu_v1_dynamic_enable_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_dynamic_enable_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode min_dyn_state); +#define ppu_v1_dynamic_enable_ReturnThruPtr_ppu(ppu) ppu_v1_dynamic_enable_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_dynamic_enable_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_dynamic_enable_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_dynamic_enable_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_dynamic_enable_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_dynamic_enable_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_dynamic_enable_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_dynamic_enable_IgnoreArg_ppu() ppu_v1_dynamic_enable_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_dynamic_enable_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_dynamic_enable_IgnoreArg_min_dyn_state() ppu_v1_dynamic_enable_CMockIgnoreArg_min_dyn_state(__LINE__) @@ -167,17 +167,17 @@ void ppu_v1_lock_off_enable_CMockStopIgnore(void); #define ppu_v1_lock_off_enable_ExpectAnyArgs() ppu_v1_lock_off_enable_CMockExpectAnyArgs(__LINE__) void ppu_v1_lock_off_enable_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); #define ppu_v1_lock_off_enable_Expect(ppu) ppu_v1_lock_off_enable_CMockExpect(__LINE__, ppu) -void ppu_v1_lock_off_enable_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu); -typedef void (* CMOCK_ppu_v1_lock_off_enable_CALLBACK)(struct ppu_v1_reg* ppu, int cmock_num_calls); +void ppu_v1_lock_off_enable_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu); +typedef void (* CMOCK_ppu_v1_lock_off_enable_CALLBACK)(struct ppu_v1_regs* ppu, int cmock_num_calls); void ppu_v1_lock_off_enable_AddCallback(CMOCK_ppu_v1_lock_off_enable_CALLBACK Callback); void ppu_v1_lock_off_enable_Stub(CMOCK_ppu_v1_lock_off_enable_CALLBACK Callback); #define ppu_v1_lock_off_enable_StubWithCallback ppu_v1_lock_off_enable_Stub #define ppu_v1_lock_off_enable_ExpectWithArray(ppu, ppu_Depth) ppu_v1_lock_off_enable_CMockExpectWithArray(__LINE__, ppu, ppu_Depth) -void ppu_v1_lock_off_enable_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth); -#define ppu_v1_lock_off_enable_ReturnThruPtr_ppu(ppu) ppu_v1_lock_off_enable_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_lock_off_enable_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth); +#define ppu_v1_lock_off_enable_ReturnThruPtr_ppu(ppu) ppu_v1_lock_off_enable_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_lock_off_enable_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_lock_off_enable_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_lock_off_enable_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_lock_off_enable_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_lock_off_enable_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_lock_off_enable_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_lock_off_enable_IgnoreArg_ppu() ppu_v1_lock_off_enable_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_lock_off_enable_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_lock_off_disable_Ignore() ppu_v1_lock_off_disable_CMockIgnore() @@ -187,17 +187,17 @@ void ppu_v1_lock_off_disable_CMockStopIgnore(void); #define ppu_v1_lock_off_disable_ExpectAnyArgs() ppu_v1_lock_off_disable_CMockExpectAnyArgs(__LINE__) void ppu_v1_lock_off_disable_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); #define ppu_v1_lock_off_disable_Expect(ppu) ppu_v1_lock_off_disable_CMockExpect(__LINE__, ppu) -void ppu_v1_lock_off_disable_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu); -typedef void (* CMOCK_ppu_v1_lock_off_disable_CALLBACK)(struct ppu_v1_reg* ppu, int cmock_num_calls); +void ppu_v1_lock_off_disable_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu); +typedef void (* CMOCK_ppu_v1_lock_off_disable_CALLBACK)(struct ppu_v1_regs* ppu, int cmock_num_calls); void ppu_v1_lock_off_disable_AddCallback(CMOCK_ppu_v1_lock_off_disable_CALLBACK Callback); void ppu_v1_lock_off_disable_Stub(CMOCK_ppu_v1_lock_off_disable_CALLBACK Callback); #define ppu_v1_lock_off_disable_StubWithCallback ppu_v1_lock_off_disable_Stub #define ppu_v1_lock_off_disable_ExpectWithArray(ppu, ppu_Depth) ppu_v1_lock_off_disable_CMockExpectWithArray(__LINE__, ppu, ppu_Depth) -void ppu_v1_lock_off_disable_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth); -#define ppu_v1_lock_off_disable_ReturnThruPtr_ppu(ppu) ppu_v1_lock_off_disable_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_lock_off_disable_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth); +#define ppu_v1_lock_off_disable_ReturnThruPtr_ppu(ppu) ppu_v1_lock_off_disable_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_lock_off_disable_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_lock_off_disable_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_lock_off_disable_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_lock_off_disable_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_lock_off_disable_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_lock_off_disable_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_lock_off_disable_IgnoreArg_ppu() ppu_v1_lock_off_disable_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_lock_off_disable_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_get_power_mode_IgnoreAndReturn(cmock_retval) ppu_v1_get_power_mode_CMockIgnoreAndReturn(__LINE__, cmock_retval) @@ -207,17 +207,17 @@ void ppu_v1_get_power_mode_CMockStopIgnore(void); #define ppu_v1_get_power_mode_ExpectAnyArgsAndReturn(cmock_retval) ppu_v1_get_power_mode_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) void ppu_v1_get_power_mode_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, enum ppu_v1_mode cmock_to_return); #define ppu_v1_get_power_mode_ExpectAndReturn(ppu, cmock_retval) ppu_v1_get_power_mode_CMockExpectAndReturn(__LINE__, ppu, cmock_retval) -void ppu_v1_get_power_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_mode cmock_to_return); -typedef enum ppu_v1_mode (* CMOCK_ppu_v1_get_power_mode_CALLBACK)(struct ppu_v1_reg* ppu, int cmock_num_calls); +void ppu_v1_get_power_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_mode cmock_to_return); +typedef enum ppu_v1_mode (* CMOCK_ppu_v1_get_power_mode_CALLBACK)(struct ppu_v1_regs* ppu, int cmock_num_calls); void ppu_v1_get_power_mode_AddCallback(CMOCK_ppu_v1_get_power_mode_CALLBACK Callback); void ppu_v1_get_power_mode_Stub(CMOCK_ppu_v1_get_power_mode_CALLBACK Callback); #define ppu_v1_get_power_mode_StubWithCallback ppu_v1_get_power_mode_Stub #define ppu_v1_get_power_mode_ExpectWithArrayAndReturn(ppu, ppu_Depth, cmock_retval) ppu_v1_get_power_mode_CMockExpectWithArrayAndReturn(__LINE__, ppu, ppu_Depth, cmock_retval) -void ppu_v1_get_power_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode cmock_to_return); -#define ppu_v1_get_power_mode_ReturnThruPtr_ppu(ppu) ppu_v1_get_power_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_get_power_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode cmock_to_return); +#define ppu_v1_get_power_mode_ReturnThruPtr_ppu(ppu) ppu_v1_get_power_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_get_power_mode_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_get_power_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_get_power_mode_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_get_power_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_get_power_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_get_power_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_get_power_mode_IgnoreArg_ppu() ppu_v1_get_power_mode_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_get_power_mode_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_get_programmed_power_mode_IgnoreAndReturn(cmock_retval) ppu_v1_get_programmed_power_mode_CMockIgnoreAndReturn(__LINE__, cmock_retval) @@ -227,17 +227,17 @@ void ppu_v1_get_programmed_power_mode_CMockStopIgnore(void); #define ppu_v1_get_programmed_power_mode_ExpectAnyArgsAndReturn(cmock_retval) ppu_v1_get_programmed_power_mode_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) void ppu_v1_get_programmed_power_mode_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, enum ppu_v1_mode cmock_to_return); #define ppu_v1_get_programmed_power_mode_ExpectAndReturn(ppu, cmock_retval) ppu_v1_get_programmed_power_mode_CMockExpectAndReturn(__LINE__, ppu, cmock_retval) -void ppu_v1_get_programmed_power_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_mode cmock_to_return); -typedef enum ppu_v1_mode (* CMOCK_ppu_v1_get_programmed_power_mode_CALLBACK)(struct ppu_v1_reg* ppu, int cmock_num_calls); +void ppu_v1_get_programmed_power_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_mode cmock_to_return); +typedef enum ppu_v1_mode (* CMOCK_ppu_v1_get_programmed_power_mode_CALLBACK)(struct ppu_v1_regs* ppu, int cmock_num_calls); void ppu_v1_get_programmed_power_mode_AddCallback(CMOCK_ppu_v1_get_programmed_power_mode_CALLBACK Callback); void ppu_v1_get_programmed_power_mode_Stub(CMOCK_ppu_v1_get_programmed_power_mode_CALLBACK Callback); #define ppu_v1_get_programmed_power_mode_StubWithCallback ppu_v1_get_programmed_power_mode_Stub #define ppu_v1_get_programmed_power_mode_ExpectWithArrayAndReturn(ppu, ppu_Depth, cmock_retval) ppu_v1_get_programmed_power_mode_CMockExpectWithArrayAndReturn(__LINE__, ppu, ppu_Depth, cmock_retval) -void ppu_v1_get_programmed_power_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode cmock_to_return); -#define ppu_v1_get_programmed_power_mode_ReturnThruPtr_ppu(ppu) ppu_v1_get_programmed_power_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_get_programmed_power_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode cmock_to_return); +#define ppu_v1_get_programmed_power_mode_ReturnThruPtr_ppu(ppu) ppu_v1_get_programmed_power_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_get_programmed_power_mode_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_get_programmed_power_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_get_programmed_power_mode_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_get_programmed_power_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_get_programmed_power_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_get_programmed_power_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_get_programmed_power_mode_IgnoreArg_ppu() ppu_v1_get_programmed_power_mode_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_get_programmed_power_mode_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_get_operating_mode_IgnoreAndReturn(cmock_retval) ppu_v1_get_operating_mode_CMockIgnoreAndReturn(__LINE__, cmock_retval) @@ -247,17 +247,17 @@ void ppu_v1_get_operating_mode_CMockStopIgnore(void); #define ppu_v1_get_operating_mode_ExpectAnyArgsAndReturn(cmock_retval) ppu_v1_get_operating_mode_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) void ppu_v1_get_operating_mode_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, enum ppu_v1_opmode cmock_to_return); #define ppu_v1_get_operating_mode_ExpectAndReturn(ppu, cmock_retval) ppu_v1_get_operating_mode_CMockExpectAndReturn(__LINE__, ppu, cmock_retval) -void ppu_v1_get_operating_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_opmode cmock_to_return); -typedef enum ppu_v1_opmode (* CMOCK_ppu_v1_get_operating_mode_CALLBACK)(struct ppu_v1_reg* ppu, int cmock_num_calls); +void ppu_v1_get_operating_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_opmode cmock_to_return); +typedef enum ppu_v1_opmode (* CMOCK_ppu_v1_get_operating_mode_CALLBACK)(struct ppu_v1_regs* ppu, int cmock_num_calls); void ppu_v1_get_operating_mode_AddCallback(CMOCK_ppu_v1_get_operating_mode_CALLBACK Callback); void ppu_v1_get_operating_mode_Stub(CMOCK_ppu_v1_get_operating_mode_CALLBACK Callback); #define ppu_v1_get_operating_mode_StubWithCallback ppu_v1_get_operating_mode_Stub #define ppu_v1_get_operating_mode_ExpectWithArrayAndReturn(ppu, ppu_Depth, cmock_retval) ppu_v1_get_operating_mode_CMockExpectWithArrayAndReturn(__LINE__, ppu, ppu_Depth, cmock_retval) -void ppu_v1_get_operating_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_opmode cmock_to_return); -#define ppu_v1_get_operating_mode_ReturnThruPtr_ppu(ppu) ppu_v1_get_operating_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_get_operating_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_opmode cmock_to_return); +#define ppu_v1_get_operating_mode_ReturnThruPtr_ppu(ppu) ppu_v1_get_operating_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_get_operating_mode_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_get_operating_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_get_operating_mode_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_get_operating_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_get_operating_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_get_operating_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_get_operating_mode_IgnoreArg_ppu() ppu_v1_get_operating_mode_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_get_operating_mode_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_get_programmed_operating_mode_IgnoreAndReturn(cmock_retval) ppu_v1_get_programmed_operating_mode_CMockIgnoreAndReturn(__LINE__, cmock_retval) @@ -267,17 +267,17 @@ void ppu_v1_get_programmed_operating_mode_CMockStopIgnore(void); #define ppu_v1_get_programmed_operating_mode_ExpectAnyArgsAndReturn(cmock_retval) ppu_v1_get_programmed_operating_mode_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) void ppu_v1_get_programmed_operating_mode_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, enum ppu_v1_opmode cmock_to_return); #define ppu_v1_get_programmed_operating_mode_ExpectAndReturn(ppu, cmock_retval) ppu_v1_get_programmed_operating_mode_CMockExpectAndReturn(__LINE__, ppu, cmock_retval) -void ppu_v1_get_programmed_operating_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_opmode cmock_to_return); -typedef enum ppu_v1_opmode (* CMOCK_ppu_v1_get_programmed_operating_mode_CALLBACK)(struct ppu_v1_reg* ppu, int cmock_num_calls); +void ppu_v1_get_programmed_operating_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_opmode cmock_to_return); +typedef enum ppu_v1_opmode (* CMOCK_ppu_v1_get_programmed_operating_mode_CALLBACK)(struct ppu_v1_regs* ppu, int cmock_num_calls); void ppu_v1_get_programmed_operating_mode_AddCallback(CMOCK_ppu_v1_get_programmed_operating_mode_CALLBACK Callback); void ppu_v1_get_programmed_operating_mode_Stub(CMOCK_ppu_v1_get_programmed_operating_mode_CALLBACK Callback); #define ppu_v1_get_programmed_operating_mode_StubWithCallback ppu_v1_get_programmed_operating_mode_Stub #define ppu_v1_get_programmed_operating_mode_ExpectWithArrayAndReturn(ppu, ppu_Depth, cmock_retval) ppu_v1_get_programmed_operating_mode_CMockExpectWithArrayAndReturn(__LINE__, ppu, ppu_Depth, cmock_retval) -void ppu_v1_get_programmed_operating_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_opmode cmock_to_return); -#define ppu_v1_get_programmed_operating_mode_ReturnThruPtr_ppu(ppu) ppu_v1_get_programmed_operating_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_get_programmed_operating_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_opmode cmock_to_return); +#define ppu_v1_get_programmed_operating_mode_ReturnThruPtr_ppu(ppu) ppu_v1_get_programmed_operating_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_get_programmed_operating_mode_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_get_programmed_operating_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_get_programmed_operating_mode_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_get_programmed_operating_mode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_get_programmed_operating_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_get_programmed_operating_mode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_get_programmed_operating_mode_IgnoreArg_ppu() ppu_v1_get_programmed_operating_mode_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_get_programmed_operating_mode_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_is_dynamic_enabled_IgnoreAndReturn(cmock_retval) ppu_v1_is_dynamic_enabled_CMockIgnoreAndReturn(__LINE__, cmock_retval) @@ -287,17 +287,17 @@ void ppu_v1_is_dynamic_enabled_CMockStopIgnore(void); #define ppu_v1_is_dynamic_enabled_ExpectAnyArgsAndReturn(cmock_retval) ppu_v1_is_dynamic_enabled_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) void ppu_v1_is_dynamic_enabled_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return); #define ppu_v1_is_dynamic_enabled_ExpectAndReturn(ppu, cmock_retval) ppu_v1_is_dynamic_enabled_CMockExpectAndReturn(__LINE__, ppu, cmock_retval) -void ppu_v1_is_dynamic_enabled_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, bool cmock_to_return); -typedef bool (* CMOCK_ppu_v1_is_dynamic_enabled_CALLBACK)(struct ppu_v1_reg* ppu, int cmock_num_calls); +void ppu_v1_is_dynamic_enabled_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, bool cmock_to_return); +typedef bool (* CMOCK_ppu_v1_is_dynamic_enabled_CALLBACK)(struct ppu_v1_regs* ppu, int cmock_num_calls); void ppu_v1_is_dynamic_enabled_AddCallback(CMOCK_ppu_v1_is_dynamic_enabled_CALLBACK Callback); void ppu_v1_is_dynamic_enabled_Stub(CMOCK_ppu_v1_is_dynamic_enabled_CALLBACK Callback); #define ppu_v1_is_dynamic_enabled_StubWithCallback ppu_v1_is_dynamic_enabled_Stub #define ppu_v1_is_dynamic_enabled_ExpectWithArrayAndReturn(ppu, ppu_Depth, cmock_retval) ppu_v1_is_dynamic_enabled_CMockExpectWithArrayAndReturn(__LINE__, ppu, ppu_Depth, cmock_retval) -void ppu_v1_is_dynamic_enabled_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, bool cmock_to_return); -#define ppu_v1_is_dynamic_enabled_ReturnThruPtr_ppu(ppu) ppu_v1_is_dynamic_enabled_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_is_dynamic_enabled_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, bool cmock_to_return); +#define ppu_v1_is_dynamic_enabled_ReturnThruPtr_ppu(ppu) ppu_v1_is_dynamic_enabled_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_is_dynamic_enabled_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_is_dynamic_enabled_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_is_dynamic_enabled_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_is_dynamic_enabled_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_is_dynamic_enabled_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_is_dynamic_enabled_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_is_dynamic_enabled_IgnoreArg_ppu() ppu_v1_is_dynamic_enabled_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_is_dynamic_enabled_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_is_locked_IgnoreAndReturn(cmock_retval) ppu_v1_is_locked_CMockIgnoreAndReturn(__LINE__, cmock_retval) @@ -307,17 +307,17 @@ void ppu_v1_is_locked_CMockStopIgnore(void); #define ppu_v1_is_locked_ExpectAnyArgsAndReturn(cmock_retval) ppu_v1_is_locked_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) void ppu_v1_is_locked_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return); #define ppu_v1_is_locked_ExpectAndReturn(ppu, cmock_retval) ppu_v1_is_locked_CMockExpectAndReturn(__LINE__, ppu, cmock_retval) -void ppu_v1_is_locked_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, bool cmock_to_return); -typedef bool (* CMOCK_ppu_v1_is_locked_CALLBACK)(struct ppu_v1_reg* ppu, int cmock_num_calls); +void ppu_v1_is_locked_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, bool cmock_to_return); +typedef bool (* CMOCK_ppu_v1_is_locked_CALLBACK)(struct ppu_v1_regs* ppu, int cmock_num_calls); void ppu_v1_is_locked_AddCallback(CMOCK_ppu_v1_is_locked_CALLBACK Callback); void ppu_v1_is_locked_Stub(CMOCK_ppu_v1_is_locked_CALLBACK Callback); #define ppu_v1_is_locked_StubWithCallback ppu_v1_is_locked_Stub #define ppu_v1_is_locked_ExpectWithArrayAndReturn(ppu, ppu_Depth, cmock_retval) ppu_v1_is_locked_CMockExpectWithArrayAndReturn(__LINE__, ppu, ppu_Depth, cmock_retval) -void ppu_v1_is_locked_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, bool cmock_to_return); -#define ppu_v1_is_locked_ReturnThruPtr_ppu(ppu) ppu_v1_is_locked_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_is_locked_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, bool cmock_to_return); +#define ppu_v1_is_locked_ReturnThruPtr_ppu(ppu) ppu_v1_is_locked_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_is_locked_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_is_locked_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_is_locked_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_is_locked_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_is_locked_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_is_locked_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_is_locked_IgnoreArg_ppu() ppu_v1_is_locked_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_is_locked_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_is_power_devactive_high_IgnoreAndReturn(cmock_retval) ppu_v1_is_power_devactive_high_CMockIgnoreAndReturn(__LINE__, cmock_retval) @@ -327,17 +327,17 @@ void ppu_v1_is_power_devactive_high_CMockStopIgnore(void); #define ppu_v1_is_power_devactive_high_ExpectAnyArgsAndReturn(cmock_retval) ppu_v1_is_power_devactive_high_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) void ppu_v1_is_power_devactive_high_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return); #define ppu_v1_is_power_devactive_high_ExpectAndReturn(ppu, ppu_mode, cmock_retval) ppu_v1_is_power_devactive_high_CMockExpectAndReturn(__LINE__, ppu, ppu_mode, cmock_retval) -void ppu_v1_is_power_devactive_high_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, bool cmock_to_return); -typedef bool (* CMOCK_ppu_v1_is_power_devactive_high_CALLBACK)(struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, int cmock_num_calls); +void ppu_v1_is_power_devactive_high_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode, bool cmock_to_return); +typedef bool (* CMOCK_ppu_v1_is_power_devactive_high_CALLBACK)(struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode, int cmock_num_calls); void ppu_v1_is_power_devactive_high_AddCallback(CMOCK_ppu_v1_is_power_devactive_high_CALLBACK Callback); void ppu_v1_is_power_devactive_high_Stub(CMOCK_ppu_v1_is_power_devactive_high_CALLBACK Callback); #define ppu_v1_is_power_devactive_high_StubWithCallback ppu_v1_is_power_devactive_high_Stub #define ppu_v1_is_power_devactive_high_ExpectWithArrayAndReturn(ppu, ppu_Depth, ppu_mode, cmock_retval) ppu_v1_is_power_devactive_high_CMockExpectWithArrayAndReturn(__LINE__, ppu, ppu_Depth, ppu_mode, cmock_retval) -void ppu_v1_is_power_devactive_high_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, bool cmock_to_return); -#define ppu_v1_is_power_devactive_high_ReturnThruPtr_ppu(ppu) ppu_v1_is_power_devactive_high_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_is_power_devactive_high_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, bool cmock_to_return); +#define ppu_v1_is_power_devactive_high_ReturnThruPtr_ppu(ppu) ppu_v1_is_power_devactive_high_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_is_power_devactive_high_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_is_power_devactive_high_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_is_power_devactive_high_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_is_power_devactive_high_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_is_power_devactive_high_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_is_power_devactive_high_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_is_power_devactive_high_IgnoreArg_ppu() ppu_v1_is_power_devactive_high_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_is_power_devactive_high_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_is_power_devactive_high_IgnoreArg_ppu_mode() ppu_v1_is_power_devactive_high_CMockIgnoreArg_ppu_mode(__LINE__) @@ -349,17 +349,17 @@ void ppu_v1_is_op_devactive_high_CMockStopIgnore(void); #define ppu_v1_is_op_devactive_high_ExpectAnyArgsAndReturn(cmock_retval) ppu_v1_is_op_devactive_high_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) void ppu_v1_is_op_devactive_high_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return); #define ppu_v1_is_op_devactive_high_ExpectAndReturn(ppu, op_devactive, cmock_retval) ppu_v1_is_op_devactive_high_CMockExpectAndReturn(__LINE__, ppu, op_devactive, cmock_retval) -void ppu_v1_is_op_devactive_high_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_op_devactive op_devactive, bool cmock_to_return); -typedef bool (* CMOCK_ppu_v1_is_op_devactive_high_CALLBACK)(struct ppu_v1_reg* ppu, enum ppu_v1_op_devactive op_devactive, int cmock_num_calls); +void ppu_v1_is_op_devactive_high_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_op_devactive op_devactive, bool cmock_to_return); +typedef bool (* CMOCK_ppu_v1_is_op_devactive_high_CALLBACK)(struct ppu_v1_regs* ppu, enum ppu_v1_op_devactive op_devactive, int cmock_num_calls); void ppu_v1_is_op_devactive_high_AddCallback(CMOCK_ppu_v1_is_op_devactive_high_CALLBACK Callback); void ppu_v1_is_op_devactive_high_Stub(CMOCK_ppu_v1_is_op_devactive_high_CALLBACK Callback); #define ppu_v1_is_op_devactive_high_StubWithCallback ppu_v1_is_op_devactive_high_Stub #define ppu_v1_is_op_devactive_high_ExpectWithArrayAndReturn(ppu, ppu_Depth, op_devactive, cmock_retval) ppu_v1_is_op_devactive_high_CMockExpectWithArrayAndReturn(__LINE__, ppu, ppu_Depth, op_devactive, cmock_retval) -void ppu_v1_is_op_devactive_high_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive, bool cmock_to_return); -#define ppu_v1_is_op_devactive_high_ReturnThruPtr_ppu(ppu) ppu_v1_is_op_devactive_high_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_is_op_devactive_high_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive, bool cmock_to_return); +#define ppu_v1_is_op_devactive_high_ReturnThruPtr_ppu(ppu) ppu_v1_is_op_devactive_high_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_is_op_devactive_high_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_is_op_devactive_high_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_is_op_devactive_high_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_is_op_devactive_high_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_is_op_devactive_high_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_is_op_devactive_high_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_is_op_devactive_high_IgnoreArg_ppu() ppu_v1_is_op_devactive_high_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_is_op_devactive_high_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_is_op_devactive_high_IgnoreArg_op_devactive() ppu_v1_is_op_devactive_high_CMockIgnoreArg_op_devactive(__LINE__) @@ -371,17 +371,17 @@ void ppu_v1_off_unlock_CMockStopIgnore(void); #define ppu_v1_off_unlock_ExpectAnyArgs() ppu_v1_off_unlock_CMockExpectAnyArgs(__LINE__) void ppu_v1_off_unlock_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); #define ppu_v1_off_unlock_Expect(ppu) ppu_v1_off_unlock_CMockExpect(__LINE__, ppu) -void ppu_v1_off_unlock_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu); -typedef void (* CMOCK_ppu_v1_off_unlock_CALLBACK)(struct ppu_v1_reg* ppu, int cmock_num_calls); +void ppu_v1_off_unlock_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu); +typedef void (* CMOCK_ppu_v1_off_unlock_CALLBACK)(struct ppu_v1_regs* ppu, int cmock_num_calls); void ppu_v1_off_unlock_AddCallback(CMOCK_ppu_v1_off_unlock_CALLBACK Callback); void ppu_v1_off_unlock_Stub(CMOCK_ppu_v1_off_unlock_CALLBACK Callback); #define ppu_v1_off_unlock_StubWithCallback ppu_v1_off_unlock_Stub #define ppu_v1_off_unlock_ExpectWithArray(ppu, ppu_Depth) ppu_v1_off_unlock_CMockExpectWithArray(__LINE__, ppu, ppu_Depth) -void ppu_v1_off_unlock_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth); -#define ppu_v1_off_unlock_ReturnThruPtr_ppu(ppu) ppu_v1_off_unlock_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_off_unlock_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth); +#define ppu_v1_off_unlock_ReturnThruPtr_ppu(ppu) ppu_v1_off_unlock_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_off_unlock_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_off_unlock_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_off_unlock_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_off_unlock_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_off_unlock_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_off_unlock_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_off_unlock_IgnoreArg_ppu() ppu_v1_off_unlock_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_off_unlock_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_disable_devactive_Ignore() ppu_v1_disable_devactive_CMockIgnore() @@ -391,17 +391,17 @@ void ppu_v1_disable_devactive_CMockStopIgnore(void); #define ppu_v1_disable_devactive_ExpectAnyArgs() ppu_v1_disable_devactive_CMockExpectAnyArgs(__LINE__) void ppu_v1_disable_devactive_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); #define ppu_v1_disable_devactive_Expect(ppu) ppu_v1_disable_devactive_CMockExpect(__LINE__, ppu) -void ppu_v1_disable_devactive_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu); -typedef void (* CMOCK_ppu_v1_disable_devactive_CALLBACK)(struct ppu_v1_reg* ppu, int cmock_num_calls); +void ppu_v1_disable_devactive_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu); +typedef void (* CMOCK_ppu_v1_disable_devactive_CALLBACK)(struct ppu_v1_regs* ppu, int cmock_num_calls); void ppu_v1_disable_devactive_AddCallback(CMOCK_ppu_v1_disable_devactive_CALLBACK Callback); void ppu_v1_disable_devactive_Stub(CMOCK_ppu_v1_disable_devactive_CALLBACK Callback); #define ppu_v1_disable_devactive_StubWithCallback ppu_v1_disable_devactive_Stub #define ppu_v1_disable_devactive_ExpectWithArray(ppu, ppu_Depth) ppu_v1_disable_devactive_CMockExpectWithArray(__LINE__, ppu, ppu_Depth) -void ppu_v1_disable_devactive_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth); -#define ppu_v1_disable_devactive_ReturnThruPtr_ppu(ppu) ppu_v1_disable_devactive_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_disable_devactive_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth); +#define ppu_v1_disable_devactive_ReturnThruPtr_ppu(ppu) ppu_v1_disable_devactive_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_disable_devactive_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_disable_devactive_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_disable_devactive_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_disable_devactive_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_disable_devactive_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_disable_devactive_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_disable_devactive_IgnoreArg_ppu() ppu_v1_disable_devactive_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_disable_devactive_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_disable_handshake_Ignore() ppu_v1_disable_handshake_CMockIgnore() @@ -411,17 +411,17 @@ void ppu_v1_disable_handshake_CMockStopIgnore(void); #define ppu_v1_disable_handshake_ExpectAnyArgs() ppu_v1_disable_handshake_CMockExpectAnyArgs(__LINE__) void ppu_v1_disable_handshake_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); #define ppu_v1_disable_handshake_Expect(ppu) ppu_v1_disable_handshake_CMockExpect(__LINE__, ppu) -void ppu_v1_disable_handshake_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu); -typedef void (* CMOCK_ppu_v1_disable_handshake_CALLBACK)(struct ppu_v1_reg* ppu, int cmock_num_calls); +void ppu_v1_disable_handshake_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu); +typedef void (* CMOCK_ppu_v1_disable_handshake_CALLBACK)(struct ppu_v1_regs* ppu, int cmock_num_calls); void ppu_v1_disable_handshake_AddCallback(CMOCK_ppu_v1_disable_handshake_CALLBACK Callback); void ppu_v1_disable_handshake_Stub(CMOCK_ppu_v1_disable_handshake_CALLBACK Callback); #define ppu_v1_disable_handshake_StubWithCallback ppu_v1_disable_handshake_Stub #define ppu_v1_disable_handshake_ExpectWithArray(ppu, ppu_Depth) ppu_v1_disable_handshake_CMockExpectWithArray(__LINE__, ppu, ppu_Depth) -void ppu_v1_disable_handshake_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth); -#define ppu_v1_disable_handshake_ReturnThruPtr_ppu(ppu) ppu_v1_disable_handshake_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_disable_handshake_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth); +#define ppu_v1_disable_handshake_ReturnThruPtr_ppu(ppu) ppu_v1_disable_handshake_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_disable_handshake_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_disable_handshake_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_disable_handshake_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_disable_handshake_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_disable_handshake_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_disable_handshake_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_disable_handshake_IgnoreArg_ppu() ppu_v1_disable_handshake_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_disable_handshake_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_interrupt_mask_Ignore() ppu_v1_interrupt_mask_CMockIgnore() @@ -431,17 +431,17 @@ void ppu_v1_interrupt_mask_CMockStopIgnore(void); #define ppu_v1_interrupt_mask_ExpectAnyArgs() ppu_v1_interrupt_mask_CMockExpectAnyArgs(__LINE__) void ppu_v1_interrupt_mask_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); #define ppu_v1_interrupt_mask_Expect(ppu, mask) ppu_v1_interrupt_mask_CMockExpect(__LINE__, ppu, mask) -void ppu_v1_interrupt_mask_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, unsigned int mask); -typedef void (* CMOCK_ppu_v1_interrupt_mask_CALLBACK)(struct ppu_v1_reg* ppu, unsigned int mask, int cmock_num_calls); +void ppu_v1_interrupt_mask_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, unsigned int mask); +typedef void (* CMOCK_ppu_v1_interrupt_mask_CALLBACK)(struct ppu_v1_regs* ppu, unsigned int mask, int cmock_num_calls); void ppu_v1_interrupt_mask_AddCallback(CMOCK_ppu_v1_interrupt_mask_CALLBACK Callback); void ppu_v1_interrupt_mask_Stub(CMOCK_ppu_v1_interrupt_mask_CALLBACK Callback); #define ppu_v1_interrupt_mask_StubWithCallback ppu_v1_interrupt_mask_Stub #define ppu_v1_interrupt_mask_ExpectWithArray(ppu, ppu_Depth, mask) ppu_v1_interrupt_mask_CMockExpectWithArray(__LINE__, ppu, ppu_Depth, mask) -void ppu_v1_interrupt_mask_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask); -#define ppu_v1_interrupt_mask_ReturnThruPtr_ppu(ppu) ppu_v1_interrupt_mask_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_interrupt_mask_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask); +#define ppu_v1_interrupt_mask_ReturnThruPtr_ppu(ppu) ppu_v1_interrupt_mask_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_interrupt_mask_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_interrupt_mask_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_interrupt_mask_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_interrupt_mask_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_interrupt_mask_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_interrupt_mask_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_interrupt_mask_IgnoreArg_ppu() ppu_v1_interrupt_mask_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_interrupt_mask_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_interrupt_mask_IgnoreArg_mask() ppu_v1_interrupt_mask_CMockIgnoreArg_mask(__LINE__) @@ -453,17 +453,17 @@ void ppu_v1_additional_interrupt_mask_CMockStopIgnore(void); #define ppu_v1_additional_interrupt_mask_ExpectAnyArgs() ppu_v1_additional_interrupt_mask_CMockExpectAnyArgs(__LINE__) void ppu_v1_additional_interrupt_mask_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); #define ppu_v1_additional_interrupt_mask_Expect(ppu, mask) ppu_v1_additional_interrupt_mask_CMockExpect(__LINE__, ppu, mask) -void ppu_v1_additional_interrupt_mask_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, unsigned int mask); -typedef void (* CMOCK_ppu_v1_additional_interrupt_mask_CALLBACK)(struct ppu_v1_reg* ppu, unsigned int mask, int cmock_num_calls); +void ppu_v1_additional_interrupt_mask_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, unsigned int mask); +typedef void (* CMOCK_ppu_v1_additional_interrupt_mask_CALLBACK)(struct ppu_v1_regs* ppu, unsigned int mask, int cmock_num_calls); void ppu_v1_additional_interrupt_mask_AddCallback(CMOCK_ppu_v1_additional_interrupt_mask_CALLBACK Callback); void ppu_v1_additional_interrupt_mask_Stub(CMOCK_ppu_v1_additional_interrupt_mask_CALLBACK Callback); #define ppu_v1_additional_interrupt_mask_StubWithCallback ppu_v1_additional_interrupt_mask_Stub #define ppu_v1_additional_interrupt_mask_ExpectWithArray(ppu, ppu_Depth, mask) ppu_v1_additional_interrupt_mask_CMockExpectWithArray(__LINE__, ppu, ppu_Depth, mask) -void ppu_v1_additional_interrupt_mask_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask); -#define ppu_v1_additional_interrupt_mask_ReturnThruPtr_ppu(ppu) ppu_v1_additional_interrupt_mask_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_additional_interrupt_mask_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask); +#define ppu_v1_additional_interrupt_mask_ReturnThruPtr_ppu(ppu) ppu_v1_additional_interrupt_mask_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_additional_interrupt_mask_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_additional_interrupt_mask_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_additional_interrupt_mask_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_additional_interrupt_mask_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_additional_interrupt_mask_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_additional_interrupt_mask_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_additional_interrupt_mask_IgnoreArg_ppu() ppu_v1_additional_interrupt_mask_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_additional_interrupt_mask_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_additional_interrupt_mask_IgnoreArg_mask() ppu_v1_additional_interrupt_mask_CMockIgnoreArg_mask(__LINE__) @@ -475,17 +475,17 @@ void ppu_v1_interrupt_unmask_CMockStopIgnore(void); #define ppu_v1_interrupt_unmask_ExpectAnyArgs() ppu_v1_interrupt_unmask_CMockExpectAnyArgs(__LINE__) void ppu_v1_interrupt_unmask_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); #define ppu_v1_interrupt_unmask_Expect(ppu, mask) ppu_v1_interrupt_unmask_CMockExpect(__LINE__, ppu, mask) -void ppu_v1_interrupt_unmask_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, unsigned int mask); -typedef void (* CMOCK_ppu_v1_interrupt_unmask_CALLBACK)(struct ppu_v1_reg* ppu, unsigned int mask, int cmock_num_calls); +void ppu_v1_interrupt_unmask_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, unsigned int mask); +typedef void (* CMOCK_ppu_v1_interrupt_unmask_CALLBACK)(struct ppu_v1_regs* ppu, unsigned int mask, int cmock_num_calls); void ppu_v1_interrupt_unmask_AddCallback(CMOCK_ppu_v1_interrupt_unmask_CALLBACK Callback); void ppu_v1_interrupt_unmask_Stub(CMOCK_ppu_v1_interrupt_unmask_CALLBACK Callback); #define ppu_v1_interrupt_unmask_StubWithCallback ppu_v1_interrupt_unmask_Stub #define ppu_v1_interrupt_unmask_ExpectWithArray(ppu, ppu_Depth, mask) ppu_v1_interrupt_unmask_CMockExpectWithArray(__LINE__, ppu, ppu_Depth, mask) -void ppu_v1_interrupt_unmask_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask); -#define ppu_v1_interrupt_unmask_ReturnThruPtr_ppu(ppu) ppu_v1_interrupt_unmask_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_interrupt_unmask_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask); +#define ppu_v1_interrupt_unmask_ReturnThruPtr_ppu(ppu) ppu_v1_interrupt_unmask_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_interrupt_unmask_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_interrupt_unmask_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_interrupt_unmask_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_interrupt_unmask_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_interrupt_unmask_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_interrupt_unmask_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_interrupt_unmask_IgnoreArg_ppu() ppu_v1_interrupt_unmask_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_interrupt_unmask_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_interrupt_unmask_IgnoreArg_mask() ppu_v1_interrupt_unmask_CMockIgnoreArg_mask(__LINE__) @@ -497,17 +497,17 @@ void ppu_v1_additional_interrupt_unmask_CMockStopIgnore(void); #define ppu_v1_additional_interrupt_unmask_ExpectAnyArgs() ppu_v1_additional_interrupt_unmask_CMockExpectAnyArgs(__LINE__) void ppu_v1_additional_interrupt_unmask_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); #define ppu_v1_additional_interrupt_unmask_Expect(ppu, mask) ppu_v1_additional_interrupt_unmask_CMockExpect(__LINE__, ppu, mask) -void ppu_v1_additional_interrupt_unmask_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, unsigned int mask); -typedef void (* CMOCK_ppu_v1_additional_interrupt_unmask_CALLBACK)(struct ppu_v1_reg* ppu, unsigned int mask, int cmock_num_calls); +void ppu_v1_additional_interrupt_unmask_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, unsigned int mask); +typedef void (* CMOCK_ppu_v1_additional_interrupt_unmask_CALLBACK)(struct ppu_v1_regs* ppu, unsigned int mask, int cmock_num_calls); void ppu_v1_additional_interrupt_unmask_AddCallback(CMOCK_ppu_v1_additional_interrupt_unmask_CALLBACK Callback); void ppu_v1_additional_interrupt_unmask_Stub(CMOCK_ppu_v1_additional_interrupt_unmask_CALLBACK Callback); #define ppu_v1_additional_interrupt_unmask_StubWithCallback ppu_v1_additional_interrupt_unmask_Stub #define ppu_v1_additional_interrupt_unmask_ExpectWithArray(ppu, ppu_Depth, mask) ppu_v1_additional_interrupt_unmask_CMockExpectWithArray(__LINE__, ppu, ppu_Depth, mask) -void ppu_v1_additional_interrupt_unmask_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask); -#define ppu_v1_additional_interrupt_unmask_ReturnThruPtr_ppu(ppu) ppu_v1_additional_interrupt_unmask_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_additional_interrupt_unmask_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask); +#define ppu_v1_additional_interrupt_unmask_ReturnThruPtr_ppu(ppu) ppu_v1_additional_interrupt_unmask_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_additional_interrupt_unmask_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_additional_interrupt_unmask_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_additional_interrupt_unmask_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_additional_interrupt_unmask_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_additional_interrupt_unmask_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_additional_interrupt_unmask_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_additional_interrupt_unmask_IgnoreArg_ppu() ppu_v1_additional_interrupt_unmask_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_additional_interrupt_unmask_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_additional_interrupt_unmask_IgnoreArg_mask() ppu_v1_additional_interrupt_unmask_CMockIgnoreArg_mask(__LINE__) @@ -519,17 +519,17 @@ void ppu_v1_is_additional_interrupt_pending_CMockStopIgnore(void); #define ppu_v1_is_additional_interrupt_pending_ExpectAnyArgsAndReturn(cmock_retval) ppu_v1_is_additional_interrupt_pending_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) void ppu_v1_is_additional_interrupt_pending_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return); #define ppu_v1_is_additional_interrupt_pending_ExpectAndReturn(ppu, mask, cmock_retval) ppu_v1_is_additional_interrupt_pending_CMockExpectAndReturn(__LINE__, ppu, mask, cmock_retval) -void ppu_v1_is_additional_interrupt_pending_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, unsigned int mask, bool cmock_to_return); -typedef bool (* CMOCK_ppu_v1_is_additional_interrupt_pending_CALLBACK)(struct ppu_v1_reg* ppu, unsigned int mask, int cmock_num_calls); +void ppu_v1_is_additional_interrupt_pending_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, unsigned int mask, bool cmock_to_return); +typedef bool (* CMOCK_ppu_v1_is_additional_interrupt_pending_CALLBACK)(struct ppu_v1_regs* ppu, unsigned int mask, int cmock_num_calls); void ppu_v1_is_additional_interrupt_pending_AddCallback(CMOCK_ppu_v1_is_additional_interrupt_pending_CALLBACK Callback); void ppu_v1_is_additional_interrupt_pending_Stub(CMOCK_ppu_v1_is_additional_interrupt_pending_CALLBACK Callback); #define ppu_v1_is_additional_interrupt_pending_StubWithCallback ppu_v1_is_additional_interrupt_pending_Stub #define ppu_v1_is_additional_interrupt_pending_ExpectWithArrayAndReturn(ppu, ppu_Depth, mask, cmock_retval) ppu_v1_is_additional_interrupt_pending_CMockExpectWithArrayAndReturn(__LINE__, ppu, ppu_Depth, mask, cmock_retval) -void ppu_v1_is_additional_interrupt_pending_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask, bool cmock_to_return); -#define ppu_v1_is_additional_interrupt_pending_ReturnThruPtr_ppu(ppu) ppu_v1_is_additional_interrupt_pending_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_is_additional_interrupt_pending_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask, bool cmock_to_return); +#define ppu_v1_is_additional_interrupt_pending_ReturnThruPtr_ppu(ppu) ppu_v1_is_additional_interrupt_pending_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_is_additional_interrupt_pending_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_is_additional_interrupt_pending_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_is_additional_interrupt_pending_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_is_additional_interrupt_pending_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_is_additional_interrupt_pending_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_is_additional_interrupt_pending_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_is_additional_interrupt_pending_IgnoreArg_ppu() ppu_v1_is_additional_interrupt_pending_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_is_additional_interrupt_pending_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_is_additional_interrupt_pending_IgnoreArg_mask() ppu_v1_is_additional_interrupt_pending_CMockIgnoreArg_mask(__LINE__) @@ -541,17 +541,17 @@ void ppu_v1_ack_interrupt_CMockStopIgnore(void); #define ppu_v1_ack_interrupt_ExpectAnyArgs() ppu_v1_ack_interrupt_CMockExpectAnyArgs(__LINE__) void ppu_v1_ack_interrupt_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); #define ppu_v1_ack_interrupt_Expect(ppu, mask) ppu_v1_ack_interrupt_CMockExpect(__LINE__, ppu, mask) -void ppu_v1_ack_interrupt_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, unsigned int mask); -typedef void (* CMOCK_ppu_v1_ack_interrupt_CALLBACK)(struct ppu_v1_reg* ppu, unsigned int mask, int cmock_num_calls); +void ppu_v1_ack_interrupt_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, unsigned int mask); +typedef void (* CMOCK_ppu_v1_ack_interrupt_CALLBACK)(struct ppu_v1_regs* ppu, unsigned int mask, int cmock_num_calls); void ppu_v1_ack_interrupt_AddCallback(CMOCK_ppu_v1_ack_interrupt_CALLBACK Callback); void ppu_v1_ack_interrupt_Stub(CMOCK_ppu_v1_ack_interrupt_CALLBACK Callback); #define ppu_v1_ack_interrupt_StubWithCallback ppu_v1_ack_interrupt_Stub #define ppu_v1_ack_interrupt_ExpectWithArray(ppu, ppu_Depth, mask) ppu_v1_ack_interrupt_CMockExpectWithArray(__LINE__, ppu, ppu_Depth, mask) -void ppu_v1_ack_interrupt_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask); -#define ppu_v1_ack_interrupt_ReturnThruPtr_ppu(ppu) ppu_v1_ack_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_ack_interrupt_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask); +#define ppu_v1_ack_interrupt_ReturnThruPtr_ppu(ppu) ppu_v1_ack_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_ack_interrupt_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_ack_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_ack_interrupt_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_ack_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_ack_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_ack_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_ack_interrupt_IgnoreArg_ppu() ppu_v1_ack_interrupt_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_ack_interrupt_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_ack_interrupt_IgnoreArg_mask() ppu_v1_ack_interrupt_CMockIgnoreArg_mask(__LINE__) @@ -563,17 +563,17 @@ void ppu_v1_ack_additional_interrupt_CMockStopIgnore(void); #define ppu_v1_ack_additional_interrupt_ExpectAnyArgs() ppu_v1_ack_additional_interrupt_CMockExpectAnyArgs(__LINE__) void ppu_v1_ack_additional_interrupt_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); #define ppu_v1_ack_additional_interrupt_Expect(ppu, mask) ppu_v1_ack_additional_interrupt_CMockExpect(__LINE__, ppu, mask) -void ppu_v1_ack_additional_interrupt_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, unsigned int mask); -typedef void (* CMOCK_ppu_v1_ack_additional_interrupt_CALLBACK)(struct ppu_v1_reg* ppu, unsigned int mask, int cmock_num_calls); +void ppu_v1_ack_additional_interrupt_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, unsigned int mask); +typedef void (* CMOCK_ppu_v1_ack_additional_interrupt_CALLBACK)(struct ppu_v1_regs* ppu, unsigned int mask, int cmock_num_calls); void ppu_v1_ack_additional_interrupt_AddCallback(CMOCK_ppu_v1_ack_additional_interrupt_CALLBACK Callback); void ppu_v1_ack_additional_interrupt_Stub(CMOCK_ppu_v1_ack_additional_interrupt_CALLBACK Callback); #define ppu_v1_ack_additional_interrupt_StubWithCallback ppu_v1_ack_additional_interrupt_Stub #define ppu_v1_ack_additional_interrupt_ExpectWithArray(ppu, ppu_Depth, mask) ppu_v1_ack_additional_interrupt_CMockExpectWithArray(__LINE__, ppu, ppu_Depth, mask) -void ppu_v1_ack_additional_interrupt_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int mask); -#define ppu_v1_ack_additional_interrupt_ReturnThruPtr_ppu(ppu) ppu_v1_ack_additional_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_ack_additional_interrupt_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int mask); +#define ppu_v1_ack_additional_interrupt_ReturnThruPtr_ppu(ppu) ppu_v1_ack_additional_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_ack_additional_interrupt_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_ack_additional_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_ack_additional_interrupt_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_ack_additional_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_ack_additional_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_ack_additional_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_ack_additional_interrupt_IgnoreArg_ppu() ppu_v1_ack_additional_interrupt_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_ack_additional_interrupt_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_ack_additional_interrupt_IgnoreArg_mask() ppu_v1_ack_additional_interrupt_CMockIgnoreArg_mask(__LINE__) @@ -585,17 +585,17 @@ void ppu_v1_set_input_edge_sensitivity_CMockStopIgnore(void); #define ppu_v1_set_input_edge_sensitivity_ExpectAnyArgs() ppu_v1_set_input_edge_sensitivity_CMockExpectAnyArgs(__LINE__) void ppu_v1_set_input_edge_sensitivity_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); #define ppu_v1_set_input_edge_sensitivity_Expect(ppu, ppu_mode, edge_sensitivity) ppu_v1_set_input_edge_sensitivity_CMockExpect(__LINE__, ppu, ppu_mode, edge_sensitivity) -void ppu_v1_set_input_edge_sensitivity_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity edge_sensitivity); -typedef void (* CMOCK_ppu_v1_set_input_edge_sensitivity_CALLBACK)(struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity edge_sensitivity, int cmock_num_calls); +void ppu_v1_set_input_edge_sensitivity_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity edge_sensitivity); +typedef void (* CMOCK_ppu_v1_set_input_edge_sensitivity_CALLBACK)(struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity edge_sensitivity, int cmock_num_calls); void ppu_v1_set_input_edge_sensitivity_AddCallback(CMOCK_ppu_v1_set_input_edge_sensitivity_CALLBACK Callback); void ppu_v1_set_input_edge_sensitivity_Stub(CMOCK_ppu_v1_set_input_edge_sensitivity_CALLBACK Callback); #define ppu_v1_set_input_edge_sensitivity_StubWithCallback ppu_v1_set_input_edge_sensitivity_Stub #define ppu_v1_set_input_edge_sensitivity_ExpectWithArray(ppu, ppu_Depth, ppu_mode, edge_sensitivity) ppu_v1_set_input_edge_sensitivity_CMockExpectWithArray(__LINE__, ppu, ppu_Depth, ppu_mode, edge_sensitivity) -void ppu_v1_set_input_edge_sensitivity_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity edge_sensitivity); -#define ppu_v1_set_input_edge_sensitivity_ReturnThruPtr_ppu(ppu) ppu_v1_set_input_edge_sensitivity_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_set_input_edge_sensitivity_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity edge_sensitivity); +#define ppu_v1_set_input_edge_sensitivity_ReturnThruPtr_ppu(ppu) ppu_v1_set_input_edge_sensitivity_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_set_input_edge_sensitivity_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_set_input_edge_sensitivity_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_set_input_edge_sensitivity_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_set_input_edge_sensitivity_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_set_input_edge_sensitivity_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_set_input_edge_sensitivity_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_set_input_edge_sensitivity_IgnoreArg_ppu() ppu_v1_set_input_edge_sensitivity_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_set_input_edge_sensitivity_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_set_input_edge_sensitivity_IgnoreArg_ppu_mode() ppu_v1_set_input_edge_sensitivity_CMockIgnoreArg_ppu_mode(__LINE__) @@ -609,17 +609,17 @@ void ppu_v1_get_input_edge_sensitivity_CMockStopIgnore(void); #define ppu_v1_get_input_edge_sensitivity_ExpectAnyArgsAndReturn(cmock_retval) ppu_v1_get_input_edge_sensitivity_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) void ppu_v1_get_input_edge_sensitivity_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, enum ppu_v1_edge_sensitivity cmock_to_return); #define ppu_v1_get_input_edge_sensitivity_ExpectAndReturn(ppu, ppu_mode, cmock_retval) ppu_v1_get_input_edge_sensitivity_CMockExpectAndReturn(__LINE__, ppu, ppu_mode, cmock_retval) -void ppu_v1_get_input_edge_sensitivity_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity cmock_to_return); -typedef enum ppu_v1_edge_sensitivity (* CMOCK_ppu_v1_get_input_edge_sensitivity_CALLBACK)(struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, int cmock_num_calls); +void ppu_v1_get_input_edge_sensitivity_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity cmock_to_return); +typedef enum ppu_v1_edge_sensitivity (* CMOCK_ppu_v1_get_input_edge_sensitivity_CALLBACK)(struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode, int cmock_num_calls); void ppu_v1_get_input_edge_sensitivity_AddCallback(CMOCK_ppu_v1_get_input_edge_sensitivity_CALLBACK Callback); void ppu_v1_get_input_edge_sensitivity_Stub(CMOCK_ppu_v1_get_input_edge_sensitivity_CALLBACK Callback); #define ppu_v1_get_input_edge_sensitivity_StubWithCallback ppu_v1_get_input_edge_sensitivity_Stub #define ppu_v1_get_input_edge_sensitivity_ExpectWithArrayAndReturn(ppu, ppu_Depth, ppu_mode, cmock_retval) ppu_v1_get_input_edge_sensitivity_CMockExpectWithArrayAndReturn(__LINE__, ppu, ppu_Depth, ppu_mode, cmock_retval) -void ppu_v1_get_input_edge_sensitivity_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity cmock_to_return); -#define ppu_v1_get_input_edge_sensitivity_ReturnThruPtr_ppu(ppu) ppu_v1_get_input_edge_sensitivity_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_get_input_edge_sensitivity_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity cmock_to_return); +#define ppu_v1_get_input_edge_sensitivity_ReturnThruPtr_ppu(ppu) ppu_v1_get_input_edge_sensitivity_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_get_input_edge_sensitivity_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_get_input_edge_sensitivity_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_get_input_edge_sensitivity_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_get_input_edge_sensitivity_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_get_input_edge_sensitivity_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_get_input_edge_sensitivity_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_get_input_edge_sensitivity_IgnoreArg_ppu() ppu_v1_get_input_edge_sensitivity_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_get_input_edge_sensitivity_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_get_input_edge_sensitivity_IgnoreArg_ppu_mode() ppu_v1_get_input_edge_sensitivity_CMockIgnoreArg_ppu_mode(__LINE__) @@ -631,17 +631,17 @@ void ppu_v1_ack_power_active_edge_interrupt_CMockStopIgnore(void); #define ppu_v1_ack_power_active_edge_interrupt_ExpectAnyArgs() ppu_v1_ack_power_active_edge_interrupt_CMockExpectAnyArgs(__LINE__) void ppu_v1_ack_power_active_edge_interrupt_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); #define ppu_v1_ack_power_active_edge_interrupt_Expect(ppu, ppu_mode) ppu_v1_ack_power_active_edge_interrupt_CMockExpect(__LINE__, ppu, ppu_mode) -void ppu_v1_ack_power_active_edge_interrupt_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode); -typedef void (* CMOCK_ppu_v1_ack_power_active_edge_interrupt_CALLBACK)(struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, int cmock_num_calls); +void ppu_v1_ack_power_active_edge_interrupt_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode); +typedef void (* CMOCK_ppu_v1_ack_power_active_edge_interrupt_CALLBACK)(struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode, int cmock_num_calls); void ppu_v1_ack_power_active_edge_interrupt_AddCallback(CMOCK_ppu_v1_ack_power_active_edge_interrupt_CALLBACK Callback); void ppu_v1_ack_power_active_edge_interrupt_Stub(CMOCK_ppu_v1_ack_power_active_edge_interrupt_CALLBACK Callback); #define ppu_v1_ack_power_active_edge_interrupt_StubWithCallback ppu_v1_ack_power_active_edge_interrupt_Stub #define ppu_v1_ack_power_active_edge_interrupt_ExpectWithArray(ppu, ppu_Depth, ppu_mode) ppu_v1_ack_power_active_edge_interrupt_CMockExpectWithArray(__LINE__, ppu, ppu_Depth, ppu_mode) -void ppu_v1_ack_power_active_edge_interrupt_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode); -#define ppu_v1_ack_power_active_edge_interrupt_ReturnThruPtr_ppu(ppu) ppu_v1_ack_power_active_edge_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_ack_power_active_edge_interrupt_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode); +#define ppu_v1_ack_power_active_edge_interrupt_ReturnThruPtr_ppu(ppu) ppu_v1_ack_power_active_edge_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_ack_power_active_edge_interrupt_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_ack_power_active_edge_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_ack_power_active_edge_interrupt_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_ack_power_active_edge_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_ack_power_active_edge_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_ack_power_active_edge_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_ack_power_active_edge_interrupt_IgnoreArg_ppu() ppu_v1_ack_power_active_edge_interrupt_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_ack_power_active_edge_interrupt_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_ack_power_active_edge_interrupt_IgnoreArg_ppu_mode() ppu_v1_ack_power_active_edge_interrupt_CMockIgnoreArg_ppu_mode(__LINE__) @@ -653,17 +653,17 @@ void ppu_v1_is_power_active_edge_interrupt_CMockStopIgnore(void); #define ppu_v1_is_power_active_edge_interrupt_ExpectAnyArgsAndReturn(cmock_retval) ppu_v1_is_power_active_edge_interrupt_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) void ppu_v1_is_power_active_edge_interrupt_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return); #define ppu_v1_is_power_active_edge_interrupt_ExpectAndReturn(ppu, ppu_mode, cmock_retval) ppu_v1_is_power_active_edge_interrupt_CMockExpectAndReturn(__LINE__, ppu, ppu_mode, cmock_retval) -void ppu_v1_is_power_active_edge_interrupt_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, bool cmock_to_return); -typedef bool (* CMOCK_ppu_v1_is_power_active_edge_interrupt_CALLBACK)(struct ppu_v1_reg* ppu, enum ppu_v1_mode ppu_mode, int cmock_num_calls); +void ppu_v1_is_power_active_edge_interrupt_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode, bool cmock_to_return); +typedef bool (* CMOCK_ppu_v1_is_power_active_edge_interrupt_CALLBACK)(struct ppu_v1_regs* ppu, enum ppu_v1_mode ppu_mode, int cmock_num_calls); void ppu_v1_is_power_active_edge_interrupt_AddCallback(CMOCK_ppu_v1_is_power_active_edge_interrupt_CALLBACK Callback); void ppu_v1_is_power_active_edge_interrupt_Stub(CMOCK_ppu_v1_is_power_active_edge_interrupt_CALLBACK Callback); #define ppu_v1_is_power_active_edge_interrupt_StubWithCallback ppu_v1_is_power_active_edge_interrupt_Stub #define ppu_v1_is_power_active_edge_interrupt_ExpectWithArrayAndReturn(ppu, ppu_Depth, ppu_mode, cmock_retval) ppu_v1_is_power_active_edge_interrupt_CMockExpectWithArrayAndReturn(__LINE__, ppu, ppu_Depth, ppu_mode, cmock_retval) -void ppu_v1_is_power_active_edge_interrupt_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, bool cmock_to_return); -#define ppu_v1_is_power_active_edge_interrupt_ReturnThruPtr_ppu(ppu) ppu_v1_is_power_active_edge_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_is_power_active_edge_interrupt_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_mode ppu_mode, bool cmock_to_return); +#define ppu_v1_is_power_active_edge_interrupt_ReturnThruPtr_ppu(ppu) ppu_v1_is_power_active_edge_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_is_power_active_edge_interrupt_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_is_power_active_edge_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_is_power_active_edge_interrupt_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_is_power_active_edge_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_is_power_active_edge_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_is_power_active_edge_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_is_power_active_edge_interrupt_IgnoreArg_ppu() ppu_v1_is_power_active_edge_interrupt_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_is_power_active_edge_interrupt_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_is_power_active_edge_interrupt_IgnoreArg_ppu_mode() ppu_v1_is_power_active_edge_interrupt_CMockIgnoreArg_ppu_mode(__LINE__) @@ -675,17 +675,17 @@ void ppu_v1_set_op_active_edge_sensitivity_CMockStopIgnore(void); #define ppu_v1_set_op_active_edge_sensitivity_ExpectAnyArgs() ppu_v1_set_op_active_edge_sensitivity_CMockExpectAnyArgs(__LINE__) void ppu_v1_set_op_active_edge_sensitivity_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); #define ppu_v1_set_op_active_edge_sensitivity_Expect(ppu, op_devactive, edge_sensitivity) ppu_v1_set_op_active_edge_sensitivity_CMockExpect(__LINE__, ppu, op_devactive, edge_sensitivity) -void ppu_v1_set_op_active_edge_sensitivity_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity edge_sensitivity); -typedef void (* CMOCK_ppu_v1_set_op_active_edge_sensitivity_CALLBACK)(struct ppu_v1_reg* ppu, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity edge_sensitivity, int cmock_num_calls); +void ppu_v1_set_op_active_edge_sensitivity_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity edge_sensitivity); +typedef void (* CMOCK_ppu_v1_set_op_active_edge_sensitivity_CALLBACK)(struct ppu_v1_regs* ppu, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity edge_sensitivity, int cmock_num_calls); void ppu_v1_set_op_active_edge_sensitivity_AddCallback(CMOCK_ppu_v1_set_op_active_edge_sensitivity_CALLBACK Callback); void ppu_v1_set_op_active_edge_sensitivity_Stub(CMOCK_ppu_v1_set_op_active_edge_sensitivity_CALLBACK Callback); #define ppu_v1_set_op_active_edge_sensitivity_StubWithCallback ppu_v1_set_op_active_edge_sensitivity_Stub #define ppu_v1_set_op_active_edge_sensitivity_ExpectWithArray(ppu, ppu_Depth, op_devactive, edge_sensitivity) ppu_v1_set_op_active_edge_sensitivity_CMockExpectWithArray(__LINE__, ppu, ppu_Depth, op_devactive, edge_sensitivity) -void ppu_v1_set_op_active_edge_sensitivity_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity edge_sensitivity); -#define ppu_v1_set_op_active_edge_sensitivity_ReturnThruPtr_ppu(ppu) ppu_v1_set_op_active_edge_sensitivity_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_set_op_active_edge_sensitivity_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity edge_sensitivity); +#define ppu_v1_set_op_active_edge_sensitivity_ReturnThruPtr_ppu(ppu) ppu_v1_set_op_active_edge_sensitivity_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_set_op_active_edge_sensitivity_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_set_op_active_edge_sensitivity_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_set_op_active_edge_sensitivity_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_set_op_active_edge_sensitivity_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_set_op_active_edge_sensitivity_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_set_op_active_edge_sensitivity_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_set_op_active_edge_sensitivity_IgnoreArg_ppu() ppu_v1_set_op_active_edge_sensitivity_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_set_op_active_edge_sensitivity_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_set_op_active_edge_sensitivity_IgnoreArg_op_devactive() ppu_v1_set_op_active_edge_sensitivity_CMockIgnoreArg_op_devactive(__LINE__) @@ -699,17 +699,17 @@ void ppu_v1_get_op_active_edge_sensitivity_CMockStopIgnore(void); #define ppu_v1_get_op_active_edge_sensitivity_ExpectAnyArgsAndReturn(cmock_retval) ppu_v1_get_op_active_edge_sensitivity_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) void ppu_v1_get_op_active_edge_sensitivity_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, enum ppu_v1_edge_sensitivity cmock_to_return); #define ppu_v1_get_op_active_edge_sensitivity_ExpectAndReturn(ppu, op_devactive, cmock_retval) ppu_v1_get_op_active_edge_sensitivity_CMockExpectAndReturn(__LINE__, ppu, op_devactive, cmock_retval) -void ppu_v1_get_op_active_edge_sensitivity_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity cmock_to_return); -typedef enum ppu_v1_edge_sensitivity (* CMOCK_ppu_v1_get_op_active_edge_sensitivity_CALLBACK)(struct ppu_v1_reg* ppu, enum ppu_v1_op_devactive op_devactive, int cmock_num_calls); +void ppu_v1_get_op_active_edge_sensitivity_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity cmock_to_return); +typedef enum ppu_v1_edge_sensitivity (* CMOCK_ppu_v1_get_op_active_edge_sensitivity_CALLBACK)(struct ppu_v1_regs* ppu, enum ppu_v1_op_devactive op_devactive, int cmock_num_calls); void ppu_v1_get_op_active_edge_sensitivity_AddCallback(CMOCK_ppu_v1_get_op_active_edge_sensitivity_CALLBACK Callback); void ppu_v1_get_op_active_edge_sensitivity_Stub(CMOCK_ppu_v1_get_op_active_edge_sensitivity_CALLBACK Callback); #define ppu_v1_get_op_active_edge_sensitivity_StubWithCallback ppu_v1_get_op_active_edge_sensitivity_Stub #define ppu_v1_get_op_active_edge_sensitivity_ExpectWithArrayAndReturn(ppu, ppu_Depth, op_devactive, cmock_retval) ppu_v1_get_op_active_edge_sensitivity_CMockExpectWithArrayAndReturn(__LINE__, ppu, ppu_Depth, op_devactive, cmock_retval) -void ppu_v1_get_op_active_edge_sensitivity_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity cmock_to_return); -#define ppu_v1_get_op_active_edge_sensitivity_ReturnThruPtr_ppu(ppu) ppu_v1_get_op_active_edge_sensitivity_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_get_op_active_edge_sensitivity_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity cmock_to_return); +#define ppu_v1_get_op_active_edge_sensitivity_ReturnThruPtr_ppu(ppu) ppu_v1_get_op_active_edge_sensitivity_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_get_op_active_edge_sensitivity_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_get_op_active_edge_sensitivity_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_get_op_active_edge_sensitivity_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_get_op_active_edge_sensitivity_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_get_op_active_edge_sensitivity_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_get_op_active_edge_sensitivity_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_get_op_active_edge_sensitivity_IgnoreArg_ppu() ppu_v1_get_op_active_edge_sensitivity_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_get_op_active_edge_sensitivity_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_get_op_active_edge_sensitivity_IgnoreArg_op_devactive() ppu_v1_get_op_active_edge_sensitivity_CMockIgnoreArg_op_devactive(__LINE__) @@ -721,17 +721,17 @@ void ppu_v1_ack_op_active_edge_interrupt_CMockStopIgnore(void); #define ppu_v1_ack_op_active_edge_interrupt_ExpectAnyArgs() ppu_v1_ack_op_active_edge_interrupt_CMockExpectAnyArgs(__LINE__) void ppu_v1_ack_op_active_edge_interrupt_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); #define ppu_v1_ack_op_active_edge_interrupt_Expect(ppu, op_devactive) ppu_v1_ack_op_active_edge_interrupt_CMockExpect(__LINE__, ppu, op_devactive) -void ppu_v1_ack_op_active_edge_interrupt_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_op_devactive op_devactive); -typedef void (* CMOCK_ppu_v1_ack_op_active_edge_interrupt_CALLBACK)(struct ppu_v1_reg* ppu, enum ppu_v1_op_devactive op_devactive, int cmock_num_calls); +void ppu_v1_ack_op_active_edge_interrupt_CMockExpect(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_op_devactive op_devactive); +typedef void (* CMOCK_ppu_v1_ack_op_active_edge_interrupt_CALLBACK)(struct ppu_v1_regs* ppu, enum ppu_v1_op_devactive op_devactive, int cmock_num_calls); void ppu_v1_ack_op_active_edge_interrupt_AddCallback(CMOCK_ppu_v1_ack_op_active_edge_interrupt_CALLBACK Callback); void ppu_v1_ack_op_active_edge_interrupt_Stub(CMOCK_ppu_v1_ack_op_active_edge_interrupt_CALLBACK Callback); #define ppu_v1_ack_op_active_edge_interrupt_StubWithCallback ppu_v1_ack_op_active_edge_interrupt_Stub #define ppu_v1_ack_op_active_edge_interrupt_ExpectWithArray(ppu, ppu_Depth, op_devactive) ppu_v1_ack_op_active_edge_interrupt_CMockExpectWithArray(__LINE__, ppu, ppu_Depth, op_devactive) -void ppu_v1_ack_op_active_edge_interrupt_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive); -#define ppu_v1_ack_op_active_edge_interrupt_ReturnThruPtr_ppu(ppu) ppu_v1_ack_op_active_edge_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_ack_op_active_edge_interrupt_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive); +#define ppu_v1_ack_op_active_edge_interrupt_ReturnThruPtr_ppu(ppu) ppu_v1_ack_op_active_edge_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_ack_op_active_edge_interrupt_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_ack_op_active_edge_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_ack_op_active_edge_interrupt_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_ack_op_active_edge_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_ack_op_active_edge_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_ack_op_active_edge_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_ack_op_active_edge_interrupt_IgnoreArg_ppu() ppu_v1_ack_op_active_edge_interrupt_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_ack_op_active_edge_interrupt_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_ack_op_active_edge_interrupt_IgnoreArg_op_devactive() ppu_v1_ack_op_active_edge_interrupt_CMockIgnoreArg_op_devactive(__LINE__) @@ -743,17 +743,17 @@ void ppu_v1_is_op_active_edge_interrupt_CMockStopIgnore(void); #define ppu_v1_is_op_active_edge_interrupt_ExpectAnyArgsAndReturn(cmock_retval) ppu_v1_is_op_active_edge_interrupt_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) void ppu_v1_is_op_active_edge_interrupt_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return); #define ppu_v1_is_op_active_edge_interrupt_ExpectAndReturn(ppu, op_devactive, cmock_retval) ppu_v1_is_op_active_edge_interrupt_CMockExpectAndReturn(__LINE__, ppu, op_devactive, cmock_retval) -void ppu_v1_is_op_active_edge_interrupt_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, enum ppu_v1_op_devactive op_devactive, bool cmock_to_return); -typedef bool (* CMOCK_ppu_v1_is_op_active_edge_interrupt_CALLBACK)(struct ppu_v1_reg* ppu, enum ppu_v1_op_devactive op_devactive, int cmock_num_calls); +void ppu_v1_is_op_active_edge_interrupt_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, enum ppu_v1_op_devactive op_devactive, bool cmock_to_return); +typedef bool (* CMOCK_ppu_v1_is_op_active_edge_interrupt_CALLBACK)(struct ppu_v1_regs* ppu, enum ppu_v1_op_devactive op_devactive, int cmock_num_calls); void ppu_v1_is_op_active_edge_interrupt_AddCallback(CMOCK_ppu_v1_is_op_active_edge_interrupt_CALLBACK Callback); void ppu_v1_is_op_active_edge_interrupt_Stub(CMOCK_ppu_v1_is_op_active_edge_interrupt_CALLBACK Callback); #define ppu_v1_is_op_active_edge_interrupt_StubWithCallback ppu_v1_is_op_active_edge_interrupt_Stub #define ppu_v1_is_op_active_edge_interrupt_ExpectWithArrayAndReturn(ppu, ppu_Depth, op_devactive, cmock_retval) ppu_v1_is_op_active_edge_interrupt_CMockExpectWithArrayAndReturn(__LINE__, ppu, ppu_Depth, op_devactive, cmock_retval) -void ppu_v1_is_op_active_edge_interrupt_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive, bool cmock_to_return); -#define ppu_v1_is_op_active_edge_interrupt_ReturnThruPtr_ppu(ppu) ppu_v1_is_op_active_edge_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_is_op_active_edge_interrupt_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, enum ppu_v1_op_devactive op_devactive, bool cmock_to_return); +#define ppu_v1_is_op_active_edge_interrupt_ReturnThruPtr_ppu(ppu) ppu_v1_is_op_active_edge_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_is_op_active_edge_interrupt_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_is_op_active_edge_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_is_op_active_edge_interrupt_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_is_op_active_edge_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_is_op_active_edge_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_is_op_active_edge_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_is_op_active_edge_interrupt_IgnoreArg_ppu() ppu_v1_is_op_active_edge_interrupt_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_is_op_active_edge_interrupt_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_is_op_active_edge_interrupt_IgnoreArg_op_devactive() ppu_v1_is_op_active_edge_interrupt_CMockIgnoreArg_op_devactive(__LINE__) @@ -765,17 +765,17 @@ void ppu_v1_is_dyn_policy_min_interrupt_CMockStopIgnore(void); #define ppu_v1_is_dyn_policy_min_interrupt_ExpectAnyArgsAndReturn(cmock_retval) ppu_v1_is_dyn_policy_min_interrupt_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) void ppu_v1_is_dyn_policy_min_interrupt_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return); #define ppu_v1_is_dyn_policy_min_interrupt_ExpectAndReturn(ppu, cmock_retval) ppu_v1_is_dyn_policy_min_interrupt_CMockExpectAndReturn(__LINE__, ppu, cmock_retval) -void ppu_v1_is_dyn_policy_min_interrupt_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, bool cmock_to_return); -typedef bool (* CMOCK_ppu_v1_is_dyn_policy_min_interrupt_CALLBACK)(struct ppu_v1_reg* ppu, int cmock_num_calls); +void ppu_v1_is_dyn_policy_min_interrupt_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, bool cmock_to_return); +typedef bool (* CMOCK_ppu_v1_is_dyn_policy_min_interrupt_CALLBACK)(struct ppu_v1_regs* ppu, int cmock_num_calls); void ppu_v1_is_dyn_policy_min_interrupt_AddCallback(CMOCK_ppu_v1_is_dyn_policy_min_interrupt_CALLBACK Callback); void ppu_v1_is_dyn_policy_min_interrupt_Stub(CMOCK_ppu_v1_is_dyn_policy_min_interrupt_CALLBACK Callback); #define ppu_v1_is_dyn_policy_min_interrupt_StubWithCallback ppu_v1_is_dyn_policy_min_interrupt_Stub #define ppu_v1_is_dyn_policy_min_interrupt_ExpectWithArrayAndReturn(ppu, ppu_Depth, cmock_retval) ppu_v1_is_dyn_policy_min_interrupt_CMockExpectWithArrayAndReturn(__LINE__, ppu, ppu_Depth, cmock_retval) -void ppu_v1_is_dyn_policy_min_interrupt_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, bool cmock_to_return); -#define ppu_v1_is_dyn_policy_min_interrupt_ReturnThruPtr_ppu(ppu) ppu_v1_is_dyn_policy_min_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_is_dyn_policy_min_interrupt_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, bool cmock_to_return); +#define ppu_v1_is_dyn_policy_min_interrupt_ReturnThruPtr_ppu(ppu) ppu_v1_is_dyn_policy_min_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_is_dyn_policy_min_interrupt_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_is_dyn_policy_min_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_is_dyn_policy_min_interrupt_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_is_dyn_policy_min_interrupt_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_is_dyn_policy_min_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_is_dyn_policy_min_interrupt_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_is_dyn_policy_min_interrupt_IgnoreArg_ppu() ppu_v1_is_dyn_policy_min_interrupt_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_is_dyn_policy_min_interrupt_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_get_num_opmode_IgnoreAndReturn(cmock_retval) ppu_v1_get_num_opmode_CMockIgnoreAndReturn(__LINE__, cmock_retval) @@ -785,17 +785,17 @@ void ppu_v1_get_num_opmode_CMockStopIgnore(void); #define ppu_v1_get_num_opmode_ExpectAnyArgsAndReturn(cmock_retval) ppu_v1_get_num_opmode_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) void ppu_v1_get_num_opmode_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, unsigned int cmock_to_return); #define ppu_v1_get_num_opmode_ExpectAndReturn(ppu, cmock_retval) ppu_v1_get_num_opmode_CMockExpectAndReturn(__LINE__, ppu, cmock_retval) -void ppu_v1_get_num_opmode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, unsigned int cmock_to_return); -typedef unsigned int (* CMOCK_ppu_v1_get_num_opmode_CALLBACK)(struct ppu_v1_reg* ppu, int cmock_num_calls); +void ppu_v1_get_num_opmode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, unsigned int cmock_to_return); +typedef unsigned int (* CMOCK_ppu_v1_get_num_opmode_CALLBACK)(struct ppu_v1_regs* ppu, int cmock_num_calls); void ppu_v1_get_num_opmode_AddCallback(CMOCK_ppu_v1_get_num_opmode_CALLBACK Callback); void ppu_v1_get_num_opmode_Stub(CMOCK_ppu_v1_get_num_opmode_CALLBACK Callback); #define ppu_v1_get_num_opmode_StubWithCallback ppu_v1_get_num_opmode_Stub #define ppu_v1_get_num_opmode_ExpectWithArrayAndReturn(ppu, ppu_Depth, cmock_retval) ppu_v1_get_num_opmode_CMockExpectWithArrayAndReturn(__LINE__, ppu, ppu_Depth, cmock_retval) -void ppu_v1_get_num_opmode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int cmock_to_return); -#define ppu_v1_get_num_opmode_ReturnThruPtr_ppu(ppu) ppu_v1_get_num_opmode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_get_num_opmode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int cmock_to_return); +#define ppu_v1_get_num_opmode_ReturnThruPtr_ppu(ppu) ppu_v1_get_num_opmode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_get_num_opmode_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_get_num_opmode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_get_num_opmode_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_get_num_opmode_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_get_num_opmode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_get_num_opmode_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_get_num_opmode_IgnoreArg_ppu() ppu_v1_get_num_opmode_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_get_num_opmode_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); #define ppu_v1_get_arch_id_IgnoreAndReturn(cmock_retval) ppu_v1_get_arch_id_CMockIgnoreAndReturn(__LINE__, cmock_retval) @@ -805,17 +805,17 @@ void ppu_v1_get_arch_id_CMockStopIgnore(void); #define ppu_v1_get_arch_id_ExpectAnyArgsAndReturn(cmock_retval) ppu_v1_get_arch_id_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) void ppu_v1_get_arch_id_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, unsigned int cmock_to_return); #define ppu_v1_get_arch_id_ExpectAndReturn(ppu, cmock_retval) ppu_v1_get_arch_id_CMockExpectAndReturn(__LINE__, ppu, cmock_retval) -void ppu_v1_get_arch_id_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, unsigned int cmock_to_return); -typedef unsigned int (* CMOCK_ppu_v1_get_arch_id_CALLBACK)(struct ppu_v1_reg* ppu, int cmock_num_calls); +void ppu_v1_get_arch_id_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, unsigned int cmock_to_return); +typedef unsigned int (* CMOCK_ppu_v1_get_arch_id_CALLBACK)(struct ppu_v1_regs* ppu, int cmock_num_calls); void ppu_v1_get_arch_id_AddCallback(CMOCK_ppu_v1_get_arch_id_CALLBACK Callback); void ppu_v1_get_arch_id_Stub(CMOCK_ppu_v1_get_arch_id_CALLBACK Callback); #define ppu_v1_get_arch_id_StubWithCallback ppu_v1_get_arch_id_Stub #define ppu_v1_get_arch_id_ExpectWithArrayAndReturn(ppu, ppu_Depth, cmock_retval) ppu_v1_get_arch_id_CMockExpectWithArrayAndReturn(__LINE__, ppu, ppu_Depth, cmock_retval) -void ppu_v1_get_arch_id_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, int ppu_Depth, unsigned int cmock_to_return); -#define ppu_v1_get_arch_id_ReturnThruPtr_ppu(ppu) ppu_v1_get_arch_id_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_reg)) +void ppu_v1_get_arch_id_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, int ppu_Depth, unsigned int cmock_to_return); +#define ppu_v1_get_arch_id_ReturnThruPtr_ppu(ppu) ppu_v1_get_arch_id_CMockReturnMemThruPtr_ppu(__LINE__, ppu, sizeof(struct ppu_v1_regs)) #define ppu_v1_get_arch_id_ReturnArrayThruPtr_ppu(ppu, cmock_len) ppu_v1_get_arch_id_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_len * sizeof(*ppu)) #define ppu_v1_get_arch_id_ReturnMemThruPtr_ppu(ppu, cmock_size) ppu_v1_get_arch_id_CMockReturnMemThruPtr_ppu(__LINE__, ppu, cmock_size) -void ppu_v1_get_arch_id_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_reg* ppu, size_t cmock_size); +void ppu_v1_get_arch_id_CMockReturnMemThruPtr_ppu(UNITY_LINE_TYPE cmock_line, struct ppu_v1_regs* ppu, size_t cmock_size); #define ppu_v1_get_arch_id_IgnoreArg_ppu() ppu_v1_get_arch_id_CMockIgnoreArg_ppu(__LINE__) void ppu_v1_get_arch_id_CMockIgnoreArg_ppu(UNITY_LINE_TYPE cmock_line); diff --git a/module/ppu_v1/test/mod_ppu_v1_extra.h b/module/ppu_v1/test/mod_ppu_v1_extra.h index 0b48e8d13..983fc5122 100644 --- a/module/ppu_v1/test/mod_ppu_v1_extra.h +++ b/module/ppu_v1/test/mod_ppu_v1_extra.h @@ -20,115 +20,118 @@ int start_alarm_api( int stop_alarm_api(fwk_id_t alarm_id); /* From ppu_v1.h*/ -void ppu_v1_init(struct ppu_v1_reg *ppu); +void ppu_v1_init(struct ppu_v1_regs *ppu); int ppu_v1_set_power_mode( - struct ppu_v1_reg *ppu, + struct ppu_v1_regs *ppu, enum ppu_v1_mode ppu_mode, struct ppu_v1_timer_ctx *timer_ctx); int ppu_v1_request_power_mode( - struct ppu_v1_reg *ppu, + struct ppu_v1_regs *ppu, enum ppu_v1_mode ppu_mode); int ppu_v1_request_operating_mode( - struct ppu_v1_reg *ppu, + struct ppu_v1_regs *ppu, enum ppu_v1_opmode op_mode); void ppu_v1_opmode_dynamic_enable( - struct ppu_v1_reg *ppu, + struct ppu_v1_regs *ppu, enum ppu_v1_opmode min_dyn_mode); void ppu_v1_dynamic_enable( - struct ppu_v1_reg *ppu, + struct ppu_v1_regs *ppu, enum ppu_v1_mode min_dyn_state); -void ppu_v1_lock_off_enable(struct ppu_v1_reg *ppu); +void ppu_v1_lock_off_enable(struct ppu_v1_regs *ppu); -void ppu_v1_lock_off_disable(struct ppu_v1_reg *ppu); +void ppu_v1_lock_off_disable(struct ppu_v1_regs *ppu); -enum ppu_v1_mode ppu_v1_get_power_mode(struct ppu_v1_reg *ppu); +enum ppu_v1_mode ppu_v1_get_power_mode(struct ppu_v1_regs *ppu); -enum ppu_v1_mode ppu_v1_get_programmed_power_mode(struct ppu_v1_reg *ppu); +enum ppu_v1_mode ppu_v1_get_programmed_power_mode(struct ppu_v1_regs *ppu); -enum ppu_v1_opmode ppu_v1_get_operating_mode(struct ppu_v1_reg *ppu); +enum ppu_v1_opmode ppu_v1_get_operating_mode(struct ppu_v1_regs *ppu); -enum ppu_v1_opmode ppu_v1_get_programmed_operating_mode(struct ppu_v1_reg *ppu); +enum ppu_v1_opmode ppu_v1_get_programmed_operating_mode( + struct ppu_v1_regs *ppu); -bool ppu_v1_is_dynamic_enabled(struct ppu_v1_reg *ppu); +bool ppu_v1_is_dynamic_enabled(struct ppu_v1_regs *ppu); -bool ppu_v1_is_locked(struct ppu_v1_reg *ppu); +bool ppu_v1_is_locked(struct ppu_v1_regs *ppu); bool ppu_v1_is_power_devactive_high( - struct ppu_v1_reg *ppu, + struct ppu_v1_regs *ppu, enum ppu_v1_mode ppu_mode); bool ppu_v1_is_op_devactive_high( - struct ppu_v1_reg *ppu, + struct ppu_v1_regs *ppu, enum ppu_v1_op_devactive op_devactive); -void ppu_v1_off_unlock(struct ppu_v1_reg *ppu); +void ppu_v1_off_unlock(struct ppu_v1_regs *ppu); -void ppu_v1_disable_devactive(struct ppu_v1_reg *ppu); +void ppu_v1_disable_devactive(struct ppu_v1_regs *ppu); -void ppu_v1_disable_handshake(struct ppu_v1_reg *ppu); +void ppu_v1_disable_handshake(struct ppu_v1_regs *ppu); -void ppu_v1_interrupt_mask(struct ppu_v1_reg *ppu, unsigned int mask); +void ppu_v1_interrupt_mask(struct ppu_v1_regs *ppu, unsigned int mask); void ppu_v1_additional_interrupt_mask( - struct ppu_v1_reg *ppu, + struct ppu_v1_regs *ppu, unsigned int mask); -void ppu_v1_interrupt_unmask(struct ppu_v1_reg *ppu, unsigned int mask); +void ppu_v1_interrupt_unmask(struct ppu_v1_regs *ppu, unsigned int mask); void ppu_v1_additional_interrupt_unmask( - struct ppu_v1_reg *ppu, + struct ppu_v1_regs *ppu, unsigned int mask); bool ppu_v1_is_additional_interrupt_pending( - struct ppu_v1_reg *ppu, + struct ppu_v1_regs *ppu, unsigned int mask); -void ppu_v1_ack_interrupt(struct ppu_v1_reg *ppu, unsigned int mask); +void ppu_v1_ack_interrupt(struct ppu_v1_regs *ppu, unsigned int mask); -void ppu_v1_ack_additional_interrupt(struct ppu_v1_reg *ppu, unsigned int mask); +void ppu_v1_ack_additional_interrupt( + struct ppu_v1_regs *ppu, + unsigned int mask); void ppu_v1_set_input_edge_sensitivity( - struct ppu_v1_reg *ppu, + struct ppu_v1_regs *ppu, enum ppu_v1_mode ppu_mode, enum ppu_v1_edge_sensitivity edge_sensitivity); enum ppu_v1_edge_sensitivity ppu_v1_get_input_edge_sensitivity( - struct ppu_v1_reg *ppu, + struct ppu_v1_regs *ppu, enum ppu_v1_mode ppu_mode); void ppu_v1_ack_power_active_edge_interrupt( - struct ppu_v1_reg *ppu, + struct ppu_v1_regs *ppu, enum ppu_v1_mode ppu_mode); bool ppu_v1_is_power_active_edge_interrupt( - struct ppu_v1_reg *ppu, + struct ppu_v1_regs *ppu, enum ppu_v1_mode ppu_mode); void ppu_v1_set_op_active_edge_sensitivity( - struct ppu_v1_reg *ppu, + struct ppu_v1_regs *ppu, enum ppu_v1_op_devactive op_devactive, enum ppu_v1_edge_sensitivity edge_sensitivity); enum ppu_v1_edge_sensitivity ppu_v1_get_op_active_edge_sensitivity( - struct ppu_v1_reg *ppu, + struct ppu_v1_regs *ppu, enum ppu_v1_op_devactive op_devactive); void ppu_v1_ack_op_active_edge_interrupt( - struct ppu_v1_reg *ppu, + struct ppu_v1_regs *ppu, enum ppu_v1_op_devactive op_devactive); bool ppu_v1_is_op_active_edge_interrupt( - struct ppu_v1_reg *ppu, + struct ppu_v1_regs *ppu, enum ppu_v1_op_devactive op_devactive); -bool ppu_v1_is_dyn_policy_min_interrupt(struct ppu_v1_reg *ppu); +bool ppu_v1_is_dyn_policy_min_interrupt(struct ppu_v1_regs *ppu); -unsigned int ppu_v1_get_num_opmode(struct ppu_v1_reg *ppu); +unsigned int ppu_v1_get_num_opmode(struct ppu_v1_regs *ppu); -unsigned int ppu_v1_get_arch_id(struct ppu_v1_reg *ppu); +unsigned int ppu_v1_get_arch_id(struct ppu_v1_regs *ppu); diff --git a/module/ppu_v1/test/mod_ppu_v1_unit_test.c b/module/ppu_v1/test/mod_ppu_v1_unit_test.c index 6b854b3b1..81fd3af23 100644 --- a/module/ppu_v1/test/mod_ppu_v1_unit_test.c +++ b/module/ppu_v1/test/mod_ppu_v1_unit_test.c @@ -139,11 +139,11 @@ void test_ppu_v1_core_pd_set_state_sleep(void) ppu_v1_is_dynamic_enabled_ExpectAnyArgsAndReturn(false); ppu_v1_dynamic_enable_ExpectAnyArgs(); ppu_v1_set_input_edge_sensitivity_Expect( - pd_ctx_temp->ppu, PPU_V1_MODE_ON, PPU_V1_EDGE_SENSITIVITY_MASKED); + &pd_ctx_temp->ppu, PPU_V1_MODE_ON, PPU_V1_EDGE_SENSITIVITY_MASKED); ppu_v1_lock_off_enable_ExpectAnyArgs(); ppu_v1_interrupt_unmask_ExpectAnyArgs(); ppu_v1_set_input_edge_sensitivity_Expect( - pd_ctx_temp->ppu, PPU_V1_MODE_ON, PPU_V1_EDGE_SENSITIVITY_MASKED); + &pd_ctx_temp->ppu, PPU_V1_MODE_ON, PPU_V1_EDGE_SENSITIVITY_MASKED); fwk_id_get_element_idx_ExpectAnyArgsAndReturn(0); fwk_id_get_element_idx_ExpectAnyArgsAndReturn(0); start_alarm_api_ExpectAndReturn( @@ -199,13 +199,13 @@ void test_deeper_locking_alarm_callback(void) struct ppu_v1_pd_ctx *pd_ctx_temp; pd_ctx_temp = &ppu_v1_ctx.pd_ctx_table[0]; - ppu_v1_lock_off_disable_Expect(pd_ctx_temp->ppu); + ppu_v1_lock_off_disable_Expect(&pd_ctx_temp->ppu); ppu_v1_off_unlock_ExpectAnyArgs(); deeper_locking_alarm_callback(param); } -int scmi_test_main(void) +int mod_ppu_v1_test_main(void) { UNITY_BEGIN(); @@ -222,5 +222,5 @@ int scmi_test_main(void) int main(void) { - return scmi_test_main(); + return mod_ppu_v1_test_main(); } diff --git a/module/ppu_v1/test/ppu_v1_unit_test.c b/module/ppu_v1/test/ppu_v1_unit_test.c new file mode 100644 index 000000000..419c29ba2 --- /dev/null +++ b/module/ppu_v1/test/ppu_v1_unit_test.c @@ -0,0 +1,66 @@ +/* + * Arm SCP/MCP Software + * Copyright (c) 2024, Arm Limited and Contributors. All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include "unity.h" + +#include + +#include UNIT_TEST_SRC + +#define WRITE_PATTERN 0x11223344 + +void setUp(void) +{ +} + +void tearDown(void) +{ +} + +#ifdef BUILD_HAS_AE_EXTENSION +void test_ppu_v1_write_ppu_reg(void) +{ + struct ppu_v1_regs ppu; + struct ppu_v1_ppu_reg ppu_reg; + struct ppu_v1_cluster_ae_reg cluster_ae_reg; + + ppu.ppu_reg = &ppu_reg; + ppu.cluster_ae_reg = &cluster_ae_reg; + ppu_reg.PWPR = 0; + cluster_ae_reg.CLUSTERWRITEKEY = 0; + + ppu_v1_write_ppu_reg(&ppu, &ppu_reg.PWPR, WRITE_PATTERN); + TEST_ASSERT_EQUAL(ppu_reg.PWPR, WRITE_PATTERN); + TEST_ASSERT_EQUAL(cluster_ae_reg.CLUSTERWRITEKEY, CLUSTER_AE_KEY_VALUE); +} +#else +void test_ppu_v1_write_ppu_reg(void) +{ + struct ppu_v1_regs ppu; + struct ppu_v1_ppu_reg ppu_reg; + + ppu.ppu_reg = &ppu_reg; + ppu_reg.PWPR = 0; + + ppu_v1_write_ppu_reg(&ppu, &ppu_reg.PWPR, WRITE_PATTERN); + TEST_ASSERT_EQUAL(ppu_reg.PWPR, WRITE_PATTERN); +} +#endif + +int ppu_v1_test_main(void) +{ + UNITY_BEGIN(); + + RUN_TEST(test_ppu_v1_write_ppu_reg); + + return UNITY_END(); +} + +int main(void) +{ + return ppu_v1_test_main(); +} -- GitLab