ceedling 1.0.1 → 1.1.0

data/vendor/cmock/test/unit/cmock_generator_plugin_return_thru_ptr_test.rb

@@ -1,7 +1,7 @@
 # =========================================================================
 #   CMock - Automatic Mock Generation for C
 #   ThrowTheSwitch.org
-#   Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   Copyright (c) 2007-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
 #   SPDX-License-Identifier: MIT
 # =========================================================================
 
@@ -56,7 +56,20 @@ describe CMockGeneratorPluginReturnThruPtr, "Verify CMockGeneratorPluginReturnTh
                       :return => test_return[:void],
                       :contains_ptr? => true }
 
+    # void Cedar(volatile struct foo_obj *foo_handle)
+    # arg[:type] has volatile stripped at parse time; volatile? flag carries the information
+    @volatile_ptr_func = {:name => "Cedar",
+                          :args => [{ :type      => "struct foo_obj*",
+                                      :name      => "foo_handle",
+                                      :ptr?      => true,
+                                      :volatile? => true,
+                                    }],
+                          :return => test_return[:void],
+                          :contains_ptr? => true }
+
     #no strict ordering
+    @config.expect :plugins, []
+    @config.expect :debug_output, false
     @cmock_generator_plugin_return_thru_ptr = CMockGeneratorPluginReturnThruPtr.new(@config, @utils)
   end
 
@@ -81,6 +94,10 @@ describe CMockGeneratorPluginReturnThruPtr, "Verify CMockGeneratorPluginReturnTh
     @config.expect :treat_as_void, ['MY_FANCY_VOID']
   end
 
+  def volatile_ptr_func_expect
+    @utils.expect :ptr_or_str?, true, ['struct foo_obj*']
+  end
+
   it "have set up internal priority correctly on init" do
     assert_equal(9, @cmock_generator_plugin_return_thru_ptr.priority)
   end
@@ -192,13 +209,13 @@ describe CMockGeneratorPluginReturnThruPtr, "Verify CMockGeneratorPluginReturnTh
       "  if (cmock_call_instance->ReturnThruPtr_tofu_Used)\n" +
       "  {\n" +
       "    UNITY_TEST_ASSERT_NOT_NULL(tofu, cmock_line, CMockStringPtrIsNULL);\n" +
-      "    memcpy((void*)tofu, (const void*)cmock_call_instance->ReturnThruPtr_tofu_Val,\n" +
+      "    CMOCK_MEMCPY((void*)tofu, (const void*)cmock_call_instance->ReturnThruPtr_tofu_Val,\n" +
       "      cmock_call_instance->ReturnThruPtr_tofu_Size);\n" +
       "  }\n" +
       "  if (cmock_call_instance->ReturnThruPtr_bean_buffer_Used)\n" +
       "  {\n" +
       "    UNITY_TEST_ASSERT_NOT_NULL(bean_buffer, cmock_line, CMockStringPtrIsNULL);\n" +
-      "    memcpy((void*)bean_buffer, (const void*)cmock_call_instance->ReturnThruPtr_bean_buffer_Val,\n" +
+      "    CMOCK_MEMCPY((void*)bean_buffer, (const void*)cmock_call_instance->ReturnThruPtr_bean_buffer_Val,\n" +
       "      cmock_call_instance->ReturnThruPtr_bean_buffer_Size);\n" +
       "  }\n"
 
@@ -206,4 +223,119 @@ describe CMockGeneratorPluginReturnThruPtr, "Verify CMockGeneratorPluginReturnTh
     assert_equal(expected, returned)
   end
 
+  it "has no volatile in the Val typedef member for a volatile pointer arg (type is pre-stripped)" do
+    volatile_ptr_func_expect()
+
+    # arg[:type] = "struct foo_obj*" (volatile stripped at parse time)
+    # ptr_to_const("struct foo_obj*") => "struct foo_obj const*"
+    expected = "  char ReturnThruPtr_foo_handle_Used;\n" +
+               "  struct foo_obj const* ReturnThruPtr_foo_handle_Val;\n" +
+               "  size_t ReturnThruPtr_foo_handle_Size;\n"
+
+    returned = @cmock_generator_plugin_return_thru_ptr.instance_typedefs(@volatile_ptr_func)
+    assert_equal(expected, returned)
+  end
+
+  it "has no volatile in the _CMockReturnMemThruPtr_ declaration for a volatile pointer arg" do
+    volatile_ptr_func_expect()
+
+    # arg[:type] = "struct foo_obj*" (volatile stripped), so sizeof and param type are clean.
+    expected =
+      "#define Cedar_ReturnThruPtr_foo_handle(foo_handle)" +
+      " Cedar_CMockReturnMemThruPtr_foo_handle(__LINE__, foo_handle, sizeof(struct foo_obj))\n" +
+      "#define Cedar_ReturnArrayThruPtr_foo_handle(foo_handle, cmock_len)" +
+      " Cedar_CMockReturnMemThruPtr_foo_handle(__LINE__, foo_handle, (cmock_len * sizeof(*foo_handle)))\n" +
+      "#define Cedar_ReturnMemThruPtr_foo_handle(foo_handle, cmock_size)" +
+      " Cedar_CMockReturnMemThruPtr_foo_handle(__LINE__, foo_handle, (cmock_size))\n" +
+      "void Cedar_CMockReturnMemThruPtr_foo_handle(UNITY_LINE_TYPE cmock_line, struct foo_obj const* foo_handle, size_t cmock_size);\n"
+
+    returned = @cmock_generator_plugin_return_thru_ptr.mock_function_declarations(@volatile_ptr_func)
+    assert_equal(expected, returned)
+  end
+
+  it "uses (void*) cast in mock_implementation for volatile pointer arg" do
+    volatile_ptr_func_expect()
+
+    expected =
+      "  if (cmock_call_instance->ReturnThruPtr_foo_handle_Used)\n" +
+      "  {\n" +
+      "    UNITY_TEST_ASSERT_NOT_NULL(foo_handle, cmock_line, CMockStringPtrIsNULL);\n" +
+      "    CMOCK_MEMCPY(CMOCK_DEVOLATILE_PTR(foo_handle), (const void*)cmock_call_instance->ReturnThruPtr_foo_handle_Val,\n" +
+      "      cmock_call_instance->ReturnThruPtr_foo_handle_Size);\n" +
+      "  }\n"
+
+    returned = @cmock_generator_plugin_return_thru_ptr.mock_implementation(@volatile_ptr_func).join("")
+    assert_equal(expected, returned)
+  end
+
+  it "converts single pointer type to pointer-to-const via ptr_to_const" do
+    plugin = @cmock_generator_plugin_return_thru_ptr
+    assert_equal("int const*",     plugin.ptr_to_const("int*"))
+    assert_equal("char const*",    plugin.ptr_to_const("char*"))
+    assert_equal("uint8_t const*", plugin.ptr_to_const("uint8_t*"))
+    assert_equal("void const*",    plugin.ptr_to_const("void*"))
+    assert_equal("MY_TYPE const*", plugin.ptr_to_const("MY_TYPE*"))
+  end
+
+  it "converts double pointer type by making inner pointer const via ptr_to_const" do
+    plugin = @cmock_generator_plugin_return_thru_ptr
+    assert_equal("char* const*",   plugin.ptr_to_const("char**"))
+    assert_equal("int* const*",    plugin.ptr_to_const("int**"))
+  end
+
+  it "includes int* const args (const pointer, mutable data) in typedef but excludes const int* args" do
+    # int* const: const_ptr?=true, const?=false → data is mutable, pointer is const
+    # The condition `!(arg[:const?])` checks whether the POINTED-TO data is const.
+    # const? is about the data, not the pointer itself, so int* const IS included.
+    const_ptr_func = {
+      :name => "Birch",
+      :args => [
+        { :type => "int*",       :name => "mutable_ptr",  :ptr? => true, :const? => false, :const_ptr? => false },
+        { :type => "int*",       :name => "const_ptr",    :ptr? => true, :const? => false, :const_ptr? => true  },
+        { :type => "const int*", :name => "ptr_to_const", :ptr? => true, :const? => true,  :const_ptr? => false },
+      ],
+      :return => test_return[:void]
+    }
+
+    @utils.expect :ptr_or_str?, true, ["int*"]
+    @utils.expect :ptr_or_str?, true, ["int*"]
+    @utils.expect :ptr_or_str?, true, ["const int*"]
+
+    # mutable_ptr and const_ptr are included; ptr_to_const is excluded (const?=true)
+    expected = "  char ReturnThruPtr_mutable_ptr_Used;\n" +
+               "  int const* ReturnThruPtr_mutable_ptr_Val;\n" +
+               "  size_t ReturnThruPtr_mutable_ptr_Size;\n" +
+               "  char ReturnThruPtr_const_ptr_Used;\n" +
+               "  int const* ReturnThruPtr_const_ptr_Val;\n" +
+               "  size_t ReturnThruPtr_const_ptr_Size;\n"
+
+    returned = @cmock_generator_plugin_return_thru_ptr.instance_typedefs(const_ptr_func)
+    assert_equal(expected, returned)
+  end
+
+  it "generates correct function signature for int* const args in mock interface" do
+    const_ptr_func = {
+      :name => "Birch",
+      :args => [
+        { :type => "int*", :name => "const_ptr", :ptr? => true, :const? => false, :const_ptr? => true },
+      ],
+      :return => test_return[:void]
+    }
+
+    @utils.expect :ptr_or_str?, true, ["int*"]
+
+    # ptr_to_const("int*") = "int const*", so the helper function takes int const* const_ptr
+    expected =
+      "#define Birch_ReturnThruPtr_const_ptr(const_ptr)" +
+      " Birch_CMockReturnMemThruPtr_const_ptr(__LINE__, const_ptr, sizeof(int))\n" +
+      "#define Birch_ReturnArrayThruPtr_const_ptr(const_ptr, cmock_len)" +
+      " Birch_CMockReturnMemThruPtr_const_ptr(__LINE__, const_ptr, (cmock_len * sizeof(*const_ptr)))\n" +
+      "#define Birch_ReturnMemThruPtr_const_ptr(const_ptr, cmock_size)" +
+      " Birch_CMockReturnMemThruPtr_const_ptr(__LINE__, const_ptr, (cmock_size))\n" +
+      "void Birch_CMockReturnMemThruPtr_const_ptr(UNITY_LINE_TYPE cmock_line, int const* const_ptr, size_t cmock_size);\n"
+
+    returned = @cmock_generator_plugin_return_thru_ptr.mock_function_declarations(const_ptr_func)
+    assert_equal(expected, returned)
+  end
+
 end

data/vendor/cmock/test/unit/cmock_generator_utils_test.rb

@@ -1,7 +1,7 @@
 # =========================================================================
 #   CMock - Automatic Mock Generation for C
 #   ThrowTheSwitch.org
-#   Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   Copyright (c) 2007-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
 #   SPDX-License-Identifier: MIT
 # =========================================================================
 
@@ -98,6 +98,46 @@ describe CMockGeneratorUtils, "Verify CMockGeneratorUtils Module" do
     assert_equal(expected, output)
   end
 
+  it "add code for a base expectation with expect_any_args plugin" do
+    config = create_stub(
+      :when_ptr => :smart,
+      :enforce_strict_ordering => false,
+      :plugins => [:expect_any_args],
+      :treat_as => {},
+      :respond_to? => false
+    )
+    utils = CMockGeneratorUtils.new(config, {})
+    expected =
+      "  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_Apple_CALL_INSTANCE));\n" +
+      "  CMOCK_Apple_CALL_INSTANCE* cmock_call_instance = (CMOCK_Apple_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);\n" +
+      "  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);\n" +
+      "  memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));\n" +
+      "  Mock.Apple_CallInstance = CMock_Guts_MemChain(Mock.Apple_CallInstance, cmock_guts_index);\n" +
+      "  cmock_call_instance->LineNumber = cmock_line;\n" +
+      "  cmock_call_instance->ExpectAnyArgsBool = (char)0;\n"
+    assert_equal(expected, utils.code_add_base_expectation("Apple"))
+  end
+
+  it "add code for a base expectation with ignore_stateless plugin (without ignore)" do
+    config = create_stub(
+      :when_ptr => :smart,
+      :enforce_strict_ordering => false,
+      :plugins => [:ignore_stateless],
+      :treat_as => {},
+      :respond_to? => false
+    )
+    utils = CMockGeneratorUtils.new(config, {})
+    expected =
+      "  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_Apple_CALL_INSTANCE));\n" +
+      "  CMOCK_Apple_CALL_INSTANCE* cmock_call_instance = (CMOCK_Apple_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);\n" +
+      "  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);\n" +
+      "  memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));\n" +
+      "  Mock.Apple_CallInstance = CMock_Guts_MemChain(Mock.Apple_CallInstance, cmock_guts_index);\n" +
+      "  Mock.Apple_IgnoreBool = (char)0;\n" +
+      "  cmock_call_instance->LineNumber = cmock_line;\n"
+    assert_equal(expected, utils.code_add_base_expectation("Apple"))
+  end
+
   it "add argument expectations for values when no array plugin" do
     arg1 = { :name => "Orange", :const? => false, :type => 'int', :ptr? => false }
     expected1 = "  cmock_call_instance->Expected_Orange = Orange;\n"
@@ -109,7 +149,7 @@ describe CMockGeneratorUtils, "Verify CMockGeneratorUtils Module" do
     expected3 = "  cmock_call_instance->Expected_Kiwi = Kiwi;\n"
 
     arg4 = { :name => "Lime", :const? => false, :type => 'LIME_T', :ptr? => false }
-    expected4 = "  memcpy((void*)(&cmock_call_instance->Expected_Lime), (void*)(&Lime),\n" +
+    expected4 = "  memcpy((void*)(&cmock_call_instance->Expected_Lime), (const void*)(&Lime),\n" +
                 "         sizeof(LIME_T[sizeof(Lime) == sizeof(LIME_T) ? 1 : -1])); /* add LIME_T to :treat_as_array if this causes an error */\n"
 
     assert_equal(expected1, @cmock_generator_utils_simple.code_add_an_arg_expectation(arg1))
@@ -130,18 +170,18 @@ describe CMockGeneratorUtils, "Verify CMockGeneratorUtils Module" do
 
     arg3 = { :name => "Kiwi", :const? => false, :type => 'KIWI_T*', :ptr? => true }
     expected3 = "  cmock_call_instance->Expected_Kiwi = Kiwi;\n" +
-                "  cmock_call_instance->Expected_Kiwi_Depth = Kiwi_Depth;\n" +
+                "  cmock_call_instance->Expected_Kiwi_Depth = Mango_Depth;\n" +
                 "  cmock_call_instance->IgnoreArg_Kiwi = 0;\n" +
                 "  cmock_call_instance->ReturnThruPtr_Kiwi_Used = 0;\n"
 
     arg4 = { :name => "Lime", :const? => false, :type => 'LIME_T', :ptr? => false }
-    expected4 = "  memcpy((void*)(&cmock_call_instance->Expected_Lime), (void*)(&Lime),\n" +
+    expected4 = "  memcpy((void*)(&cmock_call_instance->Expected_Lime), (const void*)(&Lime),\n" +
                 "         sizeof(LIME_T[sizeof(Lime) == sizeof(LIME_T) ? 1 : -1])); /* add LIME_T to :treat_as_array if this causes an error */\n" +
                 "  cmock_call_instance->IgnoreArg_Lime = 0;\n"
 
     assert_equal(expected1, @cmock_generator_utils_complex.code_add_an_arg_expectation(arg1))
     assert_equal(expected2, @cmock_generator_utils_complex.code_add_an_arg_expectation(arg2, 'Lemon_Depth'))
-    assert_equal(expected3, @cmock_generator_utils_complex.code_add_an_arg_expectation(arg3, 'Lemon_Depth'))
+    assert_equal(expected3, @cmock_generator_utils_complex.code_add_an_arg_expectation(arg3, 'Mango_Depth'))
     assert_equal(expected4, @cmock_generator_utils_complex.code_add_an_arg_expectation(arg4))
   end
 
@@ -159,7 +199,7 @@ describe CMockGeneratorUtils, "Verify CMockGeneratorUtils Module" do
     expected = "void CMockExpectParameters_Melon(CMOCK_Melon_CALL_INSTANCE* cmock_call_instance, stuff);\n" +
                "void CMockExpectParameters_Melon(CMOCK_Melon_CALL_INSTANCE* cmock_call_instance, stuff)\n{\n" +
                "  cmock_call_instance->Expected_MyIntPtr = MyIntPtr;\n" +
-               "  memcpy((void*)(&cmock_call_instance->Expected_MyMyType), (void*)(&MyMyType),\n" +
+               "  memcpy((void*)(&cmock_call_instance->Expected_MyMyType), (const void*)(&MyMyType),\n" +
                "         sizeof(MY_TYPE[sizeof(MyMyType) == sizeof(MY_TYPE) ? 1 : -1])); /* add MY_TYPE to :treat_as_array if this causes an error */\n" +
                "  cmock_call_instance->Expected_MyStr = MyStr;\n" +
                "}\n\n"
@@ -177,7 +217,7 @@ describe CMockGeneratorUtils, "Verify CMockGeneratorUtils Module" do
                "  cmock_call_instance->Expected_MyIntPtr_Depth = MyIntPtr_Depth;\n" +
                "  cmock_call_instance->IgnoreArg_MyIntPtr = 0;\n" +
                "  cmock_call_instance->ReturnThruPtr_MyIntPtr_Used = 0;\n" +
-               "  memcpy((void*)(&cmock_call_instance->Expected_MyMyType), (void*)(&MyMyType),\n" +
+               "  memcpy((void*)(&cmock_call_instance->Expected_MyMyType), (const void*)(&MyMyType),\n" +
                "         sizeof(MY_TYPE[sizeof(MyMyType) == sizeof(MY_TYPE) ? 1 : -1])); /* add MY_TYPE to :treat_as_array if this causes an error */\n" +
                "  cmock_call_instance->IgnoreArg_MyMyType = 0;\n" +
                "  cmock_call_instance->Expected_MyStr = MyStr;\n" +
@@ -267,7 +307,7 @@ describe CMockGeneratorUtils, "Verify CMockGeneratorUtils Module" do
     arg      = test_arg[:mytype]
     expected = "  {\n" +
                "    UNITY_SET_DETAILS(CMockString_Pear,CMockString_MyMyType);\n" +
-               "    UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_MyMyType), (void*)(&MyMyType), sizeof(MY_TYPE), cmock_line, CMockStringMismatch);\n" +
+               "    UNITY_TEST_ASSERT_EQUAL_MEMORY(&cmock_call_instance->Expected_MyMyType, &MyMyType, sizeof(MY_TYPE), cmock_line, CMockStringMismatch);\n" +
                "  }\n"
     @unity_helper.expect :nil?, false
     @unity_helper.expect :get_helper, ['UNITY_TEST_ASSERT_EQUAL_MEMORY','&'], ['MY_TYPE']
@@ -351,7 +391,7 @@ describe CMockGeneratorUtils, "Verify CMockGeneratorUtils Module" do
                "    if (cmock_call_instance->Expected_MyMyType == NULL)\n" +
                "      { UNITY_TEST_ASSERT_NULL(MyMyType, cmock_line, CMockStringExpNULL); }\n" +
                "    else\n" +
-               "      { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_MyMyType), (void*)(MyMyType), sizeof(MY_TYPE), 1, cmock_line, CMockStringMismatch); }\n" +
+               "      { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY(cmock_call_instance->Expected_MyMyType, MyMyType, sizeof(MY_TYPE), 1, cmock_line, CMockStringMismatch); }\n" +
                "  }\n"
     @unity_helper.expect :nil?, false
     @unity_helper.expect :get_helper, ['UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY', ''],  ['MY_TYPE']
@@ -401,4 +441,132 @@ describe CMockGeneratorUtils, "Verify CMockGeneratorUtils Module" do
     @unity_helper.expect :get_helper, ['UNITY_TEST_ASSERT_EQUAL_MY_TYPE_ARRAY', '&'], ['MY_TYPE']
     assert_equal(expected, @cmock_generator_utils_complex.code_verify_an_arg_expectation(function, arg))
   end
+
+  # void* tests without array plugin (when_ptr: :compare_data) - these must use pointer
+  # comparison because dereferencing void* is illegal in C
+  it 'handle void pointer comparison without array plugin by using pointer comparison' do
+    config_stub = create_stub({
+      when_ptr: :compare_data,
+      enforce_strict_ordering: false,
+      plugins: [],
+      treat_as: {'void*' => 'HEX8_ARRAY', 'void const*' => 'HEX8_ARRAY', 'const void*' => 'HEX8_ARRAY'},
+      treat_as_void: []
+    })
+    utils = CMockGeneratorUtils.new(config_stub, {:unity_helper => @unity_helper})
+    function = { :name => 'Pear' }
+
+    [
+      {:type => "void*",       :name => 'MyVoidPtr',      :ptr? => true, :const? => false, :const_ptr? => false},
+      {:type => "const void*", :name => 'MyConstVoidPtr', :ptr? => true, :const? => true,  :const_ptr? => false},
+      {:type => "void const*", :name => 'MyVoidConstPtr', :ptr? => true, :const? => false, :const_ptr? => true},
+    ].each do |arg|
+      expected = "  {\n" +
+                 "    UNITY_SET_DETAILS(CMockString_Pear,CMockString_#{arg[:name]});\n" +
+                 "    UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_#{arg[:name]}, #{arg[:name]}, cmock_line, CMockStringMismatch);\n" +
+                 "  }\n"
+      assert_equal(expected, utils.code_verify_an_arg_expectation(function, arg))
+    end
+  end
+
+  it 'handle treat_as_void alias pointer comparison without array plugin by using pointer comparison' do
+    config_stub = create_stub({
+      when_ptr: :compare_data,
+      enforce_strict_ordering: false,
+      plugins: [],
+      treat_as: {'MY_VOID*' => 'HEX8_ARRAY'},
+      treat_as_void: ['MY_VOID']
+    })
+    utils = CMockGeneratorUtils.new(config_stub, {:unity_helper => @unity_helper})
+    function = { :name => 'Pear' }
+
+    arg = {:type => "MY_VOID*", :name => 'MyVoidAliasPtr', :ptr? => true, :const? => false, :const_ptr? => false}
+    expected = "  {\n" +
+               "    UNITY_SET_DETAILS(CMockString_Pear,CMockString_MyVoidAliasPtr);\n" +
+               "    UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_MyVoidAliasPtr, MyVoidAliasPtr, cmock_line, CMockStringMismatch);\n" +
+               "  }\n"
+    assert_equal(expected, utils.code_verify_an_arg_expectation(function, arg))
+  end
+
+  it 'handle treat_as_void alias pointer with array plugin using HEX8_ARRAY to avoid sizeof(void)' do
+    config_stub = create_stub({
+      when_ptr: :compare_data,
+      enforce_strict_ordering: false,
+      plugins: [:array],
+      treat_as: {},
+      treat_as_void: ['MY_VOID']
+    })
+    utils = CMockGeneratorUtils.new(config_stub, {:unity_helper => @unity_helper})
+    function = { :name => 'Pear' }
+
+    arg = {:type => "MY_VOID*", :name => 'MyVoidAliasPtr', :ptr? => true, :const? => false, :const_ptr? => false}
+    expected = "  {\n" +
+               "    UNITY_SET_DETAILS(CMockString_Pear,CMockString_MyVoidAliasPtr);\n" +
+               "    if (cmock_call_instance->Expected_MyVoidAliasPtr == NULL)\n" +
+               "      { UNITY_TEST_ASSERT_NULL(MyVoidAliasPtr, cmock_line, CMockStringExpNULL); }\n" +
+               "    else\n" +
+               "      { UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(cmock_call_instance->Expected_MyVoidAliasPtr, MyVoidAliasPtr, cmock_call_instance->Expected_MyVoidAliasPtr_Depth, cmock_line, CMockStringMismatch); }\n" +
+               "  }\n"
+    assert_equal(expected, utils.code_verify_an_arg_expectation(function, arg))
+  end
+
+  it 'correctly reconstruct type strings preserving const and pointer order' do
+    # non-pointer: no const
+    assert_equal("int",       CMockGeneratorUtils.arg_type_with_const({:type => "int",   :ptr? => false, :const? => false, :const_ptr? => false}))
+    # non-pointer: const (prepended)
+    assert_equal("const int", CMockGeneratorUtils.arg_type_with_const({:type => "int",   :ptr? => false, :const? => true,  :const_ptr? => false}))
+
+    # pointer to mutable: no const
+    assert_equal("int*",      CMockGeneratorUtils.arg_type_with_const({:type => "int*",  :ptr? => true,  :const? => false, :const_ptr? => false}))
+
+    # pointer to const (const int*): const already in :type, no trailing const
+    assert_equal("const int*",      CMockGeneratorUtils.arg_type_with_const({:type => "const int*",  :ptr? => true, :const? => true, :const_ptr? => false}))
+
+    # const pointer (int* const): :type has no const, const_ptr? appends " const"
+    assert_equal("int* const",      CMockGeneratorUtils.arg_type_with_const({:type => "int*",        :ptr? => true, :const? => false, :const_ptr? => true}))
+
+    # const pointer to const (const int* const)
+    assert_equal("const int* const", CMockGeneratorUtils.arg_type_with_const({:type => "const int*", :ptr? => true, :const? => true, :const_ptr? => true}))
+
+    # trailing-const form: int const* (same semantics as const int* but different spelling)
+    assert_equal("int const*",       CMockGeneratorUtils.arg_type_with_const({:type => "int const*", :ptr? => true, :const? => true, :const_ptr? => false}))
+
+    # trailing-const pointer to const: int const* const
+    assert_equal("int const* const", CMockGeneratorUtils.arg_type_with_const({:type => "int const*", :ptr? => true, :const? => true, :const_ptr? => true}))
+
+    # custom type pointer
+    assert_equal("MY_TYPE*",      CMockGeneratorUtils.arg_type_with_const({:type => "MY_TYPE*", :ptr? => true,  :const? => false, :const_ptr? => false}))
+    assert_equal("const MY_TYPE", CMockGeneratorUtils.arg_type_with_const({:type => "MY_TYPE",  :ptr? => false, :const? => true,  :const_ptr? => false}))
+
+    # double pointer: no const_ptr, so :type used as-is
+    assert_equal("int**",        CMockGeneratorUtils.arg_type_with_const({:type => "int**",       :ptr? => true, :const? => false, :const_ptr? => false}))
+    assert_equal("const int**",  CMockGeneratorUtils.arg_type_with_const({:type => "const int**", :ptr? => true, :const? => true,  :const_ptr? => false}))
+    # double pointer with const_ptr: appends " const" after last *
+    assert_equal("int** const",  CMockGeneratorUtils.arg_type_with_const({:type => "int**",       :ptr? => true, :const? => false, :const_ptr? => true}))
+  end
+
+  it 'produce correct C declarations preserving const and pointer order' do
+    # const pointer to mutable int: int* const p
+    arg = {:type => "int*",        :name => "p", :ptr? => true, :const? => false, :const_ptr? => true}
+    assert_equal("int* const p", CMockGeneratorUtils.arg_declaration(arg))
+
+    # pointer to const int: const int* p
+    arg = {:type => "const int*",  :name => "p", :ptr? => true, :const? => true,  :const_ptr? => false}
+    assert_equal("const int* p", CMockGeneratorUtils.arg_declaration(arg))
+
+    # const pointer to const int: const int* const p
+    arg = {:type => "const int*",  :name => "p", :ptr? => true, :const? => true,  :const_ptr? => true}
+    assert_equal("const int* const p", CMockGeneratorUtils.arg_declaration(arg))
+
+    # trailing-const form: int const* const p
+    arg = {:type => "int const*",  :name => "p", :ptr? => true, :const? => true,  :const_ptr? => true}
+    assert_equal("int const* const p", CMockGeneratorUtils.arg_declaration(arg))
+
+    # plain pointer: int* p
+    arg = {:type => "int*",        :name => "p", :ptr? => true, :const? => false, :const_ptr? => false}
+    assert_equal("int* p", CMockGeneratorUtils.arg_declaration(arg))
+
+    # non-pointer const: const MY_TYPE v
+    arg = {:type => "MY_TYPE",     :name => "v", :ptr? => false, :const? => true,  :const_ptr? => false}
+    assert_equal("const MY_TYPE v", CMockGeneratorUtils.arg_declaration(arg))
+  end
 end