Allow local and persistent mockup handle

hammocking/hammocking.py

@@ -65,12 +65,12 @@ def is_array(self) -> bool:
  or self.t.kind == TypeKind.INCOMPLETEARRAY \
  or self.t.kind == TypeKind.VARIABLEARRAY \
  or self.t.kind == TypeKind.DEPENDENTSIZEDARRAY
- 
+
  @property
  def is_struct(self) -> bool:
  fields = list(self.t.get_canonical().get_fields())
  return len(fields) > 0
- 
+
  def initializer(self) -> str:
  if self.is_struct:
  return f"({self.spelling}){{0}}"
@@ -96,9 +96,9 @@ def __init__(self, configfile: Path = None):
  return
  config = configparser.ConfigParser()
  config.read_string(configfile.read_text())
- # Read generic settings
+ # Read generic settings
  self._scan(config.items(section=self.section))
- # Read OS-specific settings
+ # Read OS-specific settings
  self._scan(config.items(section=f"{self.section}.{sys.platform}"))
 
  def _scan(self, items: Iterator[Tuple[str, str]]) -> None:
@@ -132,13 +132,13 @@ def get_definition(self, with_type: bool = True) -> str:
  return self._type.render(self.name)
  else:
  return self.name
- 
+
  def is_constant(self) -> bool:
  """Is constant qualified"""
  return self._type.is_constant
- 
+
  def initializer(self) -> str:
- """C expression to represent the value "0" according to the variable type""" 
+ """C expression to represent the value "0" according to the variable type"""
  return self._type.initializer()
 
  def __repr__(self) -> str:

hammocking/templates/gmock/mockup.cc.j2

@@ -1,6 +1,6 @@
 #include "mockup{{suffix}}.h"
 
-class_mockup *mockup_global_ptr = 0;
+mock_ptr_t mockup_global_ptr = nullptr;
 
 {% for variable in variables %}
 {% if variable.is_constant() %}
@@ -15,12 +15,12 @@ extern "C" {
 
 {{function.get_signature()}}{
 {% if function.has_return_value() %}
- if(0 != mockup_global_ptr)
+ if(mockup_global_ptr)
  return mockup_global_ptr->{{function.get_call()}};
  else
  return {{function.default_return()}};
 {% else %}
- if(0 != mockup_global_ptr)
+ if(mockup_global_ptr)
  mockup_global_ptr->{{function.get_call()}};
 {% endif %}
 } /* {{function.name}} */

hammocking/templates/gmock/mockup.h.j2

@@ -9,16 +9,25 @@ extern "C" {
 {% endfor %}
 } /* extern "C" */
 
+class class_mockup;
+typedef class_mockup* mock_ptr_t;
+extern mock_ptr_t mockup_global_ptr;
+
 class class_mockup {
 
- public:
+ public:
+ class_mockup() { mockup_global_ptr = this; }
+ ~class_mockup() { mockup_global_ptr = nullptr; }
 {% for function in functions %}
-  MOCK_METHOD(({{function.return_type}}), {{function.name}}, ({{function.get_param_types()}}));
+ MOCK_METHOD(({{function.return_type}}), {{function.name}}, ({{function.get_param_types()}}));
 {% endfor %}
 }; /* class_mockup */
 
-extern class_mockup *mockup_global_ptr;
+/* Version A: Create a local object that is destroyed when out of scope */
+#define CREATE_MOCK(name) class_mockup name
 
-#define CREATE_MOCK(name) class_mockup name; mockup_global_ptr = &name;
+/* Version B: Allocate an object that will be only explicitly deallocated */
+#define CREATE_PERSISTENT_MOCK() new class_mockup
+#define DESTROY_PERSISTENT_MOCK() {if(mockup_global_ptr) delete mockup_global_ptr;}
 
 #endif /* mockup{{suffix}}_h */

tests/data/gmock_test/test_add_function_get/mockup.cc

@@ -1,12 +1,12 @@
 #include "mockup.h"
 
-class_mockup *mockup_global_ptr = 0;
+mock_ptr_t mockup_global_ptr = nullptr;
 
 
 extern "C" {
 
 int a_get_y2(){
- if(0 != mockup_global_ptr)
+ if(mockup_global_ptr)
  return mockup_global_ptr->a_get_y2();
  else
  return (int)0;

tests/data/gmock_test/test_add_function_get/mockup.h

@@ -6,14 +6,23 @@
 extern "C" {
 } /* extern "C" */
 
+class class_mockup;
+typedef class_mockup* mock_ptr_t;
+extern mock_ptr_t mockup_global_ptr;
+
 class class_mockup {
 
- public:
- MOCK_METHOD((int), a_get_y2, ());
+ public:
+ class_mockup() { mockup_global_ptr = this; }
+ ~class_mockup() { mockup_global_ptr = nullptr; }
+ MOCK_METHOD((int), a_get_y2, ());
 }; /* class_mockup */
 
-extern class_mockup *mockup_global_ptr;
+/* Version A: Create a local object that is destroyed when out of scope */
+#define CREATE_MOCK(name) class_mockup name
 
-#define CREATE_MOCK(name) class_mockup name; mockup_global_ptr = &name;
+/* Version B: Allocate an object that will be only explicitly deallocated */
+#define CREATE_PERSISTENT_MOCK() new class_mockup
+#define DESTROY_PERSISTENT_MOCK() {if(mockup_global_ptr) delete mockup_global_ptr;}
 
 #endif /* mockup_h */

tests/data/gmock_test/test_add_function_set_one_arg/mockup.cc

@@ -1,12 +1,12 @@
 #include "mockup.h"
 
-class_mockup *mockup_global_ptr = 0;
+mock_ptr_t mockup_global_ptr = nullptr;
 
 
 extern "C" {
 
 void set_some_int(int some_value){
- if(0 != mockup_global_ptr)
+ if(mockup_global_ptr)
  mockup_global_ptr->set_some_int(some_value);
 } /* set_some_int */
 }

tests/data/gmock_test/test_add_function_set_one_arg/mockup.h

@@ -6,14 +6,23 @@
 extern "C" {
 } /* extern "C" */
 
+class class_mockup;
+typedef class_mockup* mock_ptr_t;
+extern mock_ptr_t mockup_global_ptr;
+
 class class_mockup {
 
- public:
- MOCK_METHOD((void), set_some_int, (int));
+ public:
+ class_mockup() { mockup_global_ptr = this; }
+ ~class_mockup() { mockup_global_ptr = nullptr; }
+ MOCK_METHOD((void), set_some_int, (int));
 }; /* class_mockup */
 
-extern class_mockup *mockup_global_ptr;
+/* Version A: Create a local object that is destroyed when out of scope */
+#define CREATE_MOCK(name) class_mockup name
 
-#define CREATE_MOCK(name) class_mockup name; mockup_global_ptr = &name;
+/* Version B: Allocate an object that will be only explicitly deallocated */
+#define CREATE_PERSISTENT_MOCK() new class_mockup
+#define DESTROY_PERSISTENT_MOCK() {if(mockup_global_ptr) delete mockup_global_ptr;}
 
 #endif /* mockup_h */

tests/data/gmock_test/test_add_function_with_unnamed_arg/mockup.cc

@@ -1,12 +1,12 @@
 #include "mockup.h"
 
-class_mockup *mockup_global_ptr = 0;
+mock_ptr_t mockup_global_ptr = nullptr;
 
 
 extern "C" {
 
 float my_func(float unnamed1){
- if(0 != mockup_global_ptr)
+ if(mockup_global_ptr)
  return mockup_global_ptr->my_func(unnamed1);
  else
  return (float)0;

tests/data/gmock_test/test_add_function_with_unnamed_arg/mockup.h

@@ -6,14 +6,23 @@
 extern "C" {
 } /* extern "C" */
 
+class class_mockup;
+typedef class_mockup* mock_ptr_t;
+extern mock_ptr_t mockup_global_ptr;
+
 class class_mockup {
 
- public:
- MOCK_METHOD((float), my_func, (float));
+ public:
+ class_mockup() { mockup_global_ptr = this; }
+ ~class_mockup() { mockup_global_ptr = nullptr; }
+ MOCK_METHOD((float), my_func, (float));
 }; /* class_mockup */
 
-extern class_mockup *mockup_global_ptr;
+/* Version A: Create a local object that is destroyed when out of scope */
+#define CREATE_MOCK(name) class_mockup name
 
-#define CREATE_MOCK(name) class_mockup name; mockup_global_ptr = &name;
+/* Version B: Allocate an object that will be only explicitly deallocated */
+#define CREATE_PERSISTENT_MOCK() new class_mockup
+#define DESTROY_PERSISTENT_MOCK() {if(mockup_global_ptr) delete mockup_global_ptr;}
 
 #endif /* mockup_h */

tests/data/gmock_test/test_empty_templates/mockup.cc

@@ -1,6 +1,6 @@
 #include "mockup.h"
 
-class_mockup *mockup_global_ptr = 0;
+mock_ptr_t mockup_global_ptr = nullptr;
 
 
 extern "C" {

tests/data/gmock_test/test_empty_templates/mockup.h

@@ -6,13 +6,22 @@
 extern "C" {
 } /* extern "C" */
 
+class class_mockup;
+typedef class_mockup* mock_ptr_t;
+extern mock_ptr_t mockup_global_ptr;
+
 class class_mockup {
 
- public:
+ public:
+ class_mockup() { mockup_global_ptr = this; }
+ ~class_mockup() { mockup_global_ptr = nullptr; }
 }; /* class_mockup */
 
-extern class_mockup *mockup_global_ptr;
+/* Version A: Create a local object that is destroyed when out of scope */
+#define CREATE_MOCK(name) class_mockup name
 
-#define CREATE_MOCK(name) class_mockup name; mockup_global_ptr = &name;
+/* Version B: Allocate an object that will be only explicitly deallocated */
+#define CREATE_PERSISTENT_MOCK() new class_mockup
+#define DESTROY_PERSISTENT_MOCK() {if(mockup_global_ptr) delete mockup_global_ptr;}
 
 #endif /* mockup_h */

tests/data/gmock_test/test_mini_c_gmock/mockup.cc

@@ -1,6 +1,6 @@
 #include "mockup.h"
 
-class_mockup *mockup_global_ptr = 0;
+mock_ptr_t mockup_global_ptr = nullptr;
 
 int a_y1;
 int a_y4;
@@ -11,50 +11,50 @@ const int const_array[3] = {0};
 extern "C" {
 
 int a_get_y2(){
- if(0 != mockup_global_ptr)
+ if(mockup_global_ptr)
  return mockup_global_ptr->a_get_y2();
  else
  return (int)0;
 } /* a_get_y2 */
 
 int a_get_y3_and_set_u5(int u5){
- if(0 != mockup_global_ptr)
+ if(mockup_global_ptr)
  return mockup_global_ptr->a_get_y3_and_set_u5(u5);
  else
  return (int)0;
 } /* a_get_y3_and_set_u5 */
 
 int a_get_y5(){
- if(0 != mockup_global_ptr)
+ if(mockup_global_ptr)
  return mockup_global_ptr->a_get_y5();
  else
  return (int)0;
 } /* a_get_y5 */
 
 void a_get_y6(int * y6){
- if(0 != mockup_global_ptr)
+ if(mockup_global_ptr)
  mockup_global_ptr->a_get_y6(y6);
 } /* a_get_y6 */
 
 int c_get_y3_and_set_u5(int u5){
- if(0 != mockup_global_ptr)
+ if(mockup_global_ptr)
  return mockup_global_ptr->c_get_y3_and_set_u5(u5);
  else
  return (int)0;
 } /* c_get_y3_and_set_u5 */
 
 void c_set_u2(int u2){
- if(0 != mockup_global_ptr)
+ if(mockup_global_ptr)
  mockup_global_ptr->c_set_u2(u2);
 } /* c_set_u2 */
 
 void c_set_u3_and_u4(int u3, int u4){
- if(0 != mockup_global_ptr)
+ if(mockup_global_ptr)
  mockup_global_ptr->c_set_u3_and_u4(u3, u4);
 } /* c_set_u3_and_u4 */
 
 void c_set_u6(int u6){
- if(0 != mockup_global_ptr)
+ if(mockup_global_ptr)
  mockup_global_ptr->c_set_u6(u6);
 } /* c_set_u6 */
 }

tests/data/gmock_test/test_mini_c_gmock/mockup.h

@@ -8,21 +8,30 @@ extern "C" {
 #include "c.h"
 } /* extern "C" */
 
+class class_mockup;
+typedef class_mockup* mock_ptr_t;
+extern mock_ptr_t mockup_global_ptr;
+
 class class_mockup {
 
- public:
- MOCK_METHOD((int), a_get_y2, ());
- MOCK_METHOD((int), a_get_y3_and_set_u5, (int));
- MOCK_METHOD((int), a_get_y5, ());
- MOCK_METHOD((void), a_get_y6, (int *));
- MOCK_METHOD((int), c_get_y3_and_set_u5, (int));
- MOCK_METHOD((void), c_set_u2, (int));
- MOCK_METHOD((void), c_set_u3_and_u4, (int, int));
- MOCK_METHOD((void), c_set_u6, (int));
+ public:
+ class_mockup() { mockup_global_ptr = this; }
+ ~class_mockup() { mockup_global_ptr = nullptr; }
+ MOCK_METHOD((int), a_get_y2, ());
+ MOCK_METHOD((int), a_get_y3_and_set_u5, (int));
+ MOCK_METHOD((int), a_get_y5, ());
+ MOCK_METHOD((void), a_get_y6, (int *));
+ MOCK_METHOD((int), c_get_y3_and_set_u5, (int));
+ MOCK_METHOD((void), c_set_u2, (int));
+ MOCK_METHOD((void), c_set_u3_and_u4, (int, int));
+ MOCK_METHOD((void), c_set_u6, (int));
 }; /* class_mockup */
 
-extern class_mockup *mockup_global_ptr;
+/* Version A: Create a local object that is destroyed when out of scope */
+#define CREATE_MOCK(name) class_mockup name
 
-#define CREATE_MOCK(name) class_mockup name; mockup_global_ptr = &name;
+/* Version B: Allocate an object that will be only explicitly deallocated */
+#define CREATE_PERSISTENT_MOCK() new class_mockup
+#define DESTROY_PERSISTENT_MOCK() {if(mockup_global_ptr) delete mockup_global_ptr;}
 
 #endif /* mockup_h */

tests/data/mini_c_test/b.c

@@ -35,3 +35,10 @@ void b_step(void){
 
  local_extern(2);
 }
+
+int x1 = 1;
+
+int get_x1(void)
+{
+ return x1;
+}