Merge lp:~thomas-voss/compiz-core/fix-option into lp:compiz-core/0.9.5

[Thomas Voß]

Replaced custom implementation of a discriminated union type in CompOption::Value with boost::variant, introduced a set of unit tests and cleaned up CompOption::Value.

[Alan Griffiths (alan-griffiths)]

While I think symmetric operators (e.g. operator==) should be free functions this looks a lot cleaner.

(Member symmetric operator functions cannot support type conversions symmetrically, non-member ones can - in this case it doesn't matter, but it is preferable to follow the same style always.)

review: Approve

[Sam Spilsbury (smspillaz)]

Approving for now so we can get this merged, there are a few small things and some big things that we should beautify

21 +
22 +#include <boost/variant.hpp>
23 +

Whitespace

24 #include <vector>
25
26 class PrivateOption;
27 class PrivateValue;
28 class PrivateRestriction;
29 +
30 class CompAction;
31 class CompMatch;
32 class CompScreen;
33 @@ -54,12 +58,12 @@
34 TypeString,
35 TypeColor,
36 TypeAction,
37 + TypeMatch,
38 + TypeList,
39 TypeKey,
40 TypeButton,
41 TypeEdge,
42 TypeBell,
43 - TypeMatch,
44 - TypeList,

Seems redundant

212 -add_executable (compiz
213 - ${CMAKE_CURRENT_SOURCE_DIR}/region.cpp
214 +add_library (compiz_core
215 + ${CMAKE_CURRENT_SOURCE_DIR}/region.cpp
216 ${CMAKE_CURRENT_SOURCE_DIR}/atoms.cpp
217 - ${CMAKE_CURRENT_SOURCE_DIR}/main.cpp
218 ${CMAKE_CURRENT_SOURCE_DIR}/actions.cpp
219 ${CMAKE_CURRENT_SOURCE_DIR}/screen.cpp
220 ${CMAKE_CURRENT_SOURCE_DIR}/window.cpp
221 @@ -86,6 +85,10 @@
222 ${_bcop_sources}
223 )
224
225 +add_executable (compiz
226 + ${CMAKE_CURRENT_SOURCE_DIR}/main.cpp
227 +)
228 +

In general I agree with the idea of having a libcompiz, since it will be useful for other things later on, but I think for the tests we should strive to have each independently compiled module link to independent tests, rather than statically linking in compiz_core each time (executable bloat, increases link time, static initialization and destruction etc).

Of course in this case, CompOption has a hard dependency on CompScreen to dispatch option changes to plugin classes, so for now the refactoring required to abstract that out would be too large for this merge.

281 +add_subdirectory(tests)
282 +

Ideally follow the same directory layout practises

970 === added file 'src/tests/globals.h'
971 --- src/tests/globals.h 1970-01-01 00:00:00 +0000
972 +++ src/tests/globals.h 2012-01-16 14:53:32 +0000
973 @@ -0,0 +1,24 @@

This reminds me that globals.h really really needs to die.

There are a few parts where there need to be whitespace between the caller and the brackets, eg

foo () , foo <bar> () not
foo<b>()

review: Approve

=== modified file 'include/core/action.h'
--- include/core/action.h	2010-11-09 14:13:19 +0000
+++ include/core/action.h	2012-01-16 14:53:32 +0000
@@ -154,7 +154,7 @@
 
 	void copyState (const CompAction &action);
 
-	bool operator== (const CompAction& val);
+	bool operator== (const CompAction& val) const;
 	CompAction & operator= (const CompAction &action);
 
 	bool keyFromString (const CompString &str);

=== modified file 'include/core/option.h'
--- include/core/option.h	2011-10-31 13:51:00 +0000
+++ include/core/option.h	2012-01-16 14:53:32 +0000
@@ -29,11 +29,15 @@
 #define _COMPOPTION_H
 
 #include <core/string.h>
+
+#include <boost/variant.hpp>
+
 #include <vector>
 
 class PrivateOption;
 class PrivateValue;
 class PrivateRestriction;
+
 class CompAction;
 class CompMatch;
 class CompScreen;
@@ -54,12 +58,12 @@
 	    TypeString,
 	    TypeColor,
 	    TypeAction,
+	    TypeMatch,
+	    TypeList,
 	    TypeKey,
 	    TypeButton,
 	    TypeEdge,
 	    TypeBell,
-	    TypeMatch,
-	    TypeList,
 	    /* internal use only */
 	    TypeUnset
 	} Type;
@@ -69,61 +73,105 @@
 	 */
 	class Value {
 	    public:
+
+	  typedef boost::variant<
+	      bool,
+	      int,
+	      float,
+	      CompString,
+	      unsigned short*,
+	      boost::recursive_wrapper<CompAction>,
+	      boost::recursive_wrapper<CompMatch>,
+	      boost::recursive_wrapper<std::vector<Value> >
+	    > variant_type;
+
 		typedef std::vector<Value> Vector;
 
 	    public:
-		Value ();
-		Value (const Value &);
-		Value (const bool b);
-		Value (const int i);
-		Value (const float f);
-		Value (const unsigned short *color);
-		Value (const CompString& s);
-		Value (const char *s);
-		Value (const CompMatch& m);
-		Value (const CompAction& a);
-		Value (Type type, const Vector& l);
-		~Value ();
-
-		Type type () const;
-
-		void set (const bool b);
-		void set (const int i);
-		void set (const float f);
-		void set (const unsigned short *color);
-		void set (const CompString& s);
-		void set (const char *s);
-		void set (const CompMatch& m);
-		void set (const CompAction& a);
-		void set (Type type, const Vector& l);
-
-		bool               b ();
-		int                i ();
-		float              f ();
-		unsigned short*    c ();
-		CompString         s ();
-		CompMatch &        match ();
-		CompAction &       action ();
-		Type               listType ();
-		Vector &           list ();
-
-		bool operator== (const Value& val);
-		bool operator!= (const Value& val);
-		Value & operator= (const Value &val);
-
-		operator bool ();
-		operator int ();
-		operator float ();
-		operator unsigned short * ();
-		operator CompString ();
-		operator CompMatch & ();
-		operator CompAction & ();
-		operator CompAction * ();
-		operator Type ();
-		operator Vector & ();
+		Value () : mListType(TypeUnset)
+		{
+		}
+
+		template<typename T>
+		Value( const T & t ) : mListType(TypeUnset),
+		mValue(t)
+		{
+		}
+
+		~Value();
+
+		Type
+		type () const
+		{
+		    return static_cast<Type>(mValue.which());
+		}
+
+		Type
+		listType () const
+		{
+		    return mListType;
+		}
+
+		template<typename T>
+		void set (const T & t)
+		{
+		    mValue = t;
+		}
+
+		template<typename T>
+		const T & get () const
+		{
+		    return boost::get<T> (mValue);
+		}
+
+		void
+		set (Type t, const Vector & v);
+
+		bool
+		b () const;
+
+		int
+		i () const;
+
+		float
+		f () const;
+
+		unsigned short*
+		c () const;
+
+		const CompString &
+		s () const;
+
+		CompString &
+		s ();
+
+		const CompMatch &
+		match () const;
+
+		CompMatch &
+		match ();
+
+		const CompAction &
+		action () const;
+
+		CompAction &
+		action ();
+
+		const Vector &
+		list () const;
+
+		Vector &
+		list ();
+
+		bool
+		operator== (const Value & rhs) const;
+
+		bool
+		operator!= (const Value & rhs) const;
 
 	    private:
-		PrivateValue *priv;
+		Type mListType;
+		variant_type mValue;
 	};
 
 	/**

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2012-01-12 13:44:07 +0000
+++ src/CMakeLists.txt	2012-01-16 14:53:32 +0000
@@ -59,10 +59,9 @@
     ${CORE_MOD_LIBRARY_DIRS}
 )
 
-add_executable (compiz
-    ${CMAKE_CURRENT_SOURCE_DIR}/region.cpp
+add_library (compiz_core
+	${CMAKE_CURRENT_SOURCE_DIR}/region.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/atoms.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/main.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/actions.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/screen.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/window.cpp
@@ -86,6 +85,10 @@
     ${_bcop_sources}
 )
 
+add_executable (compiz
+    ${CMAKE_CURRENT_SOURCE_DIR}/main.cpp
+)
+
 # workaround for build race
 add_dependencies (compiz core-xml-file)
 
@@ -94,17 +97,33 @@
 	      PROPERTY CORE_MOD_LIBRARIES)
 
 target_link_libraries (
-    compiz ${COMPIZ_LIBRARIES} 
-    
-    m 
-    pthread 
-    dl
-    
-    compiz_string
-    compiz_timer
-    compiz_logmessage
-    compiz_pluginclasshandler
-#    ${CORE_MOD_LIBRARIES}
+    compiz_core 
+    
+    ${COMPIZ_LIBRARIES} 
+    
+    m 
+    pthread 
+    dl
+    
+    compiz_string
+    compiz_timer
+    compiz_logmessage
+    compiz_pluginclasshandler
+)
+
+target_link_libraries (
+    compiz 
+    compiz_core
+    ${COMPIZ_LIBRARIES} 
+    
+    m 
+    pthread 
+    dl
+    
+    compiz_string
+    compiz_timer
+    compiz_logmessage
+    compiz_pluginclasshandler
 )
 
 install (
@@ -112,4 +131,6 @@
     DESTINATION ${COMPIZ_DESTDIR}${exec_prefix}
 )
 
+add_subdirectory(tests)
+
 enable_coverage_report( TARGETS compiz )

=== modified file 'src/action.cpp'
--- src/action.cpp	2011-10-31 13:51:00 +0000
+++ src/action.cpp	2012-01-16 14:53:32 +0000
@@ -455,7 +455,7 @@
 }
 
 bool
-CompAction::operator== (const CompAction& val)
+CompAction::operator== (const CompAction& val) const
 {
     if (priv->state != val.priv->state)
 	return false;

=== modified file 'src/option.cpp'
--- src/option.cpp	2010-11-11 03:14:20 +0000
+++ src/option.cpp	2012-01-16 14:53:32 +0000
@@ -32,164 +32,14 @@
 #include <boost/foreach.hpp>
 #define foreach BOOST_FOREACH
 
+#include <core/action.h>
 #include <core/core.h>
+#include <core/match.h>
 #include <core/option.h>
 #include "privateoption.h"
 
 CompOption::Vector noOptions (0);
 
-CompOption::Value::Value () :
-    priv (new PrivateValue ())
-{
-}
-
-CompOption::Value::Value (const Value &v) :
-    priv (new PrivateValue (*v.priv))
-{
-}
-
-CompOption::Value::~Value ()
-{
-    delete priv;
-}
-
-CompOption::Value::Value (const bool b) :
-    priv (new PrivateValue ())
-{
-    set (b);
-}
-
-CompOption::Value::Value (const int i) :
-    priv (new PrivateValue ())
-{
-    set (i);
-}
-
-CompOption::Value::Value (const float f) :
-    priv (new PrivateValue ())
-{
-    set (f);
-}
-
-CompOption::Value::Value (const unsigned short *color) :
-    priv (new PrivateValue ())
-{
-    set (color);
-}
-
-CompOption::Value::Value (const CompString& s) :
-    priv (new PrivateValue ())
-{
-    set (s);
-}
-
-CompOption::Value::Value (const char *s) :
-    priv (new PrivateValue ())
-{
-    set (s);
-}
-
-
-CompOption::Value::Value (const CompMatch& m) :
-    priv (new PrivateValue ())
-{
-    set (m);
-}
-
-CompOption::Value::Value (const CompAction& a) :
-    priv (new PrivateValue ())
-{
-    set (a);
-}
-
-CompOption::Value::Value (CompOption::Type type, const Vector& l) :
-    priv (new PrivateValue ())
-{
-    set (type, l);
-}
-
-CompOption::Type
-CompOption::Value::type () const
-{
-    return priv->type;
-}
-
-void
-CompOption::Value::set (const bool b)
-{
-    priv->reset ();
-    priv->type = CompOption::TypeBool;
-    priv->value.b = b;
-}
-
-void
-CompOption::Value::set (const int i)
-{
-    priv->reset ();
-    priv->type = CompOption::TypeInt;
-    priv->value.i = i;
-}
-
-void
-CompOption::Value::set (const float f)
-{
-    priv->reset ();
-    priv->type = CompOption::TypeFloat;
-    priv->value.f = f;
-}
-
-void
-CompOption::Value::set (const unsigned short *color)
-{
-    priv->reset ();
-    priv->type = CompOption::TypeColor;
-    priv->value.c[0] = color[0];
-    priv->value.c[1] = color[1];
-    priv->value.c[2] = color[2];
-    priv->value.c[3] = color[3];
-}
-
-void
-CompOption::Value::set (const CompString& s)
-{
-    priv->reset ();
-    priv->type = CompOption::TypeString;
-    priv->string = s;
-}
-
-void
-CompOption::Value::set (const char *s)
-{
-    priv->reset ();
-    priv->type = CompOption::TypeString;
-    priv->string = CompString (s);
-}
-
-void
-CompOption::Value::set (const CompMatch& m)
-{
-    priv->reset ();
-    priv->type = CompOption::TypeMatch;
-    priv->match = m;
-}
-
-void
-CompOption::Value::set (const CompAction& a)
-{
-    priv->reset ();
-    priv->type = CompOption::TypeAction;
-    priv->action = a;
-}
-
-void
-CompOption::Value::set (CompOption::Type type, const Vector& l)
-{
-    priv->reset ();
-    priv->type = CompOption::TypeList;
-    priv->list = l;
-    priv->listType = type;
-}
-
 static bool
 checkIsAction (CompOption::Type type)
 {
@@ -207,307 +57,130 @@
     return false;
 }
 
-bool
-CompOption::Value::b ()
-{
-    if (!priv->checkType (CompOption::TypeBool))
-	return false;
-
-    return priv->value.b;
-}
-
-int
-CompOption::Value::i ()
-{
-    if (!priv->checkType (CompOption::TypeInt))
-	return 0;
-
-    return priv->value.i;
-}
-
-float
-CompOption::Value::f ()
-{
-    if (!priv->checkType (CompOption::TypeFloat))
-	return 0.0;
-
-    return priv->value.f;
-}
+
 
 static unsigned short defaultColor[4] = { 0x0, 0x0, 0x0, 0xffff};
 
-unsigned short *
-CompOption::Value::c ()
-{
-    if (!priv->checkType (CompOption::TypeColor))
-	return reinterpret_cast<unsigned short *> (defaultColor);
-
-    return priv->value.c;
-}
-
-CompString
+
+static void
+finiOptionValue (CompOption::Value &v)
+{
+    switch (v.type()) {
+	case CompOption::TypeAction:
+	case CompOption::TypeKey:
+	case CompOption::TypeButton:
+	case CompOption::TypeEdge:
+	case CompOption::TypeBell:
+	    if (v.action ().state () & CompAction::StateAutoGrab && screen)
+		screen->removeAction (&v.action ());
+	    break;
+
+	case CompOption::TypeList:
+	    foreach (CompOption::Value &val, v.list ())
+		finiOptionValue (val);
+	    break;
+
+	default:
+	    break;
+    }
+}
+
+CompOption::Value::~Value()
+{
+    finiOptionValue(*this);
+}
+
+void
+CompOption::Value::set (Type t, const CompOption::Value::Vector & v)
+{
+    mListType = t;
+    mValue = v;
+}
+
+bool
+CompOption::Value::b () const
+{
+    return boost::get<bool>(mValue);
+}
+
+int
+CompOption::Value::i () const
+{
+    return boost::get<int>(mValue);
+}
+
+float
+CompOption::Value::f () const
+{
+    return boost::get<float>(mValue);
+}
+
+unsigned short*
+CompOption::Value::c () const
+{
+    return boost::get<unsigned short*>(mValue);
+}
+
+const CompString &
+CompOption::Value::s () const
+{
+    return boost::get<CompString>(mValue);
+}
+
+CompString &
 CompOption::Value::s ()
 {
-    if (!priv->checkType (CompOption::TypeString))
-	return "";
+    return boost::get < CompString > (mValue);
+}
 
-    return priv->string;
+const CompMatch &
+CompOption::Value::match () const
+{
+    return boost::get<CompMatch>(mValue);
 }
 
 CompMatch &
 CompOption::Value::match ()
 {
-    priv->checkType (CompOption::TypeMatch);
+    return boost::get<CompMatch>(mValue);
+}
 
-    return priv->match;
+const CompAction &
+CompOption::Value::action () const
+{
+    return boost::get<CompAction>(mValue);
 }
 
 CompAction &
 CompOption::Value::action ()
 {
-    priv->checkType (priv->type);
-
-    if (!checkIsAction (priv->type))
-	compLogMessage ("core", CompLogLevelWarn,
-			"CompOption::Value not an action");
-
-    return priv->action;
+    return boost::get<CompAction>(mValue);
 }
 
-CompOption::Type
-CompOption::Value::listType ()
+// Type listType () const;
+
+const CompOption::Value::Vector &
+CompOption::Value::list () const
 {
-    priv->checkType (CompOption::TypeList);
-
-    return priv->listType;
+    return boost::get< std::vector<Value> >(mValue);
 }
 
 CompOption::Value::Vector &
 CompOption::Value::list ()
 {
-    priv->checkType (CompOption::TypeList);
-
-    return priv->list;
-}
-
-CompOption::Value::operator bool ()
-{
-    return b ();
-}
-
-CompOption::Value::operator int ()
-{
-    return i ();
-}
-
-CompOption::Value::operator float ()
-{
-    return f ();
-}
-
-CompOption::Value::operator unsigned short * ()
-{
-    return c ();
-}
-
-CompOption::Value::operator CompString ()
-{
-    return s ();
-}
-
-CompOption::Value::operator CompMatch & ()
-{
-    return match ();
-}
-
-CompOption::Value::operator CompAction & ()
-{
-    return action ();
-}
-
-CompOption::Value::operator CompAction * ()
-{
-    return &action ();
-}
-
-CompOption::Value::operator Type ()
-{
-    return listType ();
-}
-
-CompOption::Value::operator Vector & ()
-{
-    return list ();
-}
-
-bool
-CompOption::Value::operator== (const CompOption::Value &val)
-{
-    if (priv->type != val.priv->type)
-	return false;
-
-    switch (priv->type)
-    {
-	case CompOption::TypeBool:
-	    return priv->value.b == val.priv->value.b;
-	    break;
-
-	case CompOption::TypeInt:
-	    return priv->value.i == val.priv->value.i;
-	    break;
-
-	case CompOption::TypeFloat:
-	    return priv->value.f == val.priv->value.f;
-	    break;
-
-	case CompOption::TypeColor:
-	    return (priv->value.c[0] == val.priv->value.c[0]) &&
-		   (priv->value.c[1] == val.priv->value.c[1]) &&
-		   (priv->value.c[2] == val.priv->value.c[2]) &&
-		   (priv->value.c[3] == val.priv->value.c[3]);
-	    break;
-
-	case CompOption::TypeString:
-	    return priv->string.compare (val.priv->string) == 0;
-	    break;
-
-	case CompOption::TypeMatch:
-	    return priv->match == val.priv->match;
-	    break;
-
-	case CompOption::TypeAction:
-	    return priv->action == val.priv->action;
-	    break;
-
-	case CompOption::TypeList:
-	    if (priv->listType != val.priv->listType)
-		return false;
-
-	    if (priv->list.size () != val.priv->list.size ())
-		return false;
-
-	    for (unsigned int i = 0; i < priv->list.size (); i++)
-		if (priv->list[i] != val.priv->list[i])
-		    return false;
-
-	    return true;
-	    break;
-
-	default:
-	    break;
-    }
-
-    return true;
-}
-
-bool
-CompOption::Value::operator!= (const CompOption::Value &val)
-{
-    return !(*this == val);
-}
-
-static void
-finiOptionValue (CompOption::Value &v,
-		 CompOption::Type  type)
-{
-    switch (type) {
-	case CompOption::TypeAction:
-	case CompOption::TypeKey:
-	case CompOption::TypeButton:
-	case CompOption::TypeEdge:
-	case CompOption::TypeBell:
-	    if (v.action ().state () & CompAction::StateAutoGrab && screen)
-		screen->removeAction (&v.action ());
-	    break;
-
-	case CompOption::TypeList:
-	    foreach (CompOption::Value &val, v.list ())
-		finiOptionValue (val, v.listType ());
-	    break;
-
-	default:
-	    break;
-    }
-}
-
-CompOption::Value &
-CompOption::Value::operator= (const CompOption::Value &val)
-{
-    if (this == &val)
-	return *this;
-
-    finiOptionValue (*this, priv->type);
-
-    delete priv;
-    priv = new PrivateValue (*val.priv);
-
-    return *this;
-}
-
-PrivateValue::PrivateValue () :
-    type (CompOption::TypeUnset),
-    string (""),
-    action (),
-    match (),
-    listType (CompOption::TypeUnset),
-    list ()
-{
-    memset (&value, 0, sizeof (ValueUnion));
-}
-
-PrivateValue::PrivateValue (const PrivateValue& p) :
-    type (p.type),
-    string (p.string),
-    action (p.action),
-    match (p.match),
-    listType (p.listType),
-    list (p.list)
-{
-    memcpy (&value, &p.value, sizeof (ValueUnion));
-}
-
-bool
-PrivateValue::checkType (CompOption::Type refType)
-{
-    if (type == CompOption::TypeUnset)
-    {
-	compLogMessage ("core", CompLogLevelWarn,
-			"Value type is not yet set");
-	return false;
-    }
-
-    if (type != refType)
-    {
-	compLogMessage ("core", CompLogLevelWarn,
-			"Value type does not match (is %d, expected %d)",
-			type, refType);
-	return false;
-    }
-
-    return true;
-}
-
-void
-PrivateValue::reset ()
-{
-    switch (type) {
-	case CompOption::TypeString:
-	    string = "";
-	    break;
-	case CompOption::TypeMatch:
-	    match = CompMatch ();
-	    break;
-	case CompOption::TypeAction:
-	    action = CompAction ();
-	    break;
-	case CompOption::TypeList:
-	    list.clear ();
-	    listType = CompOption::TypeBool;
-	    break;
-	default:
-	    break;
-    }
-    type = CompOption::TypeBool;
+    return boost::get< std::vector<Value> >(mValue);
+}
+
+bool
+CompOption::Value::operator== (const Value & rhs) const
+{
+    return mValue == rhs.mValue;
+}
+
+bool
+CompOption::Value::operator!= (const Value & rhs) const
+{
+    return !(mValue == rhs.mValue);
 }
 
 CompOption::Restriction::Restriction () :
@@ -664,10 +337,9 @@
 
 static void
 finiScreenOptionValue (CompScreen        *s,
-		       CompOption::Value &v,
-		       CompOption::Type  type)
+		       CompOption::Value &v)
 {
-    switch (type) {
+    switch (v.type()) {
 	case CompOption::TypeAction:
 	case CompOption::TypeKey:
 	case CompOption::TypeButton:
@@ -679,7 +351,7 @@
 
 	case CompOption::TypeList:
 	    foreach (CompOption::Value &val, v.list ())
-		finiScreenOptionValue (s, val, v.listType ());
+		finiScreenOptionValue (s, val);
 	    break;
 
 	default:
@@ -689,7 +361,7 @@
 
 CompOption::~CompOption ()
 {
-    finiOptionValue (priv->value, priv->type);
+    finiOptionValue (priv->value);
     delete priv;
 }
 

=== modified file 'src/privateoption.h'
--- src/privateoption.h	2010-11-09 14:13:19 +0000
+++ src/privateoption.h	2012-01-16 14:53:32 +0000
@@ -56,32 +56,6 @@
 	RestrictionUnion rest;
 };
 
-typedef union {
-    bool	   b;
-    int		   i;
-    float	   f;
-    unsigned short c[4];
-} ValueUnion;
-
-class PrivateValue {
-    public:
-	PrivateValue ();
-	PrivateValue (const PrivateValue&);
-
-	void reset ();
-	bool checkType (CompOption::Type refType);
-
-	CompOption::Type          type;
-	ValueUnion                value;
-	CompString                string;
-	CompAction                action;
-	CompMatch                 match;
-	CompOption::Type          listType;
-	CompOption::Value::Vector list;
-
-	bool			  active;
-};
-
 class PrivateOption
 {
     public:

=== added directory 'src/tests'
=== added file 'src/tests/CMakeLists.txt'
--- src/tests/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/tests/CMakeLists.txt	2012-01-16 14:53:32 +0000
@@ -0,0 +1,20 @@
+include_directories( 
+  ${CMAKE_CURRENT_SOURCE_DIR} 
+)
+
+add_executable( 
+  compiz_option_test
+  
+  ${CMAKE_CURRENT_SOURCE_DIR}/option.cpp
+)
+
+target_link_libraries( 
+  compiz_option_test 
+  
+  compiz_core
+  
+  ${GTEST_BOTH_LIBRARIES}
+  ${CMAKE_THREAD_LIBS_INIT} # Link in pthread.
+)
+
+add_test( compiz_option_test compiz_option_test )

=== added file 'src/tests/globals.h'
--- src/tests/globals.h	1970-01-01 00:00:00 +0000
+++ src/tests/globals.h	2012-01-16 14:53:32 +0000
@@ -0,0 +1,24 @@
+#ifndef GLOBALS_H
+#define GLOBALS_H
+
+char *programName;
+char **programArgv;
+int  programArgc;
+
+bool shutDown = false;
+bool restartSignal = false;
+
+CompWindow *lastFoundWindow = 0;
+
+bool replaceCurrentWm = false;
+bool indirectRendering = false;
+bool noDetection = false;
+bool useDesktopHints = false;
+bool debugOutput = false;
+bool useCow = true;
+
+std::list <CompString> initialPlugins;
+
+unsigned int pluginClassHandlerIndex = 0;
+
+#endif // GLOBALS_H

=== added file 'src/tests/option.cpp'
--- src/tests/option.cpp	1970-01-01 00:00:00 +0000
+++ src/tests/option.cpp	2012-01-16 14:53:32 +0000
@@ -0,0 +1,45 @@
+#include <gtest/gtest.h>
+
+#include "core/core.h"
+#include "core/action.h"
+#include "core/match.h"
+#include "core/option.h"
+
+#include "globals.h"
+
+namespace {
+    template<typename T>
+    void
+    check_type_value(CompOption::Type type, const T & value)
+    {
+	CompOption::Value v;
+	v.set(value);
+	ASSERT_EQ(v.type(),type);
+	ASSERT_EQ (v.get<T>(),value);
+    }
+}
+
+
+
+static unsigned short defaultColor[4] = { 0x0, 0x0, 0x0, 0xffff};
+
+TEST(CompOption,Value)
+{
+
+    check_type_value<bool> (CompOption::TypeBool, true);
+    check_type_value<bool> (CompOption::TypeBool, false);
+
+    check_type_value<int> (CompOption::TypeInt, 1);
+    check_type_value<float> (CompOption::TypeFloat, 1.f);
+    check_type_value<CompString> (CompOption::TypeString, CompString("Check"));
+
+    check_type_value<CompAction> (CompOption::TypeAction, CompAction());
+    check_type_value<CompMatch> (CompOption::TypeMatch, CompMatch());
+
+    check_type_value<CompOption::Value::Vector> (CompOption::TypeList, CompOption::Value::Vector(5));
+
+    CompOption::Value v1, v2;
+    ASSERT_EQ (v1,v2);
+    v1.set (CompString("SomeString"));
+    ASSERT_TRUE(v1 != v2);
+}