Merge lp:~compiz-team/compiz/compiz.fix_1063617.7 into lp:compiz/0.9.9

[Sam Spilsbury]

Provided test fixtures for testing the setting ccsSet* functions

DefaultImplSetParam provides a "parameter" for testing different setting
types exposed through DefaultImplSetParamInterface .
DefaultImplSetFailureParam provides a "parameter" for testing failure
cases.

The test fixtures in this case set up some default values through the
stubInitializeSettingDefaultValue and stubInitializeSettingInfo
functions. This is verified through MockInitializerFuncsWithDelegators

This is about preparing a fix for (LP: #1063617).

(LP: #1063617) is really complicated. The problem is that there is a feedback loop between integrated keys and normal keys which can cause the integrated keys to read from normal keys which will be out of date or incorrect because they were never updated.

A part of that problem is that we need to have more information in the backends as to why setting a key to a particular value failed or succeeded.

Provided test fixtures for testing the setting ccsSet* functions

DefaultImplSetParam provides a "parameter" for testing different setting
types exposed through DefaultImplSetParamInterface .
DefaultImplSetFailureParam provides a "parameter" for testing failure
cases.

The test fixtures in this case set up some default values through the
stubInitializeSettingDefaultValue and stubInitializeSettingInfo
functions. This is verified through MockInitializerFuncsWithDelegators

[Sam Spilsbury (smspillaz)]

(Its just in the WIP queue until the other changes to compiz go through)

[lp:~compiz-team/compiz/compiz.fix_1063617.7]

3493. By Sam Spilsbury on 2012-11-29

Merged compiz.fix_1063617.6 into compiz.fix_1063617.7.

3494. By Sam Spilsbury on 2012-12-03

Merged compiz.fix_1063617.6 into compiz.fix_1063617.7.

3495. By Sam Spilsbury on 2012-12-04

Merged compiz.fix_1063617.6 into compiz.fix_1063617.7.

3496. By Sam Spilsbury on 2012-12-04

Clean up some class names

3497. By Sam Spilsbury on 2012-12-04

Don't use a namespace, use a better name for SetParam's impl instead

3498. By Sam Spilsbury on 2012-12-05

Merged compiz.fix_1063617.6 into compiz.fix_1063617.7.

3499. By Sam Spilsbury on 2012-12-07

Merged compiz.fix_1063617.6 into compiz.fix_1063617.7.

3500. By Sam Spilsbury on 2012-12-10

Merged compiz.fix_1063617.6 into compiz.fix_1063617.7.

Unmerged revisions

=== modified file 'compizconfig/libcompizconfig/include/ccs.h'
--- compizconfig/libcompizconfig/include/ccs.h	2012-11-27 03:59:26 +0000
+++ compizconfig/libcompizconfig/include/ccs.h	2012-11-29 07:58:20 +0000
@@ -722,6 +722,8 @@
 void ccsFreeSetting (CCSSetting *setting);
 void ccsFreeGroup (CCSGroup *group);
 void ccsFreeSubGroup (CCSSubGroup *subGroup);
+void ccsCleanupSettingInfo (CCSSettingInfo *info,
+			 CCSSettingType type);
 void ccsFreeSettingValue (CCSSettingValue *value);
 void ccsFreeSettingValueWithType (CCSSettingValue *v,
 				  CCSSettingType  type);
@@ -792,9 +794,18 @@
 
 /* Deep copy setting value */
 CCSSettingValue *
-ccsCopyValue (CCSSettingValue *orig,
-	      CCSSettingType  type,
-	      CCSSettingInfo  *info);
+ccsCopyValue (const CCSSettingValue *orig,
+	      CCSSettingType        type,
+	      CCSSettingInfo        *info);
+Bool
+ccsCopyValueInto (const CCSSettingValue *from,
+		  CCSSettingValue       *to,
+		  CCSSettingType        type,
+		  CCSSettingInfo        *info);
+
+/* Deep copy setting info */
+void
+ccsCopyInfo (const CCSSettingInfo *from, CCSSettingInfo *to, CCSSettingType type);
 
 /* Converts an array of data items to a setting value list. Behaves similar
    to ccsGetListFromStringArray */

=== modified file 'compizconfig/libcompizconfig/src/compiz.cpp'
--- compizconfig/libcompizconfig/src/compiz.cpp	2012-11-24 11:18:52 +0000
+++ compizconfig/libcompizconfig/src/compiz.cpp	2012-11-29 07:58:20 +0000
@@ -658,61 +658,6 @@
     }
 }
 
-CCSSetting *
-ccsSettingDefaultImplNew (CCSPlugin                             *plugin,
-			  const char                            *name,
-			  CCSSettingType                        type,
-			  const char                            *shortDesc,
-			  const char                            *longDesc,
-			  const char                            *hints,
-			  const char                            *group,
-			  const char                            *subGroup,
-			  CCSSettingDefaultValueInitializerFunc valueInit,
-			  void                                  *valueInitData,
-			  CCSSettingInfoInitializerFunc         infoInit,
-			  void                                  *infoInitData,
-			  CCSObjectAllocationInterface          *ai,
-			  const CCSInterfaceTable               *interfaces)
-{
-    CCSSetting *setting = (CCSSetting *) calloc (1, sizeof (CCSSetting));
-
-    if (!setting)
-	return NULL;
-
-    ccsObjectInit (setting, ai);
-
-    CCSSettingPrivate *sPrivate = (CCSSettingPrivate *) (*ai->calloc_) (ai->allocator, 1, sizeof (CCSSettingPrivate));
-
-    if (!sPrivate)
-    {
-	free (setting);
-	return NULL;
-    }
-
-    ccsObjectSetPrivate (setting, (CCSPrivate *) sPrivate);
-    ccsObjectAddInterface (setting, (CCSInterface *) interfaces->settingInterface, GET_INTERFACE_TYPE (CCSSettingInterface));
-    ccsSettingRef (setting);
-
-    sPrivate->parent = plugin;
-    sPrivate->isDefault = TRUE;
-    sPrivate->name = strdup (name);
-
-    sPrivate->shortDesc = strdup (shortDesc);
-    sPrivate->longDesc  = strdup (longDesc);
-    sPrivate->group     = strdup (group);
-    sPrivate->hints     = strdup (hints);
-    sPrivate->subGroup  = strdup (subGroup);
-
-    sPrivate->type = type;
-    sPrivate->value = &sPrivate->defaultValue;
-    sPrivate->defaultValue.parent = setting;
-
-    (*infoInit) (type, &sPrivate->info, infoInitData);
-    (*valueInit) (type, &sPrivate->info, &sPrivate->defaultValue, valueInitData);
-
-    return setting;
-}
-
 static void
 addOptionForPluginPB (CCSPlugin * plugin,
 		      const char * name,

=== modified file 'compizconfig/libcompizconfig/src/main.c'
--- compizconfig/libcompizconfig/src/main.c	2012-11-24 10:01:33 +0000
+++ compizconfig/libcompizconfig/src/main.c	2012-11-29 07:58:20 +0000
@@ -800,6 +800,29 @@
     free (p);
 }
 
+void
+ccsCleanupSettingInfo (CCSSettingInfo *info,
+		       CCSSettingType type)
+{
+    switch (type)
+    {
+    case TypeInt:
+	ccsIntDescListFree (info->forInt.desc, TRUE);
+	break;
+    case TypeString:
+	ccsStrRestrictionListFree (info->forString.restriction, TRUE);
+	break;
+    case TypeList:
+	if (info->forList.listType == TypeInt)
+	    ccsIntDescListFree (info->forList.listInfo->
+				forInt.desc, TRUE);
+	free (info->forList.listInfo);
+	break;
+    default:
+	break;
+    }
+}
+
 static void
 ccsFreeSettingDefault (CCSSetting *s)
 {
@@ -812,30 +835,13 @@
     free (sPrivate->subGroup);
     free (sPrivate->hints);
 
-    switch (sPrivate->type)
-    {
-    case TypeInt:
-	ccsIntDescListFree (sPrivate->info.forInt.desc, TRUE);
-	break;
-    case TypeString:
-	ccsStrRestrictionListFree (sPrivate->info.forString.restriction, TRUE);
-	break;
-    case TypeList:
-	if (sPrivate->info.forList.listType == TypeInt)
-	    ccsIntDescListFree (sPrivate->info.forList.listInfo->
-				forInt.desc, TRUE);
-	free (sPrivate->info.forList.listInfo);
-	//ccsSettingValueListFree (sPrivate->value->value.asList, TRUE);
-	break;
-    default:
-	break;
-    }
-
     if (&sPrivate->defaultValue != sPrivate->value)
     {
 	ccsFreeSettingValue (sPrivate->value);
     }
 
+    ccsCleanupSettingInfo (&sPrivate->info, sPrivate->type);
+
     ccsFreeSettingValue (&sPrivate->defaultValue);
 
     ccsObjectFinalize (s);
@@ -1819,10 +1825,10 @@
     return TRUE;
 }
 
-static void
-copyInfo (CCSSettingInfo *from, CCSSettingInfo *to, CCSSettingType type)
+void
+ccsCopyInfo (const CCSSettingInfo *from, CCSSettingInfo *to, CCSSettingType type)
 {	
-    memcpy (from, to, sizeof (CCSSettingInfo));
+    memcpy (to, from, sizeof (CCSSettingInfo));
 
     switch (type)
     {
@@ -1896,7 +1902,7 @@
 	    {
 		to->forList.listInfo = calloc (1, sizeof (CCSSettingInfo));
 
-		copyInfo (from->forList.listInfo, to->forList.listInfo, from->forList.listType);
+		ccsCopyInfo (from->forList.listInfo, to->forList.listInfo, from->forList.listType);
 	    }
 
 	    break;
@@ -1997,7 +2003,7 @@
     }
 
     copyValue (&fromPrivate->defaultValue, &toPrivate->defaultValue);
-    copyInfo (&fromPrivate->info, &toPrivate->info, fromPrivate->type);
+    ccsCopyInfo (&fromPrivate->info, &toPrivate->info, fromPrivate->type);
 
     toPrivate->defaultValue.parent = to;
     toPrivate->privatePtr = NULL;
@@ -2468,63 +2474,81 @@
     return TRUE;
 }
 
-CCSSettingValue *
-ccsCopyValue (CCSSettingValue *orig,
-	      CCSSettingType  type,
-	      CCSSettingInfo  *info)
+Bool
+ccsCopyValueInto (const CCSSettingValue *from,
+		  CCSSettingValue       *to,
+		  CCSSettingType        type,
+		  CCSSettingInfo        *info)
 {
-    CCSSettingValue *value = calloc (1, sizeof (CCSSettingValue));
-
-    if (!value)
-	return NULL;
-
-    value->refCount = 1;
-    value->parent = orig->parent;
-    value->isListChild = orig->isListChild;
-
-    CCSSettingType vType = value->isListChild ? info->forList.listType : type;
+    to->parent = from->parent;
+    to->isListChild = from->isListChild;
+
+    CCSSettingType vType = to->isListChild ? info->forList.listType : type;
 
     switch (vType)
     {
 	case TypeInt:
-	    value->value.asInt = orig->value.asInt;
+	    to->value.asInt = from->value.asInt;
 	    break;
 	case TypeBool:
-	    value->value.asBool = orig->value.asBool;
+	    to->value.asBool = from->value.asBool;
 	    break;
 	case TypeFloat:
-	    value->value.asFloat = orig->value.asFloat;
+	    to->value.asFloat = from->value.asFloat;
 	    break;
 	case TypeString:
-	    value->value.asString = strdup (orig->value.asString);
+	    to->value.asString = strdup (from->value.asString);
 	    break;
 	case TypeMatch:
-	    value->value.asMatch = strdup (orig->value.asMatch);
+	    to->value.asMatch = strdup (from->value.asMatch);
 	    break;
 	case TypeKey:
-	    memcpy (&value->value.asKey, &orig->value.asKey,
+	    memcpy (&to->value.asKey, &from->value.asKey,
 		    sizeof (CCSSettingKeyValue));
 	    break;
 	case TypeButton:
-	    memcpy (&value->value.asButton, &orig->value.asButton,
+	    memcpy (&to->value.asButton, &from->value.asButton,
 		    sizeof (CCSSettingButtonValue));
 	    break;
 	case TypeEdge:
-	    value->value.asEdge = orig->value.asEdge;
+	    to->value.asEdge = from->value.asEdge;
 	    break;
 	case TypeBell:
-	    value->value.asBell = orig->value.asBell;
+	    to->value.asBell = from->value.asBell;
 	    break;
 	case TypeColor:
-	    memcpy (&value->value.asColor, &orig->value.asColor,
+	    memcpy (&to->value.asColor, &from->value.asColor,
 		    sizeof (CCSSettingColorValue));
 	    break;
+	case TypeList:
+	    assert (from->parent != NULL);
+	    to->value.asList = ccsCopyList (from->value.asList, from->parent);
 	default:
-	    free (value);
-	    return NULL;
+	    ccsError ("unexpected setting type in ccsCopyValueInto");
+	    return FALSE;
 	    break;
     }
 
+    return TRUE;
+}
+
+CCSSettingValue *
+ccsCopyValue (const CCSSettingValue *orig,
+	      CCSSettingType        type,
+	      CCSSettingInfo        *info)
+{
+    CCSSettingValue *value = calloc (1, sizeof (CCSSettingValue));
+
+    if (!value)
+	return NULL;
+
+    value->refCount = 1;
+    if (!ccsCopyValueInto (orig, value, type, info))
+    {
+	free (value);
+	return NULL;
+    }
+
     return value;
 }
 
@@ -5568,6 +5592,61 @@
     (*(GET_INTERFACE (CCSIntegratedSettingInterface, setting))->free) (setting);
 }
 
+CCSSetting *
+ccsSettingDefaultImplNew (CCSPlugin                             *plugin,
+			  const char                            *name,
+			  CCSSettingType                        type,
+			  const char                            *shortDesc,
+			  const char                            *longDesc,
+			  const char                            *hints,
+			  const char                            *group,
+			  const char                            *subGroup,
+			  CCSSettingDefaultValueInitializerFunc valueInit,
+			  void                                  *valueInitData,
+			  CCSSettingInfoInitializerFunc         infoInit,
+			  void                                  *infoInitData,
+			  CCSObjectAllocationInterface          *ai,
+			  const CCSInterfaceTable               *interfaces)
+{
+    CCSSetting *setting = (CCSSetting *) calloc (1, sizeof (CCSSetting));
+
+    if (!setting)
+        return NULL;
+
+    ccsObjectInit (setting, ai);
+
+    CCSSettingPrivate *sPrivate = (CCSSettingPrivate *) (*ai->calloc_) (ai->allocator, 1, sizeof (CCSSettingPrivate));
+
+    if (!sPrivate)
+    {
+        free (setting);
+        return NULL;
+    }
+
+    ccsObjectSetPrivate (setting, (CCSPrivate *) sPrivate);
+    ccsObjectAddInterface (setting, (CCSInterface *) interfaces->settingInterface, GET_INTERFACE_TYPE (CCSSettingInterface));
+    ccsSettingRef (setting);
+
+    sPrivate->parent = plugin;
+    sPrivate->isDefault = TRUE;
+    sPrivate->name = strdup (name);
+
+    sPrivate->shortDesc = strdup (shortDesc);
+    sPrivate->longDesc  = strdup (longDesc);
+    sPrivate->group     = strdup (group);
+    sPrivate->hints     = strdup (hints);
+    sPrivate->subGroup  = strdup (subGroup);
+
+    sPrivate->type = type;
+    sPrivate->value = &sPrivate->defaultValue;
+    sPrivate->defaultValue.parent = setting;
+
+    (*infoInit) (type, &sPrivate->info, infoInitData);
+    (*valueInit) (type, &sPrivate->info, &sPrivate->defaultValue, valueInitData);
+
+    return setting;
+}
+
 /* CCSSharedIntegratedSettingInfo implementation */
 
 typedef struct _CCSSharedIntegratedSettingInfoPrivate CCSSharedIntegratedSettingInfoPrivate;

=== modified file 'compizconfig/libcompizconfig/tests/CMakeLists.txt'
--- compizconfig/libcompizconfig/tests/CMakeLists.txt	2012-09-29 14:33:53 +0000
+++ compizconfig/libcompizconfig/tests/CMakeLists.txt	2012-11-29 07:58:20 +0000
@@ -113,7 +113,8 @@
 		       compizconfig
 		       compizconfig_ccs_context_mock
 		       compizconfig_ccs_plugin_mock
-		       compizconfig_ccs_setting_mock)
+                       compizconfig_ccs_setting_mock
+                       compizconfig_ccs_list_wrapper)
 
 target_link_libraries (compizconfig_test_ccs_text_file
 		       ${GTEST_BOTH_LIBRARIES}

=== modified file 'compizconfig/libcompizconfig/tests/compizconfig_test_ccs_setting.cpp'
--- compizconfig/libcompizconfig/tests/compizconfig_test_ccs_setting.cpp	2012-11-24 11:18:52 +0000
+++ compizconfig/libcompizconfig/tests/compizconfig_test_ccs_setting.cpp	2012-11-29 07:58:20 +0000
@@ -26,14 +26,24 @@
 #include <boost/make_shared.hpp>
 #include <boost/function.hpp>
 
+#include <X11/Xlib.h>
+
 #include <ccs.h>
 
 #include "compizconfig_ccs_setting_mock.h"
 #include "compizconfig_ccs_plugin_mock.h"
+#include "compizconfig_ccs_list_wrapper.h"
+
+namespace cci = compiz::config::impl;
+namespace cc = compiz::config;
 
 using ::testing::_;
 using ::testing::Return;
 using ::testing::InSequence;
+using ::testing::WithArgs;
+using ::testing::WithParamInterface;
+using ::testing::Invoke;
+using ::testing::ReturnNull;
 
 TEST(CCSSettingTest, TestMock)
 {
@@ -134,6 +144,11 @@
 
 namespace
 {
+
+typedef boost::shared_ptr <CCSSettingInfo> CCSSettingInfoPtr;
+typedef boost::shared_ptr <CCSSettingValue> CCSSettingValuePtr;
+typedef boost::shared_ptr <CCSSetting> CCSSettingPtr;
+
 class MockInitializerFuncs
 {
     public:
@@ -250,3 +265,874 @@
     EXPECT_EQ (ccsSettingGetParent (setting.get ()),
 	       plugin.get ());
 }
+
+namespace
+{
+
+/* Used to copy different raw values */
+template <typename SettingValueType>
+class CopyRawValueBase
+{
+    public:
+
+	CopyRawValueBase (const SettingValueType &value) :
+	    mValue (value)
+	{
+	}
+
+    protected:
+
+	const SettingValueType &mValue;
+};
+
+template <typename SettingValueType>
+class CopyRawValue :
+    public CopyRawValueBase <SettingValueType>
+{
+    public:
+
+	typedef SettingValueType ReturnType;
+	typedef CopyRawValueBase <SettingValueType> Parent;
+
+	CopyRawValue (const SettingValueType &value) :
+	    CopyRawValueBase <SettingValueType> (value)
+	{
+	}
+
+	SettingValueType operator () ()
+	{
+	    return Parent::mValue;
+	}
+};
+
+template <>
+class CopyRawValue <const char *> :
+    public CopyRawValueBase <const char *>
+{
+    public:
+
+	typedef const char * ReturnType;
+	typedef CopyRawValueBase <const char *> Parent;
+
+	CopyRawValue (const char * value) :
+	    CopyRawValueBase <const char *> (value)
+	{
+	}
+
+	ReturnType operator () ()
+	{
+	    /* XXX: Valgrind complains here that mValue is uninitialized, but
+	     * verification using gdb confirms that isn't true */
+	    return strdup (Parent::mValue);
+	}
+};
+
+template <>
+class CopyRawValue <cci::SettingValueListWrapper::Ptr> :
+    public CopyRawValueBase <cci::SettingValueListWrapper::Ptr>
+{
+    public:
+
+	typedef CCSSettingValueList ReturnType;
+	typedef CopyRawValueBase <cci::SettingValueListWrapper::Ptr> Parent;
+
+	CopyRawValue (const cci::SettingValueListWrapper::Ptr &value) :
+	    CopyRawValueBase <cci::SettingValueListWrapper::Ptr> (value)
+	{
+	}
+
+	ReturnType operator () ()
+	{
+	    return ccsCopyList (*Parent::mValue,
+				Parent::mValue->setting ().get ());
+	}
+};
+
+CCSSettingValue *
+NewCCSSettingValue ()
+{
+    CCSSettingValue *value =
+	    reinterpret_cast <CCSSettingValue *> (
+		calloc (1, sizeof (CCSSettingValue)));
+
+    value->refCount = 1;
+
+    return value;
+}
+
+template <typename SettingValueType>
+CCSSettingValue *
+RawValueToCCSValue (const SettingValueType &value)
+{
+    typedef typename CopyRawValue <SettingValueType>::ReturnType UnionType;
+
+    CCSSettingValue  *settingValue = NewCCSSettingValue ();
+    UnionType *unionMember =
+	    reinterpret_cast <UnionType *> (&settingValue->value);
+
+    *unionMember = (CopyRawValue <SettingValueType> (value)) ();
+
+    return settingValue;
+}
+
+template <typename SettingValueType>
+CCSSettingValuePtr
+RawValueToListValue (const SettingValueType &value)
+{
+    return ListValueToSettingValueList (RawValueToCCSValue (value));
+}
+
+class ContainedValueGenerator
+{
+    private:
+
+	const CCSSettingValuePtr &
+	InitializedSpawnedValue (const CCSSettingValuePtr &value,
+				 CCSSettingType           type,
+				 const CCSSettingInfoPtr  &info)
+	{
+	    const CCSSettingPtr &setting (GetSetting (type, info));
+	    value->parent = setting.get ();
+	    mContainedValues.push_back (value);
+
+	    return mContainedValues.back ();
+	}
+
+    public:
+
+	template <typename SettingValueType>
+	const CCSSettingValuePtr &
+	SpawnValueForInfoAndType (const SettingValueType  &rawValue,
+				  CCSSettingType          type,
+				  const CCSSettingInfoPtr &info)
+	{
+
+	    CCSSettingValuePtr  value (AutoDestroy (RawValueToCCSValue <SettingValueType> (rawValue),
+						    ccsSettingValueUnref));
+
+	    return InitializedSpawnedValue (value, type, info);
+	}
+
+	const CCSSettingPtr &
+	GetSetting (CCSSettingType          type,
+		    const CCSSettingInfoPtr &info)
+	{
+	    if (!mSetting)
+		SetupMockSetting (type, info);
+
+	    return mSetting;
+	}
+
+    private:
+
+	void SetupMockSetting (CCSSettingType          type,
+			       const CCSSettingInfoPtr &info)
+	{
+	    mSetting = AutoDestroy (ccsMockSettingNew (),
+				    ccsSettingUnref);
+
+	    CCSSettingGMock *settingMock =
+		    reinterpret_cast <CCSSettingGMock *> (
+			ccsObjectGetPrivate (mSetting.get ()));
+
+	    EXPECT_CALL (*settingMock, getType ())
+		.WillRepeatedly (Return (type));
+
+	    EXPECT_CALL (*settingMock, getInfo ())
+		.WillRepeatedly (Return (info.get ()));
+
+	    EXPECT_CALL (*settingMock, getDefaultValue ())
+		.WillRepeatedly (ReturnNull ());
+	}
+
+	/* This must always be before the value
+	 * as the values hold a weak reference to
+	 * it */
+	CCSSettingPtr                    mSetting;
+	std::vector <CCSSettingValuePtr> mContainedValues;
+
+};
+
+/* ValueContainer Interface */
+template <typename SettingValueType>
+class ValueContainer
+{
+    public:
+
+	typedef boost::shared_ptr <ValueContainer> Ptr;
+
+	virtual const SettingValueType &
+	getRawValue (CCSSettingType          type,
+		     const CCSSettingInfoPtr &info) = 0;
+	virtual const CCSSettingValuePtr &
+	getContainedValue (CCSSettingType          type,
+			   const CCSSettingInfoPtr &info) = 0;
+};
+
+class NormalValueContainerBase
+{
+    protected:
+
+	ContainedValueGenerator  mContainedValueGenerator;
+	CCSSettingValuePtr       mContainedValue;
+};
+
+template <typename SettingValueType>
+class NormalValueContainer :
+    public NormalValueContainerBase,
+    public ValueContainer <SettingValueType>
+{
+    public:
+
+	NormalValueContainer (const SettingValueType &value) :
+	    mRawValue (value)
+	{
+	}
+
+	const SettingValueType &
+	getRawValue (CCSSettingType          type,
+		     const CCSSettingInfoPtr &info)
+	{
+	    return mRawValue;
+	}
+
+	const CCSSettingValuePtr &
+	getContainedValue (CCSSettingType          type,
+			   const CCSSettingInfoPtr &info)
+	{
+	    if (!mContainedValue)
+		mContainedValue = mContainedValueGenerator.SpawnValueForInfoAndType (mRawValue,
+										     type,
+										     info);
+
+	    return mContainedValue;
+	}
+
+    private:
+
+	const SettingValueType   &mRawValue;
+};
+
+template <typename SettingValueType>
+typename NormalValueContainer <SettingValueType>::Ptr
+ContainNormal (const SettingValueType &value)
+{
+    return boost::make_shared <NormalValueContainer <SettingValueType> > (value);
+}
+
+class ListValueContainerBase :
+    public ValueContainer <CCSSettingValueList>
+{
+    protected:
+
+	const CCSSettingValuePtr &
+	getContainedValue (CCSSettingType          type,
+			   const CCSSettingInfoPtr &info)
+	{
+	    if (!mContainedWrapper)
+	    {
+		const cci::SettingValueListWrapper::Ptr &wrapper (SetupWrapper (type, info));
+
+		mContainedWrapper =
+			mContainedValueGenerator.SpawnValueForInfoAndType (wrapper,
+									   type,
+									   info);
+	    }
+
+	    return mContainedWrapper;
+	}
+
+	const CCSSettingValueList &
+	getRawValue (CCSSettingType          type,
+		     const CCSSettingInfoPtr &info)
+	{
+	    const cci::SettingValueListWrapper::Ptr &wrapper (SetupWrapper (type, info));
+
+	    return *wrapper;
+	}
+
+	cci::SettingValueListWrapper::Ptr mWrapper;
+
+	/* ccsFreeSettingValue has an implicit
+	 * dependency on mWrapper (CCSSettingValue -> CCSSetting ->
+	 * CCSSettingInfo -> cci::SettingValueListWrapper), these should
+	 * be kept after mWrapper here */
+	ContainedValueGenerator           mContainedValueGenerator;
+	CCSSettingValuePtr                mContainedWrapper;
+
+    private:
+
+	const cci::SettingValueListWrapper::Ptr &
+	SetupWrapper (CCSSettingType          type,
+		      const CCSSettingInfoPtr &info)
+	{
+	    if (!mWrapper)
+	    {
+		const CCSSettingPtr &setting (mContainedValueGenerator.GetSetting (type, info));
+		CCSSettingValue     *value = GetValueForListWrapper ();
+
+		value->parent = setting.get ();
+		value->isListChild = TRUE;
+		mWrapper.reset (new cci::SettingValueListWrapper (NULL,
+								  cci::Deep,
+								  type,
+								  info,
+								  setting));
+		mWrapper->append (value);
+	    }
+
+	    return mWrapper;
+	}
+
+	virtual CCSSettingValue * GetValueForListWrapper () = 0;
+};
+
+template <typename SettingValueType>
+class ListValueContainer :
+    public ListValueContainerBase
+{
+    public:
+
+	ListValueContainer (const SettingValueType &value) :
+	    mRawChildValue (value)
+	{
+	}
+
+    private:
+
+	CCSSettingValue * GetValueForListWrapper ()
+	{
+	    return RawValueToCCSValue (mRawChildValue);
+	}
+
+	const SettingValueType  &mRawChildValue;
+};
+
+template <typename SettingValueType>
+typename ValueContainer <CCSSettingValueList>::Ptr
+ContainList (const SettingValueType &value)
+{
+    return boost::make_shared <ListValueContainer <SettingValueType> > (value);
+}
+
+class DefaultImplSetParamInterface
+{
+    public:
+
+	typedef boost::shared_ptr <DefaultImplSetParamInterface> Ptr;
+	typedef boost::function <void (MockInitializerFuncs &funcs)> SetUpSettingFunc;
+
+	virtual ~DefaultImplSetParamInterface () {};
+
+	virtual void SetUpSetting (const SetUpSettingFunc &func) = 0;
+	virtual void TearDownSetting () = 0;
+	virtual CCSSettingType GetSettingType () = 0;
+	virtual void         SetUpParam (const CCSSettingPtr &) = 0;
+	virtual Bool setWithInvalidType () = 0;
+	virtual Bool setToFailValue () = 0;
+	virtual Bool setToNonDefaultValue () = 0;
+	virtual Bool setToDefaultValue () = 0;
+};
+
+void stubInitializeSettingInfo (CCSSettingType type,
+				CCSSettingInfo *copyToInfo,
+				void           *data)
+{
+    CCSSettingInfo *copyFromInfo = reinterpret_cast <CCSSettingInfo *> (data);
+
+    ccsCopyInfo (copyFromInfo, copyToInfo, type);
+}
+
+void stubInitializeSettingDefaultValue (CCSSettingType  type,
+					CCSSettingInfo  *info,
+					CCSSettingValue *copyToValue,
+					void           *data)
+{
+    CCSSettingValue *copyFromValue = reinterpret_cast <CCSSettingValue *> (data);
+    CCSSetting      *oldParentForOtherValue = copyFromValue->parent;
+
+    /* Change the parent to this setting that's being initialized
+     * as that needs to go into the setting's default value as
+     * the parent entry */
+    copyFromValue->parent = copyToValue->parent;
+    ccsCopyValueInto (copyFromValue, copyToValue, type, info);
+
+    /* Restore the old parent */
+    copyFromValue->parent = oldParentForOtherValue;
+}
+
+class MockInitializerFuncsWithDelegators :
+    public MockInitializerFuncs
+{
+    public:
+
+	MockInitializerFuncsWithDelegators (CCSSettingInfo  *info,
+					    CCSSettingValue *value) :
+	    MockInitializerFuncs (),
+	    mInfo (info),
+	    mValue (value)
+	{
+	    ON_CALL (*this, initializeInfo (_, _, _))
+		    .WillByDefault (WithArgs <0, 1> (
+					Invoke (this,
+						&MockInitializerFuncsWithDelegators::initializeInfoDelegator)));
+
+	    ON_CALL (*this, initializeDefaultValue (_, _, _, _))
+		    .WillByDefault (WithArgs <0, 1, 2> (
+					Invoke (this,
+						&MockInitializerFuncsWithDelegators::initializeValueDelegator)));
+	}
+
+	void initializeInfoDelegator (CCSSettingType type,
+				      CCSSettingInfo *info)
+	{
+	    stubInitializeSettingInfo (type, info, reinterpret_cast <void *> (mInfo));
+	}
+
+	void initializeValueDelegator (CCSSettingType  type,
+				       CCSSettingInfo  *info,
+				       CCSSettingValue *value)
+	{
+	    stubInitializeSettingDefaultValue (type, info, value,
+					       reinterpret_cast <void *> (mValue));
+	}
+
+	CCSSettingInfo  *mInfo;
+	CCSSettingValue *mValue;
+};
+
+template <typename SettingValueType>
+struct SettingMutators
+{
+    typedef Bool (*SetFunction) (CCSSetting *setting,
+				 SettingValueType data,
+				 Bool);
+    typedef Bool (*GetFunction) (CCSSetting *setting,
+				 SettingValueType *);
+};
+
+class DefaultImplSetParamBase :
+    public DefaultImplSetParamInterface
+{
+    public:
+
+	DefaultImplSetParamBase (const CCSSettingInfoPtr &info,
+				 CCSSettingType          type) :
+	    mInfo (info),
+	    mType (type)
+	{
+	}
+
+	virtual void TearDownSetting ()
+	{
+	    if (mSetting)
+		setToDefaultValue ();
+	}
+
+	void InitializeDefaultsForSetting (const SetUpSettingFunc &func)
+	{
+	    MockInitializerFuncsWithDelegators mockInitializers (mInfo.get (), mValue.get ());
+
+	    func (mockInitializers);
+	}
+
+	void TakeReferenceToCreatedSetting (const CCSSettingPtr &setting)
+	{
+	    mSetting = setting;
+	}
+
+	const CCSSettingInterface * RedirectSettingInterface ()
+	{
+	    const CCSSettingInterface *settingInterface =
+		GET_INTERFACE (CCSSettingInterface, mSetting.get ());
+	    CCSSettingInterface tmpSettingInterface = *settingInterface;
+
+	    tmpSettingInterface.settingGetType =
+		DefaultImplSetParamBase::returnIncorrectSettingType;
+
+	    ccsObjectRemoveInterface (mSetting.get (),
+				      GET_INTERFACE_TYPE (CCSSettingInterface));
+	    ccsObjectAddInterface (mSetting.get (),
+				   (const CCSInterface *) &tmpSettingInterface,
+				   GET_INTERFACE_TYPE (CCSSettingInterface));
+
+	    return settingInterface;
+	}
+
+	void RestoreSettingInterface (const CCSSettingInterface *settingInterface)
+	{
+	    /* Restore the old interface */
+	    ccsObjectRemoveInterface (mSetting.get (),
+				      GET_INTERFACE_TYPE (CCSSettingInterface));
+	    ccsObjectAddInterface (mSetting.get (),
+				   (const CCSInterface *) settingInterface,
+				   GET_INTERFACE_TYPE (CCSSettingInterface));
+	}
+
+	virtual Bool setToFailValue ()
+	{
+	    return TRUE;
+	}
+
+	virtual CCSSettingType GetSettingType ()
+	{
+	    return mType;
+	}
+
+    protected:
+
+	CCSSettingInfoPtr  mInfo;
+	CCSSettingValuePtr mValue;
+	CCSSettingType     mType;
+	CCSSettingPtr      mSetting;
+
+    private:
+
+	static const CCSSettingType incorrectSettingType = TypeNum;
+	static CCSSettingType returnIncorrectSettingType (CCSSetting *setting)
+	{
+	    return incorrectSettingType;
+	}
+};
+
+class RequireSettingInterfaceRedirection
+{
+    public:
+
+	RequireSettingInterfaceRedirection (DefaultImplSetParamBase *base) :
+	    mBase (base),
+	    mSettingInterface (mBase->RedirectSettingInterface ())
+	{
+	}
+
+	~RequireSettingInterfaceRedirection ()
+	{
+	    mBase->RestoreSettingInterface (mSettingInterface);
+	}
+
+    private:
+
+	DefaultImplSetParamBase   *mBase;
+	const CCSSettingInterface *mSettingInterface;
+};
+
+template <typename SettingValueType>
+class DefaultImplSetParamTemplatedBase
+{
+    protected:
+
+	typedef typename ValueContainer <SettingValueType>::Ptr ValueContainerPtr;
+
+	DefaultImplSetParamTemplatedBase (const ValueContainerPtr &defaultValueContainer,
+					  const ValueContainerPtr &nonDefaultValueContainer) :
+	    mDefaultValueContainer (defaultValueContainer),
+	    mNonDefaultValueContainer (nonDefaultValueContainer)
+	{
+	}
+
+	ValueContainerPtr  mDefaultValueContainer;
+	ValueContainerPtr  mNonDefaultValueContainer;
+};
+
+template <typename SettingValueType>
+class DefaultImplSetParam :
+    /* Do not change the order of inheritance here, DefaultImplSetParamTemplatedBase
+     * must be destroyed after DefaultImplSetParamBase as DefaultImplSetParamBase
+     * has indirect weak references to variables in DefaultImplSetParamTemplatedBase
+     */
+   private DefaultImplSetParamTemplatedBase <SettingValueType>,
+   public  DefaultImplSetParamBase
+{
+    public:
+
+	typedef typename SettingMutators <SettingValueType>::SetFunction SetFunction;
+	typedef typename SettingMutators <SettingValueType>::GetFunction GetFunction;
+	typedef typename ValueContainer <SettingValueType>::Ptr ValueContainerPtr;
+	typedef DefaultImplSetParamTemplatedBase <SettingValueType> TemplateParent;
+
+	DefaultImplSetParam (const ValueContainerPtr &defaultValueContainer,
+			     CCSSettingType          type,
+			     SetFunction             setFunction,
+			     GetFunction             getFunction,
+			     const CCSSettingInfoPtr &info,
+			     const ValueContainerPtr &nonDefaultValueContainer) :
+	    DefaultImplSetParamTemplatedBase <SettingValueType> (defaultValueContainer,
+								 nonDefaultValueContainer),
+	    DefaultImplSetParamBase (info, type),
+	    mSetFunction (setFunction),
+	    mGetFunction (getFunction)
+	{
+	}
+
+	virtual void SetUpSetting (const SetUpSettingFunc &func)
+	{
+	    /* Do delayed setup here */
+	    mValue = TemplateParent::mDefaultValueContainer->getContainedValue (mType, mInfo);
+	    mNonDefaultValue = TemplateParent::mNonDefaultValueContainer->getRawValue (mType, mInfo);
+
+	    InitializeDefaultsForSetting (func);
+	}
+
+	virtual void SetUpParam (const CCSSettingPtr &setting)
+	{
+	    ASSERT_TRUE ((*mGetFunction) (setting.get (), &mDefaultValue));
+
+	    TakeReferenceToCreatedSetting (setting);
+	}
+
+	virtual Bool setWithInvalidType ()
+	{
+	    RequireSettingInterfaceRedirection redirection (this);
+
+	    return (*mSetFunction) (mSetting.get (), mNonDefaultValue, FALSE);
+	}
+
+	virtual Bool setToNonDefaultValue ()
+	{
+	    return (*mSetFunction) (mSetting.get (), mNonDefaultValue, FALSE);
+	}
+
+	virtual Bool setToDefaultValue ()
+	{
+	    return (*mSetFunction) (mSetting.get (), mDefaultValue, FALSE);
+	}
+
+    private:
+
+	SettingValueType   mDefaultValue;
+	SettingValueType   mNonDefaultValue;
+
+    protected:
+
+	SetFunction        mSetFunction;
+	GetFunction        mGetFunction;
+
+};
+
+class SetWithDisallowedValueBase
+{
+    protected:
+
+	SetWithDisallowedValueBase (const CCSSettingPtr     &setting,
+				    const CCSSettingInfoPtr &info) :
+	    mSetting (setting),
+	    mInfo (info)
+	{
+	}
+
+	CCSSettingPtr     mSetting;
+	CCSSettingInfoPtr mInfo;
+};
+
+template <typename SettingValueType>
+class SetWithDisallowedValueTemplatedBase :
+    public SetWithDisallowedValueBase
+{
+    protected:
+
+	typedef typename SettingMutators <SettingValueType>::SetFunction SetFunction;
+
+	SetWithDisallowedValueTemplatedBase (SetFunction             setFunction,
+					     const CCSSettingPtr     &setting,
+					     const CCSSettingInfoPtr &info) :
+	    SetWithDisallowedValueBase (setting, info),
+	    mSetFunction (setFunction)
+	{
+	}
+
+	SetFunction       mSetFunction;
+};
+
+template <typename SettingValueType>
+class SetWithDisallowedValue :
+    public SetWithDisallowedValueTemplatedBase <SettingValueType>
+{
+    public:
+
+	typedef typename SettingMutators <SettingValueType>::SetFunction SetFunction;
+
+	SetWithDisallowedValue (SetFunction             setFunction,
+				const CCSSettingPtr     &setting,
+				const CCSSettingInfoPtr &info) :
+	    SetWithDisallowedValueTemplatedBase <SettingValueType> (setFunction, setting, info)
+	{
+	}
+
+	Bool operator () ()
+	{
+	    return FALSE;
+	}
+};
+
+template <>
+class SetWithDisallowedValue <int> :
+    public SetWithDisallowedValueTemplatedBase <int>
+{
+    public:
+
+	typedef typename SettingMutators <int>::SetFunction SetFunction;
+	typedef SetWithDisallowedValueTemplatedBase <int> Parent;
+
+	SetWithDisallowedValue (SetFunction             setFunction,
+				const CCSSettingPtr     &setting,
+				const CCSSettingInfoPtr &info) :
+	    SetWithDisallowedValueTemplatedBase <int> (setFunction, setting, info)
+	{
+	}
+
+	Bool operator () ()
+	{
+	    return (*Parent::mSetFunction) (Parent::mSetting.get (),
+					    Parent::mInfo->forInt.min - 1,
+					    FALSE);
+	}
+};
+
+template <>
+class SetWithDisallowedValue <float> :
+    public SetWithDisallowedValueTemplatedBase <float>
+{
+    public:
+
+	typedef typename SettingMutators <float>::SetFunction SetFunction;
+	typedef SetWithDisallowedValueTemplatedBase <float> Parent;
+
+	SetWithDisallowedValue (SetFunction             setFunction,
+				const CCSSettingPtr     &setting,
+				const CCSSettingInfoPtr &info) :
+	    SetWithDisallowedValueTemplatedBase <float> (setFunction, setting, info)
+	{
+	}
+
+	Bool operator () ()
+	{
+	    return (*Parent::mSetFunction) (Parent::mSetting.get (),
+					    Parent::mInfo->forFloat.min - 1,
+					    FALSE);
+	}
+};
+
+template <>
+class SetWithDisallowedValue <const char *> :
+    public SetWithDisallowedValueTemplatedBase <const char *>
+{
+    public:
+
+	typedef typename SettingMutators <const char *>::SetFunction SetFunction;
+	typedef SetWithDisallowedValueTemplatedBase <const char *> Parent;
+
+	SetWithDisallowedValue (SetFunction             setFunction,
+				const CCSSettingPtr     &setting,
+				const CCSSettingInfoPtr &info) :
+	    SetWithDisallowedValueTemplatedBase <const char *> (setFunction, setting, info)
+	{
+	}
+
+	Bool operator () ()
+	{
+	    return (*Parent::mSetFunction) (Parent::mSetting.get (),
+					    NULL,
+					    FALSE);
+	}
+};
+
+template <typename SettingValueType>
+class DefaultImplSetFailureParam :
+    public DefaultImplSetParam <SettingValueType>
+{
+    public:
+
+	typedef DefaultImplSetParam <SettingValueType> Parent;
+	typedef typename DefaultImplSetParam <SettingValueType>::SetFunction SetFunction;
+	typedef typename DefaultImplSetParam <SettingValueType>::GetFunction GetFunction;
+	typedef typename DefaultImplSetParam <SettingValueType>::ValueContainerPtr ValueContainerPtr;
+
+	DefaultImplSetFailureParam (const ValueContainerPtr &defaultValueContainer,
+				    CCSSettingType          type,
+				    SetFunction             setFunction,
+				    GetFunction             getFunction,
+				    const CCSSettingInfoPtr &info,
+				    const ValueContainerPtr &nonDefaultValueContainer) :
+	    DefaultImplSetParam <SettingValueType> (defaultValueContainer,
+						    type,
+						    setFunction,
+						    getFunction,
+						    info,
+						    nonDefaultValueContainer)
+	{
+	}
+
+	virtual Bool setToFailValue ()
+	{
+	    typedef DefaultImplSetParam <SettingValueType> Parent;
+	    return SetWithDisallowedValue <SettingValueType> (Parent::mSetFunction,
+							      Parent::mSetting,
+							      Parent::mInfo) ();
+	}
+};
+
+template <typename SettingValueType>
+DefaultImplSetParamInterface::Ptr
+SemanticsParamFor (const typename ValueContainer <SettingValueType>::Ptr   &defaultValue,
+		   CCSSettingType                                          type,
+		   typename SettingMutators<SettingValueType>::SetFunction setFunc,
+		   typename SettingMutators<SettingValueType>::GetFunction getFunc,
+		   const CCSSettingInfoPtr                                 &settingInfo,
+		   const typename ValueContainer <SettingValueType>::Ptr   &changeTo)
+{
+    typedef SettingValueType T;
+    return boost::make_shared <DefaultImplSetParam <T> > (defaultValue,
+							  type,
+							  setFunc,
+							  getFunc,
+							  settingInfo,
+							  changeTo);
+}
+
+template <typename SettingValueType>
+DefaultImplSetParamInterface::Ptr
+FailureSemanticsParamFor (const typename ValueContainer <SettingValueType>::Ptr   &defaultValue,
+			  CCSSettingType                                          type,
+			  typename SettingMutators<SettingValueType>::SetFunction setFunc,
+			  typename SettingMutators<SettingValueType>::GetFunction getFunc,
+			  const CCSSettingInfoPtr                                 &settingInfo,
+			  const typename ValueContainer <SettingValueType>::Ptr   &changeTo)
+{
+    typedef SettingValueType T;
+    return boost::make_shared <DefaultImplSetFailureParam <T> > (defaultValue,
+								 type,
+								 setFunc,
+								 getFunc,
+								 settingInfo,
+								 changeTo);
+}
+
+class SettingDefaultImplSet :
+    public CCSSettingDefaultImplTest,
+    public WithParamInterface <DefaultImplSetParamInterface::Ptr>
+{
+    public:
+
+	virtual void SetUp ()
+	{
+	    GetParam ()->SetUpSetting (boost::bind (&CCSSettingDefaultImplTest::SetUpSetting, this, _1));
+	    GetParam ()->SetUpParam (setting);
+	}
+
+	virtual void TearDown ()
+	{
+	    GetParam ()->TearDownSetting ();
+	}
+
+	CCSSettingType GetSettingType ()
+	{
+	    return GetParam ()->GetSettingType ();
+	}
+};
+
+class SettingDefaulImplSetFailure :
+    public SettingDefaultImplSet
+{
+};
+
+}