optimized the class definition stuff, add instanceOf and isObject methods and ad…

…d assertion macros to use these checks

+2011-11-17 13:00:11 +0100 Georg Hopp 
+
+	* optimized the class definition stuff, add instanceOf and isObject methods and add assertion macros to use these checks (HEAD, master)
+
+2011-11-17 08:33:56 +0100 Georg Hopp 
+
+	* remove obsolete non conformant tests for crypt
+
+2011-11-17 08:31:24 +0100 Georg Hopp 
+
+	* always run checks under valgrind now. @TODO Let configure set the environment variable only if valgrind is installed.
+
+2011-11-17 08:29:25 +0100 Georg Hopp 
+
+	* add tests form crypt class @TODO: add assertion on length
+
+2011-11-17 08:27:29 +0100 Georg Hopp 
+
+	* add new assertion macros
+
 2011-11-16 19:32:44 +0100 Georg Hopp 
 
-	* i had to remove the cool plugin stuff for my tests, as i found no working way to use this with autotools. Now all works. (HEAD, master)
+	* i had to remove the cool plugin stuff for my tests, as i found no working way to use this with autotools. Now all works. (origin/master, origin/HEAD)
 
 2011-11-16 18:14:51 +0100 Georg Hopp 
 
@@ -8,7 +28,7 @@
 
 2011-11-16 09:09:32 +0100 Georg Hopp 
 
-	* work on test <<framework>> (origin/master, origin/HEAD)
+	* work on test <<framework>>
 
 2011-11-15 21:26:08 +0100 Georg Hopp 
 

@@ -22,6 +22,20 @@
 #include <sys/types.h>
 #include <json/json.h>
 
+#define CCLASS_MAGIC    0xFEFE
+
+#define INIT_CCLASS(name, jsonConst, toJson) \
+    static const struct CCLASS _##name = { \
+        CCLASS_MAGIC, \
+        sizeof(struct name), \
+        (ctor)__construct, \
+        (jCtor)jsonConst, \
+        (dtor)__destruct, \
+        (jTo)toJson \
+    }; const struct CCLASS * const name = &_##name
+
+
+
 typedef void (* ctor)(void *, va_list *);
 typedef void (* dtor)(void *);
 typedef void (* jCtor)(void *, struct json_object *);
@@ -29,24 +43,22 @@ typedef struct json_object * (* jTo)(void *);
 
 
 struct CCLASS {
+    const int magic;
     size_t size;
     void (* __construct)(void * _this, va_list * params);
     void (* __jsonConst)(void * _this, struct json_object * json);
     void (* __destruct)(void * _this);
     struct json_object * (* __toJson)(void * _this);
 };
+#define CCLASS_PTR_SIZE     sizeof(struct CCLASS *)
+#define CCLASS_SIZE         sizeof(struct CCLASS)
 
-void *
-new(const void * _class, ...);
-
-void *
-newFromJson(const void * _class, struct json_object * json);
-
-void 
-delete(void * _object);
-
-struct json_object *
-toJson(void * _object);
+void *               new(const void * _class, ...);
+void *               newFromJson(const void * _class, struct json_object * json);
+void                 delete(void * _object);
+struct json_object * toJson(void * _object);
+int                  isObject(void * _object);
+int                  instanceOf(const void * _class, void * _object);
 
 #endif//__CCLASS_H__
 

@@ -82,4 +82,20 @@ toJson(void * _object)
     return NULL;
 }
 
+int
+isObject(void * _object)
+{
+    const struct CCLASS ** class = _object;
+
+    return (_object && (*class) && CCLASS_MAGIC == (*class)->magic);
+}
+
+int
+instanceOf(const void * _class, void * _object)
+{
+    const struct CCLASS ** class = _object;
+
+    return (_class == *class);
+}
+
 // vim: set et ts=4 sw=4:

@@ -56,16 +56,7 @@ __destruct(struct CRYPT * _this)
     mcrypt_module_close(_this->mcrypt);
 }
 
-static const
-struct CCLASS _crypt = {
-    sizeof(struct CRYPT),
-    (ctor)__construct,
-    NULL,
-    (dtor)__destruct,
-    NULL
-};
-
-const struct CCLASS * const CRYPT = &_crypt;
+INIT_CCLASS(CRYPT, NULL, NULL);
 
 void *
 crypt_createIv(struct CRYPT * _this)

@@ -132,15 +132,6 @@ __toJson(struct DYNTYPE * _this)
     return json;
 }
 
-static const
-struct CCLASS _dyntype = {
-    sizeof(struct DYNTYPE),
-    (ctor)__construct,
-    (jCtor)__jsonConst,
-    (dtor)__destruct,
-    (jTo)__toJson
-};
-
-const struct CCLASS * const DYNTYPE = &_dyntype;
+INIT_CCLASS(DYNTYPE, __jsonConst, __toJson);
 
 // vim: set et ts=4 sw=4:

@@ -84,16 +84,7 @@ __toJson(struct DYNTYPE_HASH * _this)
     return json;
 }
 
-static const
-struct CCLASS _dyntype_hash = {
-    sizeof(struct DYNTYPE_HASH),
-    (ctor)__construct,
-    (jCtor)__jsonConst,
-    (dtor)__destruct,
-    (jTo)__toJson
-};
-
-const struct CCLASS * const DYNTYPE_HASH = &_dyntype_hash;
+INIT_CCLASS(DYNTYPE_HASH, __jsonConst, __toJson);
 
 static
 void

@@ -69,16 +69,7 @@ __toJson(struct PACKET * _this)
     return json;
 }
 
-static const
-struct CCLASS _packet = {
-    sizeof(struct PACKET),
-    (ctor)__construct,
-    (jCtor)__jsonConst,
-    (dtor)__destruct,
-    (jTo)__toJson
-};
-
-const struct CCLASS * const PACKET = &_packet;
+INIT_CCLASS(PACKET, __jsonConst, __toJson);
 
 struct DYNTYPE *
 packet_getHeader(

@@ -10,23 +10,28 @@ const char testname[] = "cclassTest";
 struct MOCK_CLASS * mock = NULL;
 
 static
-void
+int
 __setUp()
 {
     mock = NULL;
     _reset();
+
+    return TEST_OK;
 }
-void (* const setUp)() = __setUp;
+int (* const setUp)() = __setUp;
 
 static
-void
+int
 __tearDown()
 {
     if (NULL != mock) {
+        ASSERT_OBJECT(mock);
         delete(&mock);
     }
+
+    return TEST_OK;
 }
-void (* const tearDown)() = __tearDown;
+int (* const tearDown)() = __tearDown;
 
 static
 int
@@ -34,7 +39,7 @@ testNew(void)
 {
     mock = new(MOCK_CLASS, 123);
 
-    ASSERT_NOT_NULL(mock);
+    ASSERT_OBJECT_NOT_NULL(mock);
     ASSERT_EQUAL(1, _called);
     ASSERT_EQUAL(123, mock_class_getValue(mock));
 
@@ -50,7 +55,7 @@ testNewFromJson(void)
     mock = newFromJson(MOCK_CLASS, json);
     json_object_put(json);
 
-    ASSERT_NOT_NULL(mock);
+    ASSERT_OBJECT_NOT_NULL(mock);
     ASSERT_EQUAL(1, _called);
     ASSERT_EQUAL(123, mock_class_getValue(mock));
 
@@ -82,9 +87,11 @@ testToJson(void)
     mock = new(MOCK_CLASS, 123);
     int value;
 
+    _reset();
     json = toJson(mock);
 
     ASSERT_NOT_NULL(json);
+
     value = json_object_get_int(json);
     json_object_put(json);
 

@@ -16,20 +16,29 @@ struct CRYPT * crypt  = NULL;
 
 
 static
-void
+int
 __setUp()
 {
     crypt = new(CRYPT, MCRYPT_RIJNDAEL_256, MCRYPT_CFB);
+
+    ASSERT_INSTANCE_OF(CRYPT, crypt);
+
+    return TEST_OK;
 }
-void (* const setUp)() = __setUp;
+int (* const setUp)() = __setUp;
 
 static
-void
+int
 __tearDown()
 {
-    delete(&crypt);
+    if (NULL != crypt) {
+        ASSERT_OBJECT(crypt);
+        delete(&crypt);
+    }
+
+    return TEST_OK;
 }
-void (* const tearDown)() = __tearDown;
+int (* const tearDown)() = __tearDown;
 
 static
 int

@@ -48,16 +48,7 @@ __toJson(struct MOCK_CLASS * _this)
     return json;
 }
 
-static const
-struct CCLASS _mock_class = {
-    sizeof(struct MOCK_CLASS),
-    (ctor)__construct,
-    (jCtor)__jsonConst,
-    (dtor)__destruct,
-    (jTo)__toJson
-};
-
-const struct CCLASS * const MOCK_CLASS = &_mock_class;
+INIT_CCLASS(MOCK_CLASS, __jsonConst, __toJson);
 
 /**
  * ~~~ method implementations ~~~~~~~~

@@ -4,6 +4,8 @@
 #include <sys/types.h>
 
 #include "runtest.h"
+#include "token/cclass.h"
+
 
 #define TEST_OK_CHAR		'.'
 #define TEST_FAILED_CHAR	'F'
@@ -16,6 +18,30 @@ const char results[3] = {
     TEST_ERROR_CHAR
 };
 
+int
+isObjectNull(void * _object)
+{
+    const struct CCLASS ** class = _object;
+
+    ASSERT_OBJECT(_object);
+    ASSERT_MEM_NULL(_object + CCLASS_PTR_SIZE, (*class)->size - CCLASS_PTR_SIZE);
+
+    return TEST_OK;
+}
+
+int
+isMemNull(void * _mem, size_t size)
+{
+    size_t index;
+
+    ASSERT_NOT_NULL(_mem);
+
+    for(index=0; index<size && 0 == ((char *)_mem)[index]; index++);
+
+    ASSERT_EQUAL(size, index);
+
+    return TEST_OK;
+}
 
 int
 main(int argc, char * argv[])
@@ -29,16 +55,24 @@ main(int argc, char * argv[])
     printf("running tests for %s\n", testname);
 
     for (index=0; index<count; index++) {
-        int result;
+        int result, _setUp = 0;  // initialize setup to false
 
         if (NULL != setUp) {
-            setUp();
+            if (TEST_OK == (result = setUp())) {
+                _setUp = 1;  // we successfully set up the test
+            }
+        }
+
+        if (_setUp) {
+            result = tests[index]();
         }
 
-        result = tests[index]();
+        if (_setUp && NULL != tearDown) {
+            int _tearDown = tearDown();
 
-        if (NULL != setUp) {
-            tearDown();
+            if ((! TEST_OK == _tearDown) && TEST_OK == result) {
+                result = _tearDown;
+            }
         }
 
         switch (result) {

@@ -19,10 +19,18 @@ enum RESULT_TYPES {
     if(0 != memcmp((val1), (val2), (size))) return TEST_FAILED
 #define ASSERT_MEM_NOT_EQUAL(val1,val2,size) \
     if(0 == memcmp((val1), (val2), (size))) return TEST_FAILED
+#define ASSERT_MEM_NULL(val, size)  if (! isMemNull((val), (size))) return TEST_FAILED
+#define ASSERT_MEM_NOT_NULL(val, size) \
+    if (isMemNull((val), (size))) return TEST_FAILED
 #define ASSERT_STRING_EQUAL(val1,val2) \
     if(0 != strcmp((val1), (val2))) return TEST_FAILED
 #define ASSERT_STRING_NOT_EQUAL(val1,val2) \
     if(0 == strcmp((val1), (val2))) return TEST_FAILED
+#define ASSERT_OBJECT(val)          if (! isObject((val))) return TEST_FAILED
+#define ASSERT_OBJECT_NULL(val)     if (! isObjectNull((val))) return TEST_FAILED
+#define ASSERT_OBJECT_NOT_NULL(val) if (isObjectNull((val))) return TEST_FAILED
+#define ASSERT_INSTANCE_OF(class, val) \
+    if (! instanceOf((class), (val))) return TEST_FAILED
 
 
 typedef int (* const testfunc)(void);
@@ -32,8 +40,11 @@ extern const char testname[];
 extern testfunc tests[];
 extern const size_t count;
 
-extern void (* const setUp)();
-extern void (* const tearDown)();
+extern int (* const setUp)();
+extern int (* const tearDown)();
+
+int isMemNull(void * _mem, size_t size);
+int isObjectNull(void * _object);
 
 #endif//__RUNTEST_h__
 // vim: set et ts=4 sw=4: