Merge lp:~smspillaz/compiz-libcompizconfig/compiz-libcompizconfig.ccs-object into lp:~compiz-team/compiz-libcompizconfig/0.9.8

[Sam Spilsbury]

This is all about bug 990690.

!! - It probably isn't a good idea to test this branch in isolation, as it is part of a pipeline to get compiz-libcompizconfig under test. If you want to test the result of this work, you should probably look at testing

lp:~smspillaz/compiz-libcompizconfig/compiz-libcompizconfig.mock-context
lp:~smspillaz/compiz-compizconfig-python/compiz-compizconfig-python.setting-api
lp:~smspillaz/compiz-compizconfig-gconf/compiz-compizconfig-gconf.adapt-to-new-interfaces

.. that's all !!

This branch introduces some preliminary work in a series of branches to get libcompizconfig under test. In order to test the objects properly, we need to abstract away their interfaces into replacable structs so you can test the interaction between the various classes.

This would be awkward to do correctly if we didn't have a suitable object system to handle interface implementation, referencing, private storage etc.

As such, a new struct CCSObject is introduced. It is similar in design to GObject, but with a much smaller feature set centered mostly around the handling of interfaces and composition / indirection. A type registrar is also included (also very simple).

Tests are included.

Unmerged revisions

433. By Sam Spilsbury on 2012-04-28

Added a simple type registrar

432. By Sam Spilsbury on 2012-04-28

Added a ccsObjectFinalize function which frees everything in CCSObject storage

431. By Sam Spilsbury on 2012-04-28

Added tests for CCSObject

430. By Sam Spilsbury on 2012-04-28

Added some testing code

429. By Sam Spilsbury on 2012-04-28

Added CCSObject

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2011-07-07 12:23:21 +0000
+++ CMakeLists.txt	2012-04-28 18:57:19 +0000
@@ -141,6 +141,7 @@
 add_subdirectory (src)
 add_subdirectory (include)
 add_subdirectory (cmake)
+add_subdirectory (tests)
 
 compiz_print_configure_header ("CompizConfig Library")
 compiz_color_message ("\n${_escape}[4mOptional features:${_escape}[0m\n")

=== modified file 'include/ccs.h'
--- include/ccs.h	2011-08-20 19:03:37 +0000
+++ include/ccs.h	2012-04-28 18:57:19 +0000
@@ -19,10 +19,14 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  */
 
-
 #ifndef _CSS_H
 #define _CSS_H
 
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
 #define D_NONE   0
 #define D_NORMAL 1
 #define D_FULL   2
@@ -124,6 +128,60 @@
 CCSLIST_HDR (StrRestriction, CCSStrRestriction)
 CCSLIST_HDR (StrExtension, CCSStrExtension)
 
+typedef struct _CCSInterface CCSInterface; /* Dummy typedef */
+typedef struct _CCSPrivate CCSPrivate; /* Dummy typedef */
+typedef struct _CCSObject CCSObject;
+
+struct _CCSObject
+{
+    CCSPrivate *priv; /* Private pointer for object storage */
+
+    const CCSInterface **interfaces; /* An array of interfaces that this object implements */
+    int          *interface_types; /* An array of interface types */
+    unsigned int n_interfaces;
+
+    unsigned int refcnt; /* Reference count of this object */
+};
+
+Bool
+ccsObjectAddInterface (CCSObject *object, const CCSInterface *interface, int interface_type);
+
+Bool
+ccsObjectRemoveInterface (CCSObject *object, int interface_type);
+
+const CCSInterface * ccsObjectGetInterface (CCSObject *object, int interface_type);
+
+void
+ccsObjectRef (CCSObject *object);
+
+void
+ccsObjectUnref (CCSObject *object);
+
+CCSPrivate *
+ccsObjectGetPrivate (CCSObject *object);
+
+void
+ccsObjectSetPrivate (CCSObject *object, CCSPrivate *priv);
+
+void
+ccsObjectFinalize (CCSObject *object);
+
+unsigned int
+ccsAllocateType ();
+
+#define GET_INTERFACE_TYPE(Interface) \
+    ccs##Interface##GetType ();
+
+#define INTERFACE_TYPE(Interface) \
+    inline unsigned int ccs##Interface##GetType () \
+    { \
+	static unsigned int   type_id = 0; \
+	if (!type_id) \
+	    type_id = ccsAllocateType (); \
+	 \
+	return type_id; \
+    }
+
 /**
  * reference counting
  * 
@@ -913,4 +971,8 @@
 /* Checks if settings need to be constrained */
 Bool ccsContextNeedsConstraining (CCSContext *context);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2011-10-15 07:28:45 +0000
+++ src/CMakeLists.txt	2012-04-28 18:57:19 +0000
@@ -35,6 +35,9 @@
 	 ${LIBCOMPIZCONFIG_FILES}
 	 compizconfig.pb.cc
 	)
+    set (LIBCOMPIZCONFIG_LIBRARIES
+	 ${LIBCOMPIZCONFIG_LIBRARIES}
+	 protobuf)
     add_definitions (
 	    -DUSE_PROTOBUF
     )

=== modified file 'src/main.c'
--- src/main.c	2011-11-10 00:58:18 +0000
+++ src/main.c	2012-04-28 18:57:19 +0000
@@ -39,6 +39,134 @@
 #include "ccs-private.h"
 #include "iniparser.h"
 
+/* CCSObject stuff */
+Bool
+ccsObjectAddInterface (CCSObject *object, const CCSInterface *interface, int interface_type)
+{
+    object->n_interfaces++;
+    object->interfaces = realloc (object->interfaces, object->n_interfaces * sizeof (CCSInterface *));
+
+    if (!object->interfaces)
+    {
+	object->n_interfaces--;
+	return FALSE;
+    }
+
+    object->interface_types = realloc (object->interface_types, object->n_interfaces * sizeof (int));
+
+    if (!object->interface_types)
+    {
+	object->n_interfaces--;
+	return FALSE;
+    }
+
+    object->interfaces[object->n_interfaces - 1] = interface;
+    object->interface_types[object->n_interfaces - 1] = interface_type;
+
+    return TRUE;
+}
+
+Bool
+ccsObjectRemoveInterface (CCSObject *object, int interface_type)
+{
+    unsigned int i = 0;
+
+    if (!object->n_interfaces)
+	return FALSE;
+
+    const void *o = *object->interfaces;
+    int        *type = object->interface_types;
+
+    for (; i < object->n_interfaces; i++, o++, type++)
+    {
+	if (object->interface_types[i] == interface_type)
+	    break;
+    }
+
+    if (i >= object->n_interfaces)
+	return FALSE;
+
+    /* Now clear this section and move everything back */
+    object->interfaces[i] = NULL;
+
+    i++;
+
+    void *oLast = (void *) o;
+    int *typeLast = type;
+
+    o++;
+    type++;
+
+    memmove (oLast, o, (object->n_interfaces - i) * sizeof (CCSInterface *));
+    memmove (typeLast, type, (object->n_interfaces - i) * sizeof (int));
+
+    object->n_interfaces--;
+    object->interfaces = realloc (object->interfaces, object->n_interfaces * sizeof (CCSInterface *));
+    object->interface_types = realloc (object->interface_types, object->n_interfaces * sizeof (int));
+
+    return TRUE;
+}
+
+const CCSInterface *
+ccsObjectGetInterface (CCSObject *object, int interface_type)
+{
+    unsigned int i = 0;
+
+    for (; i < object->n_interfaces; i++)
+    {
+	if (object->interface_types[i] == interface_type)
+	    return object->interfaces[i];
+    }
+
+    return NULL;
+}
+
+CCSPrivate *
+ccsObjectGetPrivate (CCSObject *object)
+{
+    return object->priv;
+}
+
+void
+ccsObjectSetPrivate (CCSObject *object, CCSPrivate *priv)
+{
+    object->priv = priv;
+}
+
+void
+ccsObjectFinalize (CCSObject *object)
+{
+    if (object->priv)
+    {
+	free (object->priv);
+	object->priv = NULL;
+    }
+
+    if (object->interfaces)
+    {
+	free (object->interfaces);
+	object->interfaces = NULL;
+    }
+
+    if (object->interface_types)
+    {
+	free (object->interface_types);
+	object->interface_types = NULL;
+    }
+
+    object->n_interfaces = 0;
+}
+
+unsigned int
+ccsAllocateType ()
+{
+    static unsigned int start = 0;
+
+    start++;
+
+    return start;
+}
+
 Bool basicMetadata = FALSE;
 
 void
@@ -592,6 +720,18 @@
 CCSREF (StrRestriction, CCSStrRestriction)
 CCSREF (StrExtension, CCSStrExtension)
 
+#define CCSREF_OBJ(type,dtype) \
+    void ccs##type##Ref (dtype *d)  \
+    { \
+	((CCSObject *) d)->refcnt++; \
+    } \
+    void ccs##type##Unref (dtype *d) \
+    { \
+	((CCSObject *) d)->refcnt--; \
+	if (((CCSObject *) d)->refcnt == 0) \
+	    ccsFree##type (d); \
+    } \
+
 static void *
 openBackend (char *backend)
 {

=== added directory 'tests'
=== added file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ tests/CMakeLists.txt	2012-04-28 18:57:19 +0000
@@ -0,0 +1,56 @@
+# Build Google Test and make its headers known
+find_package (GTest)
+
+if (NOT GTEST_FOUND)
+
+    # Check for google test and build it locally
+    set (GTEST_ROOT_DIR
+	"/usr/src/gtest" # Default value, adjustable by user with e.g., ccmake
+	CACHE
+	PATH
+	"Path to Google test srcs"
+    )
+
+    find_path (GTEST_INCLUDE_DIR gtest/gtest.h)
+
+    if (GTEST_INCLUDE_DIR)
+	#FIXME - hardcoded is bad!
+	add_subdirectory (${GTEST_ROOT_DIR}
+		      gtest)
+    endif(GTEST_INCLUDE_DIR)
+
+    set (GTEST_BOTH_LIBRARIES gtest gtest_main)
+    set (GTEST_FOUND TRUE)
+
+endif (NOT GTEST_FOUND)
+
+find_library (GMOCK_LIBRARY gmock)
+find_library (GMOCK_MAIN_LIBRARY gmock_main)
+
+if (NOT GMOCK_LIBRARY OR NOT GMOCK_MAIN_LIBRARY OR NOT GTEST_FOUND)
+  message ("Google Mock and Google Test not found - cannot build tests!")
+  set (COMPIZ_BUILD_TESTING OFF)
+endif (NOT GMOCK_LIBRARY OR NOT GMOCK_MAIN_LIBRARY OR NOT GTEST_FOUND)
+
+include_directories (${GTEST_INCLUDE_DIRS})
+include_directories (${CMAKE_SOURCE_DIR}/include)
+link_directories (${CMAKE_INSTALL_PREFIX}/lib)
+
+add_executable (test-ccs-object
+		${CMAKE_CURRENT_SOURCE_DIR}/test-ccs-object.cpp)
+
+if (HAVE_PROTOBUF)
+    set (LIBCOMPIZCONFIG_LIBRARIES
+	 ${LIBCOMPIZCONFIG_LIBRARIES}
+	 protobuf)
+endif (HAVE_PROTOBUF)
+
+target_link_libraries (test-ccs-object
+		       ${GTEST_BOTH_LIBRARIES}
+		       ${GMOCK_LIBRARY}
+		       ${GMOCK_MAIN_LIBRARY}
+		       ${CMAKE_THREAD_LIBS_INIT}
+		       ${LIBCOMPIZCONFIG_LIBRARIES}
+		       compizconfig)
+
+gtest_add_tests (test-ccs-object "" ${CMAKE_CURRENT_SOURCE_DIR}/test-ccs-object.cpp)

=== added file 'tests/test-ccs-object.cpp'
--- tests/test-ccs-object.cpp	1970-01-01 00:00:00 +0000
+++ tests/test-ccs-object.cpp	2012-04-28 18:57:19 +0000
@@ -0,0 +1,207 @@
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <ccs.h>
+#include <cstdio>
+
+using ::testing::_;
+using ::testing::Return;
+
+class CCSObjectTest :
+    public ::testing::Test
+{
+};
+
+struct TestingObjectWrapper
+{
+    CCSObject object;
+};
+
+typedef void (*dummyFunc) (void);
+
+struct DummyInterface
+{
+    dummyFunc dummy;
+};
+
+struct Dummy2Interface
+{
+    dummyFunc dummy;
+};
+
+class GoogleMockDummyInterface
+{
+    public:
+
+	virtual ~GoogleMockDummyInterface () {};
+
+	virtual void dummyFunc () = 0;
+	virtual void freeTestingObjectWrapper (TestingObjectWrapper *) = 0;
+};
+
+class GoogleMockDummy :
+    public GoogleMockDummyInterface
+{
+    public:
+
+	MOCK_METHOD0 (dummyFunc, void ());
+	MOCK_METHOD1 (freeTestingObjectWrapper, void (TestingObjectWrapper *));
+    public:
+
+	static void thunkDummyFunc () { return _mockDummy.dummyFunc (); }
+	static GoogleMockDummy _mockDummy;
+};
+
+GoogleMockDummy GoogleMockDummy::_mockDummy;
+
+const struct DummyInterface SomeDummyInterface =
+{
+    GoogleMockDummy::thunkDummyFunc
+};
+
+#define CCS_INTERFACE_TYPE_DUMMY GET_INTERFACE_TYPE (DummyInterface)
+#define CCS_INTERFACE_TYPE_DUMMY2 GET_INTERFACE_TYPE (Dummy2Interface)
+
+INTERFACE_TYPE (DummyInterface)
+INTERFACE_TYPE (Dummy2Interface)
+
+TEST(CCSObjectTest, TestTypeAllocation)
+{
+    unsigned int i = CCS_INTERFACE_TYPE_DUMMY;
+    unsigned int j = CCS_INTERFACE_TYPE_DUMMY;
+    unsigned int k = CCS_INTERFACE_TYPE_DUMMY2;
+
+    EXPECT_EQ (i, 1);
+    EXPECT_EQ (j ,1);
+    EXPECT_EQ (k, 2);
+}
+
+TEST(CCSObjectTest, InterfaceAdd)
+{
+    TestingObjectWrapper *to = (TestingObjectWrapper *) calloc (1, sizeof (TestingObjectWrapper));
+
+    ccsObjectAddInterface ((CCSObject *) to, (const CCSInterface *) &SomeDummyInterface, 1);
+
+    EXPECT_EQ (*((CCSObject *) to)->interfaces, (const CCSInterface *) (&SomeDummyInterface));
+    EXPECT_EQ (((CCSObject *) to)->n_interfaces, 1);
+    EXPECT_EQ (*((CCSObject *) to)->interface_types, 1);
+
+    free (to);
+}
+
+TEST(CCSObjectTest, InterfaceRemove)
+{
+    TestingObjectWrapper *to = (TestingObjectWrapper *) calloc (1, sizeof (TestingObjectWrapper));
+
+    ccsObjectAddInterface ((CCSObject *) to, (const CCSInterface *) &SomeDummyInterface, 1);
+
+    EXPECT_EQ (*((CCSObject *) to)->interfaces, (const CCSInterface *) (&SomeDummyInterface));
+    EXPECT_EQ (((CCSObject *) to)->n_interfaces, 1);
+    EXPECT_EQ (*((CCSObject *) to)->interface_types, 1);
+
+    ccsObjectRemoveInterface ((CCSObject *) to, 1);
+
+    EXPECT_EQ (NULL, ((CCSObject *) to)->interfaces);
+    EXPECT_EQ (((CCSObject *) to)->n_interfaces, 0);
+    EXPECT_EQ (NULL, ((CCSObject *) to)->interface_types);
+
+    free (to);
+}
+
+TEST(CCSObjectTest, InterfaceFetchCall)
+{
+    TestingObjectWrapper *to = (TestingObjectWrapper *) calloc (1, sizeof (TestingObjectWrapper));
+
+    ccsObjectAddInterface ((CCSObject *) to, (const CCSInterface *) &SomeDummyInterface, 1);
+
+    EXPECT_EQ (*((CCSObject *) to)->interfaces, (const CCSInterface *) (&SomeDummyInterface));
+    EXPECT_EQ (((CCSObject *) to)->n_interfaces, 1);
+    EXPECT_EQ (*((CCSObject *) to)->interface_types, 1);
+
+    const DummyInterface *myDummyInterface = (const DummyInterface *) ccsObjectGetInterface ((CCSObject *) to, 1);
+
+    EXPECT_CALL (GoogleMockDummy::_mockDummy, dummyFunc ());
+
+    (*myDummyInterface->dummy) ();
+
+    ccsObjectRemoveInterface ((CCSObject *) to, 1);
+
+    EXPECT_EQ (NULL, ((CCSObject *) to)->interfaces);
+    EXPECT_EQ (((CCSObject *) to)->n_interfaces, 0);
+    EXPECT_EQ (NULL, ((CCSObject *) to)->interface_types);
+
+    free (to);
+}
+
+TEST(CCSObjectTest, SetPrivateGetPrivate)
+{
+    TestingObjectWrapper *to = (TestingObjectWrapper *) calloc (1, sizeof (TestingObjectWrapper));
+
+    int i = 1;
+
+    ccsObjectSetPrivate ((CCSObject *) to, (CCSPrivate *) &i);
+
+    CCSPrivate *p = ccsObjectGetPrivate ((CCSObject *) to);
+
+    EXPECT_EQ (&i, (int *) p);
+    EXPECT_EQ (i, (*((int *) p)));
+}
+
+void ccsFreeTestingObjectWrapper (TestingObjectWrapper *wrapper)
+{
+    GoogleMockDummy::_mockDummy.freeTestingObjectWrapper (wrapper);
+}
+
+#define CCSREF_OBJ(type,dtype) \
+    void ccs##type##Ref (dtype *d)  \
+    { \
+	((CCSObject *) d)->refcnt++; \
+    } \
+    void ccs##type##Unref (dtype *d) \
+    { \
+	((CCSObject *) d)->refcnt--; \
+	if (((CCSObject *) d)->refcnt == 0) \
+	    ccsFree##type (d); \
+    } \
+
+CCSREF_HDR(TestingObjectWrapper, TestingObjectWrapper);
+CCSREF_OBJ(TestingObjectWrapper, TestingObjectWrapper);
+
+TEST(CCSObjectTest, TestRefUnrefFreesObject)
+{
+    TestingObjectWrapper *to = (TestingObjectWrapper *) calloc (1, sizeof (TestingObjectWrapper));
+
+    ccsTestingObjectWrapperRef (to);
+
+    EXPECT_CALL (GoogleMockDummy::_mockDummy, freeTestingObjectWrapper (to));
+
+    ccsTestingObjectWrapperUnref (to);
+}
+
+TEST(CCSObjectTest, TestFinalizeFreesEverything)
+{
+    TestingObjectWrapper *to = (TestingObjectWrapper *) calloc (1, sizeof (TestingObjectWrapper));
+
+    ccsObjectAddInterface ((CCSObject *) to, (const CCSInterface *) &SomeDummyInterface, 1);
+
+    EXPECT_EQ (*((CCSObject *) to)->interfaces, (const CCSInterface *) (&SomeDummyInterface));
+    EXPECT_EQ (((CCSObject *) to)->n_interfaces, 1);
+    EXPECT_EQ (*((CCSObject *) to)->interface_types, 1);
+
+    int *i = (int *) malloc (sizeof (int));
+
+    *i = 1;
+
+    ccsObjectSetPrivate ((CCSObject *) to, (CCSPrivate *) i);
+
+    CCSPrivate *p = ccsObjectGetPrivate ((CCSObject *) to);
+
+    EXPECT_EQ (i, (int *) p);
+    EXPECT_EQ (*i, (*((int *) p)));
+
+    ccsObjectFinalize ((CCSObject *) to);
+
+    EXPECT_EQ (NULL, ((CCSObject *) to)->priv);
+    EXPECT_EQ (NULL, ((CCSObject *) to)->interfaces);
+    EXPECT_EQ (((CCSObject *) to)->n_interfaces, 0);
+    EXPECT_EQ (NULL, ((CCSObject *) to)->interface_types);
+}