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)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3493
http://jenkins.qa.ubuntu.com/job/compiz-ci/281/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-ci/./build=pbuilder,distribution=quantal,flavor=amd64/281/console

Click here to trigger a rebuild:
http://jenkins.qa.ubuntu.com/job/compiz-ci/281//rebuild/?

review: Approve (continuous-integration)

[Sam Spilsbury (smspillaz)]

Ping, other work is blocked on this

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3494
http://jenkins.qa.ubuntu.com/job/compiz-ci/289/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-ci/./build=pbuilder,distribution=quantal,flavor=amd64/289/console

Click here to trigger a rebuild:
http://jenkins.qa.ubuntu.com/job/compiz-ci/289//rebuild/?

review: Approve (continuous-integration)

[Daniel van Vugt (vanvugt)]

1. As usual, I find it unreadable due to the long lines, from long identifiers and template use everywhere.

2. Can you find a better name for: class RequireSettingInterfaceRedirection ? There seems to be no (strong enough) noun really describing what an instance of such a thing is. How do I visualize a RequireSettingInterfaceRedirection in my model of the world? Is "redirection" the noun? Sounds more like an operation so would be a method of some other class.

review: Needs Information

[Sam Spilsbury (smspillaz)]

On Dec 4, 2012 11:59 AM, "Daniel van Vugt" <email address hidden>
wrote:
>
> Review: Needs Information
>
> 1. As usual, I find it unreadable due to the long lines, from long
identifiers and template use everywhere.
>

Can you identify which lines you find problematic, and provide alternative
solutions please?

> 2. Can you find a better name for: class
RequireSettingInterfaceRedirection ? There seems to be no (strong enough)
noun really describing what an instance of such a thing is. How do I
visualize a RequireSettingInterfaceRedirection in my model of the world? Is
"redirection" the noun? Sounds more like an operation so would be a method
of some other class.

Its meant to be a state that automatically cleans up. Hence the reason why
its a class.

Its only really used once though, so I suppose it can be changed to:

->RedirectGetTypeFunc ()
->DoThing ()
->UnredirectGetTypeFunc ()

>
>
> --
>
https://code.launchpad.net/~compiz-team/compiz/compiz.fix_1063617.7/+merge/136917
> Your team Compiz Maintainers is subscribed to branch lp:compiz.

[Daniel van Vugt (vanvugt)]

Identifiers too long:
  * "Initialize" should be "Init"
  * "Interface" and "Impl" are implied by the context and should be obvious from the rest of the class name, if not the namespace. So you should never need to say "Interface", "Impl" or "Base".
  * Many parameters are excessively descriptive and sometimes misleading. For example "copyToValue"/"copyFromValue" could be better represented as nouns: "dest"/"src".
  * ValueContainerPtr mDefaultValueContainer; ValueContainerPtr mNonDefaultValueContainer; ... I already know they are ValueContainers. You rarely need to put the type name in the variable name. The variable name is already half the description of a variable.
  * "WithParamInterface" as a template name. How does the "With" prefix make sense?
  * "MockInitializerFuncsWithDelegators" as a class name... The "With" suffix is unusual and hinders readability because the primary noun is no longer at the end (contrary to English grammar). Consider rewording "WithWhatever" suffixes into a prefix of some sort.
  * "SemanticsParamFor" and "FailureSemanticsParamFor" are unreadable because the types of the parameters dominate the function definition, mostly due to templates. I don't have an understanding of the code to suggest any alternatives right now, other than templates should only ever be used scarcely.

Finally, remember carefully chosen English is only half the problem in readable code. The other half is realizing code is mostly symbolic. You should see the structure and flow without having to read the words themselves. And remember we recognize words or identifiers as symbols. So if an identifier is made up of too many words it becomes unrecognisable as a symbol and easily mistaken for some other identifier with similar spelling.

But enough said. I've said it all before.

review: Approve

[Sam Spilsbury (smspillaz)]

Thanks for the advice.

I'll have another look today to see where we can simplify some of the class
names (they are a bit lame).
On Dec 4, 2012 1:29 PM, "Daniel van Vugt" <email address hidden>
wrote:

> Review: Approve
>
> Identifiers too long:
> * "Initialize" should be "Init"
> * "Interface" and "Impl" are implied by the context and should be
> obvious from the rest of the class name, if not the namespace. So you
> should never need to say "Interface", "Impl" or "Base".
> * Many parameters are excessively descriptive and sometimes misleading.
> For example "copyToValue"/"copyFromValue" could be better represented as
> nouns: "dest"/"src".
> * ValueContainerPtr mDefaultValueContainer; ValueContainerPtr
> mNonDefaultValueContainer; ... I already know they are ValueContainers.
> You rarely need to put the type name in the variable name. The variable
> name is already half the description of a variable.
> * "WithParamInterface" as a template name. How does the "With" prefix
> make sense?
> * "MockInitializerFuncsWithDelegators" as a class name... The "With"
> suffix is unusual and hinders readability because the primary noun is no
> longer at the end (contrary to English grammar). Consider rewording
> "WithWhatever" suffixes into a prefix of some sort.
> * "SemanticsParamFor" and "FailureSemanticsParamFor" are unreadable
> because the types of the parameters dominate the function definition,
> mostly due to templates. I don't have an understanding of the code to
> suggest any alternatives right now, other than templates should only ever
> be used scarcely.
>
> Finally, remember carefully chosen English is only half the problem in
> readable code. The other half is realizing code is mostly symbolic. You
> should see the structure and flow without having to read the words
> themselves. And remember we recognize words or identifiers as symbols. So
> if an identifier is made up of too many words it becomes unrecognisable as
> a symbol and easily mistaken for some other identifier with similar
> spelling.
>
> But enough said. I've said it all before.
>
> --
>
> https://code.launchpad.net/~compiz-team/compiz/compiz.fix_1063617.7/+merge/136917
> Your team Compiz Maintainers is subscribed to branch lp:compiz.
>

[Sam Spilsbury (smspillaz)]

On Dec 4, 2012 1:29 PM, "Daniel van Vugt" <email address hidden>
wrote:
>
> Review: Approve
>
> Identifiers too long:
> * "Initialize" should be "Init"

I'll change that.

> * "Interface" and "Impl" are implied by the context and should be
obvious from the rest of the class name, if not the namespace. So you
should never need to say "Interface", "Impl" or "Base".

I agree with this, although the structural separation is necessary.

Either I can use the namespace trick, I'll give this a little more thought
and see what works.

> * Many parameters are excessively descriptive and sometimes misleading.
For example "copyToValue"/"copyFromValue" could be better represented as
nouns: "dest"/"src".

+1

> * ValueContainerPtr mDefaultValueContainer; ValueContainerPtr
 mNonDefaultValueContainer; ... I already know they are ValueContainers.
You rarely need to put the type name in the variable name. The variable
name is already half the description of a variable.

+1 . They can become mDefaultValue and mNonDefaultValue

> * "WithParamInterface" as a template name. How does the "With" prefix
make sense?

This is lame, but it comes from Google Test.

> * "MockInitializerFuncsWithDelegators" as a class name... The "With"
suffix is unusual and hinders readability because the primary noun is no
longer at the end (contrary to English grammar). Consider rewording
"WithWhatever" suffixes into a prefix of some sort.

This can become StubVerifiedSettingInitializers

> * "SemanticsParamFor" and "FailureSemanticsParamFor" are unreadable
because the types of the parameters dominate the function definition,
mostly due to templates. I don't have an understanding of the code to
suggest any alternatives right now, other than templates should only ever
be used scarcely.

Yeah, the only reason why templates were used was that there would be far
too much code repetition any other way.

>
> Finally, remember carefully chosen English is only half the problem in
readable code. The other half is realizing code is mostly symbolic. You
should see the structure and flow without having to read the words
themselves. And remember we recognize words or identifiers as symbols. So
if an identifier is made up of too many words it becomes unrecognisable as
a symbol and easily mistaken for some other identifier with similar
spelling.

Yeah, I agree with this. Sadly english is not too good at dealing with this
problem.

Have another look at this tomorrow, I'll fix up some of the names tonight.

>
> But enough said. I've said it all before.
>
> --
>
https://code.launchpad.net/~compiz-team/compiz/compiz.fix_1063617.7/+merge/136917
> Your team Compiz Maintainers is subscribed to branch lp:compiz.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3497
http://jenkins.qa.ubuntu.com/job/compiz-ci/292/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-ci/./build=pbuilder,distribution=quantal,flavor=amd64/292/console

Click here to trigger a rebuild:
http://jenkins.qa.ubuntu.com/job/compiz-ci/292//rebuild/?

review: Approve (continuous-integration)

[Daniel van Vugt (vanvugt)]

review: Approve

[Sam Spilsbury (smspillaz)]

review: Approve

[Sam Spilsbury (smspillaz)]

(merged trunk)

[PS Jenkins bot (ps-jenkins)]

FAILED: Autolanding.
Unapproved changes made after approval.
http://jenkins.qa.ubuntu.com/job/compiz-mbs-autolanding/119/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-mbs-autolanding/./build=pbuilder,distribution=quantal,flavor=amd64/119/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-mbs-autolanding/./build=pbuilder,distribution=quantal,flavor=i386/119/console

review: Needs Fixing (continuous-integration)

=== modified file 'compizconfig/libcompizconfig/tests/compizconfig_test_ccs_setting.cpp'
--- compizconfig/libcompizconfig/tests/compizconfig_test_ccs_setting.cpp	2012-11-26 08:06:08 +0000
+++ compizconfig/libcompizconfig/tests/compizconfig_test_ccs_setting.cpp	2012-12-05 06:00:30 +0000
@@ -40,6 +40,9 @@
 using ::testing::_;
 using ::testing::Return;
 using ::testing::InSequence;
+using ::testing::WithArgs;
+using ::testing::WithParamInterface;
+using ::testing::Invoke;
 using ::testing::ReturnNull;
 
 TEST(CCSSettingTest, TestMock)
@@ -146,28 +149,28 @@
 typedef boost::shared_ptr <CCSSettingValue> CCSSettingValuePtr;
 typedef boost::shared_ptr <CCSSetting> CCSSettingPtr;
 
-class MockInitializerFuncs
+class MockInitFuncs
 {
     public:
 
-	MOCK_METHOD3 (initializeInfo, void (CCSSettingType, CCSSettingInfo *, void *));
-	MOCK_METHOD4 (initializeDefaultValue, void (CCSSettingType, CCSSettingInfo *, CCSSettingValue *, void *));
+	MOCK_METHOD3 (initInfo, void (CCSSettingType, CCSSettingInfo *, void *));
+	MOCK_METHOD4 (initDefaultValue, void (CCSSettingType, CCSSettingInfo *, CCSSettingValue *, void *));
 
-	static void wrapInitializeInfo (CCSSettingType type,
-					CCSSettingInfo *info,
-					void           *data)
+	static void wrapInitInfo (CCSSettingType type,
+				  CCSSettingInfo *info,
+				  void           *data)
 	{
-	    MockInitializerFuncs &funcs (*(reinterpret_cast <MockInitializerFuncs *> (data)));
-	    funcs.initializeInfo (type, info, data);
+	    MockInitFuncs &funcs (*(reinterpret_cast <MockInitFuncs *> (data)));
+	    funcs.initInfo (type, info, data);
 	}
 
-	static void wrapInitializeValue (CCSSettingType  type,
-					 CCSSettingInfo  *info,
-					 CCSSettingValue *value,
-					 void            *data)
+	static void wrapInitValue (CCSSettingType  type,
+				   CCSSettingInfo  *info,
+				   CCSSettingValue *value,
+				   void            *data)
 	{
-	    MockInitializerFuncs &funcs (*(reinterpret_cast <MockInitializerFuncs *> (data)));
-	    funcs.initializeDefaultValue (type, info, value, data);
+	    MockInitFuncs &funcs (*(reinterpret_cast <MockInitFuncs *> (data)));
+	    funcs.initDefaultValue (type, info, value, data);
 	}
 };
 
@@ -178,7 +181,6 @@
 const std::string SETTING_SUBGROUP = "Sub Group";
 const std::string SETTING_HINTS = "Hints";
 const CCSSettingType SETTING_TYPE = TypeInt;
-}
 
 class CCSSettingDefaultImplTest :
     public ::testing::Test
@@ -192,15 +194,15 @@
 	{
 	}
 
-	virtual void SetUpSetting (MockInitializerFuncs &funcs)
+	virtual void SetUpSetting (MockInitFuncs &funcs)
 	{
 	    void                 *vFuncs = reinterpret_cast <void *> (&funcs);
 
 	    /* Info must be initialized before the value */
 	    InSequence s;
 
-	    EXPECT_CALL (funcs, initializeInfo (GetSettingType (), _, vFuncs));
-	    EXPECT_CALL (funcs, initializeDefaultValue (GetSettingType (), _, _, vFuncs));
+	    EXPECT_CALL (funcs, initInfo (GetSettingType (), _, vFuncs));
+	    EXPECT_CALL (funcs, initDefaultValue (GetSettingType (), _, _, vFuncs));
 
 	    setting = AutoDestroy (ccsSettingDefaultImplNew (plugin.get (),
 							     SETTING_NAME.c_str (),
@@ -210,9 +212,9 @@
 							     SETTING_HINTS.c_str (),
 							     SETTING_GROUP.c_str (),
 							     SETTING_SUBGROUP.c_str (),
-							     MockInitializerFuncs::wrapInitializeValue,
+							     MockInitFuncs::wrapInitValue,
 							     vFuncs,
-							     MockInitializerFuncs::wrapInitializeInfo,
+							     MockInitFuncs::wrapInitInfo,
 							     vFuncs,
 							     &ccsDefaultObjectAllocator,
 							     &ccsDefaultInterfaceTable),
@@ -221,7 +223,7 @@
 
 	virtual void SetUp ()
 	{
-	    MockInitializerFuncs funcs;
+	    MockInitFuncs funcs;
 
 	    SetUpSetting (funcs);
 
@@ -237,6 +239,8 @@
 	boost::shared_ptr <CCSSetting> setting;
 };
 
+}
+
 TEST_F (CCSSettingDefaultImplTest, Construction)
 {
     EXPECT_EQ (SETTING_TYPE, ccsSettingGetType (setting.get ()));
@@ -384,30 +388,30 @@
     private:
 
 	const CCSSettingValuePtr &
-	InitializedSpawnedValue (const CCSSettingValuePtr &value,
-				 CCSSettingType           type,
-				 const CCSSettingInfoPtr  &info)
+	InitValue (const CCSSettingValuePtr &value,
+		   CCSSettingType           type,
+		   const CCSSettingInfoPtr  &info)
 	{
 	    const CCSSettingPtr &setting (GetSetting (type, info));
 	    value->parent = setting.get ();
-	    mContainedValues.push_back (value);
+	    mValues.push_back (value);
 
-	    return mContainedValues.back ();
+	    return mValues.back ();
 	}
 
     public:
 
 	template <typename SettingValueType>
 	const CCSSettingValuePtr &
-	SpawnValueForInfoAndType (const SettingValueType  &rawValue,
-				  CCSSettingType          type,
-				  const CCSSettingInfoPtr &info)
+	SpawnValue (const SettingValueType  &rawValue,
+		    CCSSettingType          type,
+		    const CCSSettingInfoPtr &info)
 	{
 
 	    CCSSettingValuePtr  value (AutoDestroy (RawValueToCCSValue <SettingValueType> (rawValue),
 						    ccsSettingValueUnref));
 
-	    return InitializedSpawnedValue (value, type, info);
+	    return InitValue (value, type, info);
 	}
 
 	const CCSSettingPtr &
@@ -446,7 +450,7 @@
 	 * as the values hold a weak reference to
 	 * it */
 	CCSSettingPtr                    mSetting;
-	std::vector <CCSSettingValuePtr> mContainedValues;
+	std::vector <CCSSettingValuePtr> mValues;
 
 };
 
@@ -470,8 +474,8 @@
 {
     protected:
 
-	ContainedValueGenerator  mContainedValueGenerator;
-	CCSSettingValuePtr       mContainedValue;
+	ContainedValueGenerator  mGenerator;
+	CCSSettingValuePtr       mValue;
 };
 
 template <typename SettingValueType>
@@ -497,12 +501,12 @@
 	getContainedValue (CCSSettingType          type,
 			   const CCSSettingInfoPtr &info)
 	{
-	    if (!mContainedValue)
-		mContainedValue = mContainedValueGenerator.SpawnValueForInfoAndType (mRawValue,
-										     type,
-										     info);
+	    if (!mValue)
+		mValue = mGenerator.SpawnValue (mRawValue,
+						type,
+						info);
 
-	    return mContainedValue;
+	    return mValue;
 	}
 
     private:
@@ -531,9 +535,9 @@
 		const cci::SettingValueListWrapper::Ptr &wrapper (SetupWrapper (type, info));
 
 		mContainedWrapper =
-			mContainedValueGenerator.SpawnValueForInfoAndType (wrapper,
-									   type,
-									   info);
+			mContainedValueGenerator.SpawnValue (wrapper,
+							     type,
+							     info);
 	    }
 
 	    return mContainedWrapper;
@@ -612,6 +616,92 @@
     return boost::make_shared <ListValueContainer <SettingValueType> > (value);
 }
 
+class SetParam
+{
+    public:
+
+	typedef boost::shared_ptr <SetParam> Ptr;
+	typedef boost::function <void (MockInitFuncs &funcs)> SetUpSettingFunc;
+
+	virtual ~SetParam () {};
+
+	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 stubInitInfo (CCSSettingType type,
+		   CCSSettingInfo *dst,
+		   void           *data)
+{
+    CCSSettingInfo *src = reinterpret_cast <CCSSettingInfo *> (data);
+
+    ccsCopyInfo (src, dst, type);
+}
+
+void stubInitDefaultValue (CCSSettingType  type,
+			   CCSSettingInfo  *info,
+			   CCSSettingValue *dest,
+			   void           *data)
+{
+    CCSSettingValue *src = reinterpret_cast <CCSSettingValue *> (data);
+    CCSSetting      *oldDestParent = src->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 */
+    src->parent = dest->parent;
+    ccsCopyValueInto (src, dest, type, info);
+
+    /* Restore the old parent */
+    src->parent = oldDestParent;
+}
+
+class StubInitFuncs :
+    public MockInitFuncs
+{
+    public:
+
+	StubInitFuncs (CCSSettingInfo  *info,
+		       CCSSettingValue *value) :
+	    MockInitFuncs (),
+	    mInfo (info),
+	    mValue (value)
+	{
+	    ON_CALL (*this, initInfo (_, _, _))
+		    .WillByDefault (WithArgs <0, 1> (
+					Invoke (this,
+						&StubInitFuncs::initInfo)));
+
+	    ON_CALL (*this, initDefaultValue (_, _, _, _))
+		    .WillByDefault (WithArgs <0, 1, 2> (
+					Invoke (this,
+						&StubInitFuncs::initializeValue)));
+	}
+
+	void initInfo (CCSSettingType type,
+		       CCSSettingInfo *info)
+	{
+	    stubInitInfo (type, info, reinterpret_cast <void *> (mInfo));
+	}
+
+	void initializeValue (CCSSettingType  type,
+			      CCSSettingInfo  *info,
+			      CCSSettingValue *value)
+	{
+	    stubInitDefaultValue (type, info, value,
+				  reinterpret_cast <void *> (mValue));
+	}
+
+	CCSSettingInfo  *mInfo;
+	CCSSettingValue *mValue;
+};
+
 template <typename SettingValueType>
 struct SettingMutators
 {
@@ -622,6 +712,185 @@
 				 SettingValueType *);
 };
 
+class InternalSetParam :
+    public SetParam
+{
+    protected:
+
+	InternalSetParam (const CCSSettingInfoPtr &info,
+				 CCSSettingType          type) :
+	    mInfo (info),
+	    mType (type)
+	{
+	}
+
+	virtual void TearDownSetting ()
+	{
+	    if (mSetting)
+		setToDefaultValue ();
+	}
+
+	void InitDefaultsForSetting (const SetUpSettingFunc &func)
+	{
+	    StubInitFuncs stubInitializers (mInfo.get (), mValue.get ());
+
+	    func (stubInitializers);
+	}
+
+	void TakeReferenceToCreatedSetting (const CCSSettingPtr &setting)
+	{
+	    mSetting = setting;
+	}
+
+	const CCSSettingInterface * RedirectSettingInterface ()
+	{
+	    const CCSSettingInterface *settingInterface =
+		GET_INTERFACE (CCSSettingInterface, mSetting.get ());
+	    CCSSettingInterface tmpSettingInterface = *settingInterface;
+
+	    tmpSettingInterface.settingGetType =
+		InternalSetParam::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;
+	}
+};
+
+template <typename SettingValueType>
+class SetParamContainerStorage
+{
+    protected:
+
+	typedef typename ValueContainer <SettingValueType>::Ptr ValueContainerPtr;
+
+	SetParamContainerStorage (const ValueContainerPtr &defaultValue,
+				  const ValueContainerPtr &nonDefaultValue) :
+	    mDefault (defaultValue),
+	    mNonDefault (nonDefaultValue)
+	{
+	}
+
+	ValueContainerPtr  mDefault;
+	ValueContainerPtr  mNonDefault;
+};
+
+template <typename SettingValueType>
+class TypedSetParam :
+    /* 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 SetParamContainerStorage <SettingValueType>,
+   public  InternalSetParam
+{
+    public:
+
+	typedef typename SettingMutators <SettingValueType>::SetFunction SetFunction;
+	typedef typename SettingMutators <SettingValueType>::GetFunction GetFunction;
+	typedef typename ValueContainer <SettingValueType>::Ptr ValueContainerPtr;
+	typedef SetParamContainerStorage <SettingValueType> TemplateParent;
+
+	TypedSetParam (const ValueContainerPtr &defaultValue,
+		       CCSSettingType          type,
+		       SetFunction             setFunction,
+		       GetFunction             getFunction,
+		       const CCSSettingInfoPtr &info,
+		       const ValueContainerPtr &nonDefaultValue) :
+	    SetParamContainerStorage <SettingValueType> (defaultValue,
+								 nonDefaultValue),
+	    InternalSetParam (info, type),
+	    mSetFunction (setFunction),
+	    mGetFunction (getFunction)
+	{
+	}
+
+	virtual void SetUpSetting (const SetUpSettingFunc &func)
+	{
+	    /* Do delayed setup here */
+	    mValue = TemplateParent::mDefault->getContainedValue (mType, mInfo);
+	    mNonDefaultValue = TemplateParent::mNonDefault->getRawValue (mType, mInfo);
+
+	    InitDefaultsForSetting (func);
+	}
+
+	virtual void SetUpParam (const CCSSettingPtr &setting)
+	{
+	    ASSERT_TRUE ((*mGetFunction) (setting.get (), &mDefaultValue));
+
+	    TakeReferenceToCreatedSetting (setting);
+	}
+
+	virtual Bool setWithInvalidType ()
+	{
+	    CCSSettingInterface *iface = RedirectSettingInterface ();
+	    Bool ret = (*mSetFunction) (mSetting.get (), mNonDefaultValue, FALSE);
+	    RestoreSettingInterface (iface);
+
+	    return ret;
+	}
+
+	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:
@@ -749,4 +1018,101 @@
 	}
 };
 
+template <typename SettingValueType>
+class SetFailureParam :
+    public TypedSetParam <SettingValueType>
+{
+    public:
+
+	typedef TypedSetParam <SettingValueType> Parent;
+	typedef typename TypedSetParam <SettingValueType>::SetFunction SetFunction;
+	typedef typename TypedSetParam <SettingValueType>::GetFunction GetFunction;
+	typedef typename TypedSetParam <SettingValueType>::ValueContainerPtr ValueContainerPtr;
+
+	SetFailureParam (const ValueContainerPtr &defaultValue,
+			 CCSSettingType          type,
+			 SetFunction             setFunction,
+			 GetFunction             getFunction,
+			 const CCSSettingInfoPtr &info,
+			 const ValueContainerPtr &nonDefault) :
+	    TypedSetParam <SettingValueType> (defaultValue,
+					      type,
+					      setFunction,
+					      getFunction,
+					      info,
+					      nonDefault)
+	{
+	}
+
+	virtual Bool setToFailValue ()
+	{
+	    typedef TypedSetParam <SettingValueType> Parent;
+	    return SetWithDisallowedValue <SettingValueType> (Parent::mSetFunction,
+							      Parent::mSetting,
+							      Parent::mInfo) ();
+	}
+};
+
+template <typename T>
+SetParam::Ptr
+SemanticsParamFor (const typename ValueContainer <T>::Ptr   &defaultValue,
+		   CCSSettingType                           type,
+		   typename SettingMutators<T>::SetFunction setFunc,
+		   typename SettingMutators<T>::GetFunction getFunc,
+		   const CCSSettingInfoPtr                  &settingInfo,
+		   const typename ValueContainer <T>::Ptr   &changeTo)
+{
+    return boost::make_shared <TypedSetParam <T> > (defaultValue,
+						    type,
+						    setFunc,
+						    getFunc,
+						    settingInfo,
+						    changeTo);
+}
+
+template <typename T>
+SetParam::Ptr
+FailureSemanticsParamFor (const typename ValueContainer <T>::Ptr   &defaultValue,
+			  CCSSettingType			   type,
+			  typename SettingMutators<T>::SetFunction setFunc,
+			  typename SettingMutators<T>::GetFunction getFunc,
+			  const CCSSettingInfo			   &settingInfo,
+			  const typename ValueContainer <T>::Ptr   &changeTo)
+{
+    return boost::make_shared <SetFailureParam <T> > (defaultValue,
+						      type,
+						      setFunc,
+						      getFunc,
+						      settingInfo,
+						      changeTo);
+}
+
+class SettingDefaultImplSet :
+    public CCSSettingDefaultImplTest,
+    public WithParamInterface <SetParam::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
+{
+};
+
 }