Problem with mocked function using 32-bit compiler in Ceedling unit tests

[dampie286]

Hello,

I'm working on a project that uses Ceedling for unit testing, and I'm encountering an issue with a mocked function that writes to a pointer variable when compiling with a 32-bit compiler.

Function being mocked:

eResult eCalculate(float32_t fInVal, float32_t * const pOutVal);

Relevant part of project.yml:

:flags:
  :test:
    :compile:
      - -m32
      - -g
      - -O0
    :link:
      - -m32
      - -g

When I use eCalculate_ReturnThruPtr_pOutVal(...), the value of pOutVal is invalid in 2 out of 3 test cases compared to the expected value.
The issue disappears when I remove the -m32 flag.

While debugging the unit tests, I noticed that the CMock instance address differs from the expected address.

Do I need to change or add something in project.yml, or could this be an issue with CMock or Ceedling?

Note: In another project, I use a similar function and have no issues with 32-bit compilation.

[Letme]

Could the const be the problem? You have output variable with const value?

[dampie286]

The output variable is not a constant value.
I think this is not related to the const qualifier itself, but rather an issue with linking or compiling the mocks or the test file.
When I change the type from float to uint32_t or int (i.e., a non-floating-point type), it works correctly.

When I modify the function to:

float32_t fCalculate(float32_t fInVal);

the returned value is always incorrect - random value.

However, when I debug the code and step into the mocked function:

float32_t fCalculate(float32_t fInVal)
{
  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
  CMOCK_fCalculate_CALL_INSTANCE* cmock_call_instance;
  UNITY_SET_DETAIL(CMockString_fCalculate);
  cmock_call_instance = (CMOCK_fCalculate_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.fCalculate_CallInstance);
  Mock.fCalculate_CallInstance = CMock_Guts_MemNext(Mock.fCalculate_CallInstance);
  if (Mock.fCalculate_IgnoreBool)
  {
    UNITY_CLR_DETAILS();
    if (cmock_call_instance == NULL)
      return Mock.fCalculate_FinalReturn;
    Mock.fCalculate_FinalReturn = cmock_call_instance->ReturnVal;
    return cmock_call_instance->ReturnVal;
  }
  if (!Mock.fCalculate_CallbackBool &&
      Mock.fCalculate_CallbackFunctionPointer != NULL)
  {
    float cmock_cb_ret = Mock.fCalculate_CallbackFunctionPointer(Mock.fCalculate_CallbackCalls++);
    UNITY_CLR_DETAILS();
    return cmock_cb_ret;
  }
}

cmock_call_instance->ReturnVal is set correctly by ExpectAndReturn,
but after the function returns, the test receives a different value.

[Letme]

That second example makes no sense unless you meant that finVal is pointer? You can always use gdb to step through and figure out why return value returned is not correct.