ceedling 0.30.0 → 0.31.0

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

@@ -0,0 +1,116 @@
+# ==========================================
+#   CMock Project - Automatic Mock Generation for C
+#   Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
+#   [Released under MIT License. Please refer to license.txt for details]
+# ==========================================
+
+require File.expand_path(File.dirname(__FILE__)) + "/../test_helper"
+require File.expand_path(File.dirname(__FILE__)) + '/../../lib/cmock_generator_plugin_ignore_stateless'
+
+describe CMockGeneratorPluginIgnoreStateless, "Verify CMockGeneratorPluginIgnoreStateless Module" do
+
+  before do
+    create_mocks :config, :utils
+    @config = create_stub(:respond_to? => true)
+    @cmock_generator_plugin_ignore_stateless = CMockGeneratorPluginIgnoreStateless.new(@config, @utils)
+  end
+
+  after do
+  end
+
+  it "have set up internal priority" do
+    assert_equal(2, @cmock_generator_plugin_ignore_stateless.priority)
+  end
+
+  it "not have any additional include file requirements" do
+    assert(!@cmock_generator_plugin_ignore_stateless.respond_to?(:include_files))
+  end
+
+  it "add a required variable to the instance structure" do
+    function = {:name => "Grass", :args => [], :return => test_return[:void]}
+    expected = "  char Grass_IgnoreBool;\n"
+    returned = @cmock_generator_plugin_ignore_stateless.instance_structure(function)
+    assert_equal(expected, returned)
+  end
+
+  it "handle function declarations for functions without return values" do
+    function = {:name => "Mold", :args_string => "void", :return => test_return[:void]}
+    expected = "#define Mold_Ignore() Mold_CMockIgnore()\nvoid Mold_CMockIgnore(void);\n" +
+               "#define Mold_StopIgnore() Mold_CMockStopIgnore()\nvoid Mold_CMockStopIgnore(void);\n"
+    returned = @cmock_generator_plugin_ignore_stateless.mock_function_declarations(function)
+    assert_equal(expected, returned)
+  end
+
+  it "handle function declarations for functions that returns something" do
+    function = {:name => "Fungus", :args_string => "void", :return => test_return[:string]}
+    expected = "#define Fungus_IgnoreAndReturn(cmock_retval) Fungus_CMockIgnoreAndReturn(cmock_retval)\n"+
+               "void Fungus_CMockIgnoreAndReturn(const char* cmock_to_return);\n" +
+               "#define Fungus_StopIgnore() Fungus_CMockStopIgnore()\n"+
+               "void Fungus_CMockStopIgnore(void);\n"
+    returned = @cmock_generator_plugin_ignore_stateless.mock_function_declarations(function)
+    assert_equal(expected, returned)
+  end
+
+  it "add required code to implementation precheck with void function" do
+    function = {:name => "Mold", :args_string => "void", :return => test_return[:void]}
+    expected = ["  if (Mock.Mold_IgnoreBool)\n",
+                "  {\n",
+                "    UNITY_CLR_DETAILS();\n",
+                "    return;\n",
+                "  }\n"
+               ].join
+    returned = @cmock_generator_plugin_ignore_stateless.mock_implementation_precheck(function)
+    assert_equal(expected, returned)
+  end
+
+  it "add required code to implementation precheck with return functions" do
+    function = {:name => "Fungus", :args_string => "void", :return => test_return[:int]}
+    retval = test_return[:int].merge({ :name => "cmock_call_instance->ReturnVal"})
+    @utils.expect :code_assign_argument_quickly, '  mock_retval_0', ["Mock.Fungus_FinalReturn", retval]
+    expected = ["  if (Mock.Fungus_IgnoreBool)\n",
+                "  {\n",
+                "    UNITY_CLR_DETAILS();\n",
+                "    if (cmock_call_instance == NULL)\n",
+                "      return Mock.Fungus_FinalReturn;\n",
+                "    mock_retval_0",
+                "    return cmock_call_instance->ReturnVal;\n",
+                "  }\n"
+               ].join
+    returned = @cmock_generator_plugin_ignore_stateless.mock_implementation_precheck(function)
+    assert_equal(expected, returned)
+  end
+
+  it "add a new mock interface for ignoring when function had no return value" do
+    function = {:name => "Slime", :args => [], :args_string => "void", :return => test_return[:void]}
+    expected = ["void Slime_CMockIgnore(void)\n",
+                "{\n",
+                "  Mock.Slime_IgnoreBool = (char)1;\n",
+                "}\n\n",
+                "void Slime_CMockStopIgnore(void)\n",
+                "{\n",
+                "  Mock.Slime_IgnoreBool = (char)0;\n",
+                "}\n\n"
+               ].join
+    returned = @cmock_generator_plugin_ignore_stateless.mock_interfaces(function)
+    assert_equal(expected, returned)
+  end
+
+  it "add a new mock interface for ignoring when function has return value" do
+    function = {:name => "Slime", :args => [], :args_string => "void", :return => test_return[:int]}
+    @utils.expect :code_add_base_expectation, "mock_return_1", ["Slime", false]
+    expected = ["void Slime_CMockIgnoreAndReturn(int cmock_to_return)\n",
+                "{\n",
+                "  Mock.Slime_CallInstance = CMOCK_GUTS_NONE;\n",
+                "  Mock.Slime_FinalReturn = cmock_to_return;\n",
+                "  Mock.Slime_IgnoreBool = (char)1;\n",
+                "}\n\n",
+                "void Slime_CMockStopIgnore(void)\n",
+                "{\n",
+                "  Mock.Slime_IgnoreBool = (char)0;\n",
+                "}\n\n"
+               ].join
+    returned = @cmock_generator_plugin_ignore_stateless.mock_interfaces(function)
+    assert_equal(expected, returned)
+  end
+
+end

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

@@ -73,7 +73,7 @@ describe CMockGeneratorPluginReturnThruPtr, "Verify CMockGeneratorPluginReturnTh
     complex_func_expect()
     expected = "  char ReturnThruPtr_tofu_Used;\n" +
                "  int* ReturnThruPtr_tofu_Val;\n" +
-               "  int ReturnThruPtr_tofu_Size;\n"
+               "  size_t ReturnThruPtr_tofu_Size;\n"
     returned = @cmock_generator_plugin_return_thru_ptr.instance_typedefs(@complex_func)
     assert_equal(expected, returned)
   end
@@ -91,10 +91,10 @@ describe CMockGeneratorPluginReturnThruPtr, "Verify CMockGeneratorPluginReturnTh
       "#define Pine_ReturnThruPtr_tofu(tofu)" +
       " Pine_CMockReturnMemThruPtr_tofu(__LINE__, tofu, sizeof(int))\n" +
       "#define Pine_ReturnArrayThruPtr_tofu(tofu, cmock_len)" +
-      " Pine_CMockReturnMemThruPtr_tofu(__LINE__, tofu, (int)(cmock_len * (int)sizeof(*tofu)))\n" +
+      " Pine_CMockReturnMemThruPtr_tofu(__LINE__, tofu, cmock_len * sizeof(*tofu))\n" +
       "#define Pine_ReturnMemThruPtr_tofu(tofu, cmock_size)" +
       " Pine_CMockReturnMemThruPtr_tofu(__LINE__, tofu, cmock_size)\n" +
-      "void Pine_CMockReturnMemThruPtr_tofu(UNITY_LINE_TYPE cmock_line, int* tofu, int cmock_size);\n"
+      "void Pine_CMockReturnMemThruPtr_tofu(UNITY_LINE_TYPE cmock_line, int* tofu, size_t cmock_size);\n"
 
     returned = @cmock_generator_plugin_return_thru_ptr.mock_function_declarations(@complex_func)
     assert_equal(expected, returned)
@@ -104,7 +104,7 @@ describe CMockGeneratorPluginReturnThruPtr, "Verify CMockGeneratorPluginReturnTh
     complex_func_expect();
 
     expected =
-      "void Pine_CMockReturnMemThruPtr_tofu(UNITY_LINE_TYPE cmock_line, int* tofu, int cmock_size)\n" +
+      "void Pine_CMockReturnMemThruPtr_tofu(UNITY_LINE_TYPE cmock_line, int* tofu, size_t cmock_size)\n" +
       "{\n" +
       "  CMOCK_Pine_CALL_INSTANCE* cmock_call_instance = " +
       "(CMOCK_Pine_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.Pine_CallInstance));\n" +

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

@@ -20,17 +20,19 @@ describe CMockGeneratorUtils, "Verify CMockGeneratorUtils Module" do
     @config.expect :plugins, []
     @config.expect :plugins, []
     @config.expect :plugins, []
+    @config.expect :plugins, []
     @config.expect :treat_as, {'int' => 'INT','short' => 'INT16','long' => 'INT','char' => 'INT8','const char*' => 'STRING'}
     @cmock_generator_utils_simple = CMockGeneratorUtils.new(@config, {:unity_helper => @unity_helper})
 
     @config.expect :when_ptr, :smart
     @config.expect :enforce_strict_ordering, true
-    @config.expect :plugins, [:array, :cexception, :return_thru_ptr, :ignore_arg, :ignore]
-    @config.expect :plugins, [:array, :cexception, :return_thru_ptr, :ignore_arg, :ignore]
-    @config.expect :plugins, [:array, :cexception, :return_thru_ptr, :ignore_arg, :ignore]
-    @config.expect :plugins, [:array, :cexception, :return_thru_ptr, :ignore_arg, :ignore]
-    @config.expect :plugins, [:array, :cexception, :return_thru_ptr, :ignore_arg, :ignore]
-    @config.expect :plugins, [:array, :cexception, :return_thru_ptr, :ignore_arg, :ignore]
+    @config.expect :plugins, [:array, :cexception, :return_thru_ptr, :ignore_arg, :ignore, :ignore_stateless]
+    @config.expect :plugins, [:array, :cexception, :return_thru_ptr, :ignore_arg, :ignore, :ignore_stateless]
+    @config.expect :plugins, [:array, :cexception, :return_thru_ptr, :ignore_arg, :ignore, :ignore_stateless]
+    @config.expect :plugins, [:array, :cexception, :return_thru_ptr, :ignore_arg, :ignore, :ignore_stateless]
+    @config.expect :plugins, [:array, :cexception, :return_thru_ptr, :ignore_arg, :ignore, :ignore_stateless]
+    @config.expect :plugins, [:array, :cexception, :return_thru_ptr, :ignore_arg, :ignore, :ignore_stateless]
+    @config.expect :plugins, [:array, :cexception, :return_thru_ptr, :ignore_arg, :ignore, :ignore_stateless]
     @config.expect :treat_as, {'int' => 'INT','short' => 'INT16','long' => 'INT','char' => 'INT8','uint32_t' => 'HEX32','const char*' => 'STRING'}
     @cmock_generator_utils_complex = CMockGeneratorUtils.new(@config, {:unity_helper => @unity_helper, :A=>1, :B=>2})
   end
@@ -153,7 +155,8 @@ describe CMockGeneratorUtils, "Verify CMockGeneratorUtils Module" do
                  :args_string => "stuff",
                  :args => [test_arg[:int_ptr], test_arg[:mytype], test_arg[:string]]
     }
-    expected = "void CMockExpectParameters_Melon(CMOCK_Melon_CALL_INSTANCE* cmock_call_instance, stuff)\n{\n" +
+    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" +
                "         sizeof(MY_TYPE[sizeof(MyMyType) == sizeof(MY_TYPE) ? 1 : -1])); /* add MY_TYPE to :treat_as_array if this causes an error */\n" +
@@ -167,7 +170,8 @@ describe CMockGeneratorUtils, "Verify CMockGeneratorUtils Module" do
                  :args_string => "stuff",
                  :args => [test_arg[:int_ptr], test_arg[:mytype], test_arg[:string]]
     }
-    expected = "void CMockExpectParameters_Melon(CMOCK_Melon_CALL_INSTANCE* cmock_call_instance, int* MyIntPtr, int MyIntPtr_Depth, const MY_TYPE MyMyType, const char* MyStr)\n{\n" +
+    expected = "void CMockExpectParameters_Melon(CMOCK_Melon_CALL_INSTANCE* cmock_call_instance, int* MyIntPtr, int MyIntPtr_Depth, const MY_TYPE MyMyType, const char* MyStr);\n" +
+               "void CMockExpectParameters_Melon(CMOCK_Melon_CALL_INSTANCE* cmock_call_instance, int* MyIntPtr, int MyIntPtr_Depth, const MY_TYPE MyMyType, const char* MyStr)\n{\n" +
                "  cmock_call_instance->Expected_MyIntPtr = MyIntPtr;\n" +
                "  cmock_call_instance->Expected_MyIntPtr_Depth = MyIntPtr_Depth;\n" +
                "  cmock_call_instance->IgnoreArg_MyIntPtr = 0;\n" +
@@ -186,7 +190,8 @@ describe CMockGeneratorUtils, "Verify CMockGeneratorUtils Module" do
                  :args_string => "stuff",
                  :args => [test_arg[:const_ptr], test_arg[:double_ptr]]
     }
-    expected = "void CMockExpectParameters_Melon(CMOCK_Melon_CALL_INSTANCE* cmock_call_instance, int* const MyConstPtr, int MyConstPtr_Depth, int const** MyDoublePtr, int MyDoublePtr_Depth)\n{\n" +
+    expected = "void CMockExpectParameters_Melon(CMOCK_Melon_CALL_INSTANCE* cmock_call_instance, int* const MyConstPtr, int MyConstPtr_Depth, int const** MyDoublePtr, int MyDoublePtr_Depth);\n" +
+               "void CMockExpectParameters_Melon(CMOCK_Melon_CALL_INSTANCE* cmock_call_instance, int* const MyConstPtr, int MyConstPtr_Depth, int const** MyDoublePtr, int MyDoublePtr_Depth)\n{\n" +
                "  cmock_call_instance->Expected_MyConstPtr = MyConstPtr;\n" +
                "  cmock_call_instance->Expected_MyConstPtr_Depth = MyConstPtr_Depth;\n" +
                "  cmock_call_instance->IgnoreArg_MyConstPtr = 0;\n" +

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

@@ -2009,7 +2009,8 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
     end
   end
 
-  it "Transform inline functions doesn't change a header with no inlines" do
+  it "Transform inline functions only removes comments from a header with no inlines" do
+    # We remove the comments from the header, this is to protect the parser from wrongfully recognizing inline functions
     source =
       "#ifndef _NOINCLUDES\n" +
       "#define _NOINCLUDES\n" +
@@ -2040,7 +2041,37 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
       "\n" +
       "#endif _NOINCLUDES\n"
 
-    assert_equal(source, @parser.transform_inline_functions(source))
+    expected =
+      "#ifndef _NOINCLUDES\n" +
+      "#define _NOINCLUDES\n" +
+      "#include \"unity.h\"\n" +
+      "#include \"cmock.h\"\n" +
+      "#include \"YetAnotherHeader.h\"\n" +
+      "\n" +
+      "\n" +                    # Removed comment
+      "#if defined(__GNUC__) && !defined(__ICC) && !defined(__TMS470__)\n" +
+      "#if __GNUC__ > 4 || (__GNUC__ == 4 && (__GNUC_MINOR__ > 6 || (__GNUC_MINOR__ == 6 && __GNUC_PATCHLEVEL__ > 0)))\n" +
+      "#pragma GCC diagnostic push\n" +
+      "#endif\n" +
+      "#if !defined(__clang__)\n" +
+      "#pragma GCC diagnostic ignored \"-Wpragmas\"\n" +
+      "#endif\n" +
+      "#pragma GCC diagnostic ignored \"-Wunknown-pragmas\"\n" +
+      "#pragma GCC diagnostic ignored \"-Wduplicate-decl-specifier\"\n" +
+      "#endif\n" +
+      "\n" +
+      "struct my_struct {\n" +
+      "int a;\n" +
+      "int b;\n" +
+      "int b;\n" +
+      "char c;\n" +
+      "};\n" +
+      "int my_function(int a);\n" +
+      "int my_better_function(struct my_struct *s);\n" +
+      "\n" +
+      "#endif _NOINCLUDES\n"
+
+    assert_equal(expected, @parser.transform_inline_functions(source))
   end
 
   it "Transform inline functions changes inline functions to function declarations" do
@@ -2133,7 +2164,7 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
       "#include \"cmock.h\"\n" +
       "#include \"YetAnotherHeader.h\"\n" +
       "\n" +
-      "/* Ignore the following warnings since we are copying code */\n" +
+      "\n" +                    # Removed comment
       "#if defined(__GNUC__) && !defined(__ICC) && !defined(__TMS470__)\n" +
       "#if __GNUC__ > 4 || (__GNUC__ == 4 && (__GNUC_MINOR__ > 6 || (__GNUC_MINOR__ == 6 && __GNUC_PATCHLEVEL__ > 0)))\n" +
       "#pragma GCC diagnostic push\n" +
@@ -2173,6 +2204,73 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
     assert_equal(expected, @parser.transform_inline_functions(source))
   end
 
+  it "Transform inline functions leaves static variables" do
+    source =
+      "#ifndef _NOINCLUDES\n" +
+      "#define _NOINCLUDES\n" +
+      "#include \"unity.h\"\n" +
+      "#include \"cmock.h\"\n" +
+      "#include \"YetAnotherHeader.h\"\n" +
+      "\n" +
+      "/* Ignore the following warnings since we are copying code */\n" +
+      "#if defined(__GNUC__) && !defined(__ICC) && !defined(__TMS470__)\n" +
+      "#if __GNUC__ > 4 || (__GNUC__ == 4 && (__GNUC_MINOR__ > 6 || (__GNUC_MINOR__ == 6 && __GNUC_PATCHLEVEL__ > 0)))\n" +
+      "#pragma GCC diagnostic push\n" +
+      "#endif\n" +
+      "#if !defined(__clang__)\n" +
+      "#pragma GCC diagnostic ignored \"-Wpragmas\"\n" +
+      "#endif\n" +
+      "#pragma GCC diagnostic ignored \"-Wunknown-pragmas\"\n" +
+      "#pragma GCC diagnostic ignored \"-Wduplicate-decl-specifier\"\n" +
+      "#endif\n" +
+      "\n" +
+      "int my_function(int a);\n" +
+      "static inline int staticinlinefunc(struct my_struct *s)\n" +
+      "{\n" +
+      "    return s->a;\n" +
+      "}\n" +
+      "static const int my_variable = 5;\n" +
+      "struct my_struct {\n" +
+      "int a;\n" +
+      "int b;\n" +
+      "int b;\n" +
+      "char c;\n" +
+      "};\n" +
+      "#endif _NOINCLUDES\n"
+
+    expected =
+    "#ifndef _NOINCLUDES\n" +
+    "#define _NOINCLUDES\n" +
+    "#include \"unity.h\"\n" +
+    "#include \"cmock.h\"\n" +
+    "#include \"YetAnotherHeader.h\"\n" +
+    "\n" +
+    "\n" + #The comments are now removed
+    "#if defined(__GNUC__) && !defined(__ICC) && !defined(__TMS470__)\n" +
+    "#if __GNUC__ > 4 || (__GNUC__ == 4 && (__GNUC_MINOR__ > 6 || (__GNUC_MINOR__ == 6 && __GNUC_PATCHLEVEL__ > 0)))\n" +
+    "#pragma GCC diagnostic push\n" +
+    "#endif\n" +
+    "#if !defined(__clang__)\n" +
+    "#pragma GCC diagnostic ignored \"-Wpragmas\"\n" +
+    "#endif\n" +
+    "#pragma GCC diagnostic ignored \"-Wunknown-pragmas\"\n" +
+    "#pragma GCC diagnostic ignored \"-Wduplicate-decl-specifier\"\n" +
+    "#endif\n" +
+    "\n" +
+    "int my_function(int a);\n" +
+    "int staticinlinefunc(struct my_struct *s);\n" +
+    "static const int my_variable = 5;\n" +
+    "struct my_struct {\n" +
+    "int a;\n" +
+    "int b;\n" +
+    "int b;\n" +
+    "char c;\n" +
+    "};\n" +
+    "#endif _NOINCLUDES\n"
+
+    assert_equal(expected, @parser.transform_inline_functions(source))
+  end
+
   it "Count number of pairs of braces in function succesfully" do
     source =
       "int foo(struct my_struct *s)\n" +
@@ -2714,4 +2812,32 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
     assert_equal(expected, @parser.transform_inline_functions(source))
   end
 
+  it "Transform inline functions will ignore comments containing static" do
+    source =
+      "typedef struct {\n" +
+      "const uint32_t var1;\n" +
+      "const uint16_t var2; // comment with the word static in it\n" +
+      "} struct1;\n" +
+      "\n" +
+      "typedef struct {\n" +
+      "const uint32_t var1;\n" +
+      "const uint16_t var2;\n" +
+      "} struct2;\n"
+
+    expected =
+      "typedef struct {\n" +
+      "const uint32_t var1;\n" +
+      "const uint16_t var2; \n" +
+      "} struct1;\n" +
+      "\n" +
+      "typedef struct {\n" +
+      "const uint32_t var1;\n" +
+      "const uint16_t var2;\n" +
+      "} struct2;\n"
+
+    @parser.treat_inlines = :include
+    assert_equal(expected, @parser.transform_inline_functions(source))
+  end
+
+
 end

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

@@ -18,7 +18,8 @@ describe CMockPluginManager, "Verify CMockPluginManager Module" do
       :respond_to => true,
       :when_ptr => :compare_data,
       :enforce_strict_ordering => false,
-      :ignore => :args_and_calls
+      :ignore => :args_and_calls,
+      :exclude_setjmp_h => false
     )
 
     def @config.plugins

data/vendor/cmock/vendor/c_exception/README.md

@@ -1,7 +1,5 @@
-CException - Lightweight exception library for C
-================================================
-
-[![CException Build Status](https://api.travis-ci.org/ThrowTheSwitch/CException.png?branch=master)](https://travis-ci.org/ThrowTheSwitch/CException)
+CException ![CI](https://github.com/ThrowTheSwitch/CException/workflows/CI/badge.svg)
+==========
 
 _This Documentation Is Released Under a Creative Commons 3.0 Attribution Share-Alike License_
 
@@ -127,7 +125,7 @@ location was updated and not just a register unless the variable is marked volat
 ### Memory Management
 
 Memory which is `malloc`'d within a `Try` block is not automatically released when an error is thrown. This 
-will sometimes be desirable, and othertimes may not. It will be the responsibility of the code you put in 
+will sometimes be desirable, and other times may not. It will be the responsibility of the code you put in 
 the `Catch` block to perform this kind of cleanup.
 
 There's just no easy way to track `malloc`'d memory, etc., without replacing or wrapping `malloc` 
@@ -241,7 +239,7 @@ License
 =======
 
 *This software is licensed under the MIT License:
-Copyright (c) 2007-2019 Mark VanderVoord*
+Copyright (c) 2007-2021 Mark VanderVoord*
 
 *Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.*

data/vendor/cmock/vendor/c_exception/docs/CException.md

@@ -145,7 +145,7 @@ to successfully utilize this library:
 
 3. Memory which is `malloc`'d or `new`'d is not automatically released
    when an error is thrown.  This will sometimes be desirable, and
-   othertimes may not.  It will be the responsibility of the `Catch`
+   other times may not.  It will be the responsibility of the `Catch`
    block to perform this kind of cleanup.
 
    *Why?*
@@ -311,7 +311,7 @@ LICENSE
 
 This software is licensed under the MIT License
 
-Copyright (c) 2007-2020 Mark VanderVoord
+Copyright (c) 2007-2021 Mark VanderVoord
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/vendor/cmock/vendor/c_exception/lib/CException.h

@@ -11,7 +11,7 @@ extern "C"
 
 #define CEXCEPTION_VERSION_MAJOR    1
 #define CEXCEPTION_VERSION_MINOR    3
-#define CEXCEPTION_VERSION_BUILD    2
+#define CEXCEPTION_VERSION_BUILD    3
 #define CEXCEPTION_VERSION          ((CEXCEPTION_VERSION_MAJOR << 16) | (CEXCEPTION_VERSION_MINOR << 8) | CEXCEPTION_VERSION_BUILD)
 
 //To Use CException, you have a number of options:

data/vendor/cmock/vendor/c_exception/lib/meson.build

@@ -7,5 +7,5 @@
 cexception_dir = include_directories('.')
 
 cexception_lib = static_library(meson.project_name(), 
-    sources: ['CException.c'],
-    include_directories: cexception_dir)
+    files('CException.c'),
+    include_directories : cexception_dir)

data/vendor/cmock/vendor/c_exception/meson.build

@@ -4,45 +4,11 @@
 #
 # license: MIT
 #
-project('CException', 'c',
+project('cexception', 'c',
     license: 'MIT',
     meson_version: '>=0.53.0',
-    default_options: ['layout=flat', 'warning_level=3', 'werror=true', 'c_std=c11']
+    default_options: ['werror=true', 'c_std=c11']
 )
-lang = 'c'
-cc = meson.get_compiler(lang)
 
-#
-# Meson: Add compiler flags
-if cc.get_id() == 'clang'
-    add_project_arguments(cc.get_supported_arguments(
-            [
-                '-Wexit-time-destructors',
-                '-Wglobal-constructors',
-                '-Wmissing-prototypes',
-                '-Wmissing-noreturn',
-                '-Wno-missing-braces',
-                '-Wold-style-cast', '-Wpointer-arith', '-Wweak-vtables',
-                '-Wcast-align', '-Wconversion', '-Wcast-qual', '-Wshadow'
-            ]
-        ), language: lang)
-endif
-
-if cc.get_argument_syntax() == 'gcc'
-    add_project_arguments(cc.get_supported_arguments(
-            [
-                '-Wformat', '-Waddress', '-Winit-self', '-Wno-multichar',
-                '-Wpointer-arith'       , '-Wwrite-strings'              ,
-                '-Wno-parentheses'      , '-Wno-type-limits'             ,
-                '-Wformat-security'     , '-Wunreachable-code'           ,
-                '-Waggregate-return'    , '-Wformat-nonliteral'          ,
-                '-Wmissing-declarations', '-Wmissing-include-dirs'       ,
-                '-Wno-unused-parameter'
-            ]
-        ), language: lang)
-endif
-
-#
-# Sub directory to project source code
 subdir('lib')
 cexception_dep = declare_dependency(link_with: cexception_lib, include_directories: cexception_dir)