← Back to branch summary

~brandontschaefer/compiz/lp1002246_fix

« back to all changes in this revision

Viewing changes to compizconfig/libcompizconfig/tests/compizconfig_test_ccs_setting.cpp

  • Committer: Tarmac
  • Author(s): Sam Spilsbury
  • Date: 2012-12-05 13:06:14 UTC
  • mfrom: (3480.8.13 compiz.fix_1063617.7)
  • Revision ID: tarmac-20121205130614-xdye6keqb6puh6b2
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. Fixes: https://bugs.launchpad.net/bugs/1063617.

Approved by Sam Spilsbury, Daniel van Vugt.

Show diffs side-by-side

added added

removed removed

Lines of Context:
compizconfig/libcompizconfig/tests/compizconfig_test_ccs_setting.cpp
40
40
using ::testing::_;
41
41
using ::testing::Return;
42
42
using ::testing::InSequence;
 
43
using ::testing::WithArgs;
 
44
using ::testing::WithParamInterface;
 
45
using ::testing::Invoke;
43
46
using ::testing::ReturnNull;
44
47
 
45
48
TEST(CCSSettingTest, TestMock)
146
149
typedef boost::shared_ptr <CCSSettingValue> CCSSettingValuePtr;
147
150
typedef boost::shared_ptr <CCSSetting> CCSSettingPtr;
148
151
 
149
 
class MockInitializerFuncs
 
152
class MockInitFuncs
150
153
{
151
154
    public:
152
155
 
153
 
        MOCK_METHOD3 (initializeInfo, void (CCSSettingType, CCSSettingInfo *, void *));
154
 
        MOCK_METHOD4 (initializeDefaultValue, void (CCSSettingType, CCSSettingInfo *, CCSSettingValue *, void *));
 
156
        MOCK_METHOD3 (initInfo, void (CCSSettingType, CCSSettingInfo *, void *));
 
157
        MOCK_METHOD4 (initDefaultValue, void (CCSSettingType, CCSSettingInfo *, CCSSettingValue *, void *));
155
158
 
156
 
        static void wrapInitializeInfo (CCSSettingType type,
157
 
                                        CCSSettingInfo *info,
158
 
                                        void           *data)
 
159
        static void wrapInitInfo (CCSSettingType type,
 
160
                                  CCSSettingInfo *info,
 
161
                                  void           *data)
159
162
        {
160
 
            MockInitializerFuncs &funcs (*(reinterpret_cast <MockInitializerFuncs *> (data)));
161
 
            funcs.initializeInfo (type, info, data);
 
163
            MockInitFuncs &funcs (*(reinterpret_cast <MockInitFuncs *> (data)));
 
164
            funcs.initInfo (type, info, data);
162
165
        }
163
166
 
164
 
        static void wrapInitializeValue (CCSSettingType  type,
165
 
                                         CCSSettingInfo  *info,
166
 
                                         CCSSettingValue *value,
167
 
                                         void            *data)
 
167
        static void wrapInitValue (CCSSettingType  type,
 
168
                                   CCSSettingInfo  *info,
 
169
                                   CCSSettingValue *value,
 
170
                                   void            *data)
168
171
        {
169
 
            MockInitializerFuncs &funcs (*(reinterpret_cast <MockInitializerFuncs *> (data)));
170
 
            funcs.initializeDefaultValue (type, info, value, data);
 
172
            MockInitFuncs &funcs (*(reinterpret_cast <MockInitFuncs *> (data)));
 
173
            funcs.initDefaultValue (type, info, value, data);
171
174
        }
172
175
};
173
176
 
178
181
const std::string SETTING_SUBGROUP = "Sub Group";
179
182
const std::string SETTING_HINTS = "Hints";
180
183
const CCSSettingType SETTING_TYPE = TypeInt;
181
 
}
182
184
 
183
185
class CCSSettingDefaultImplTest :
184
186
    public ::testing::Test
192
194
        {
193
195
        }
194
196
 
195
 
        virtual void SetUpSetting (MockInitializerFuncs &funcs)
 
197
        virtual void SetUpSetting (MockInitFuncs &funcs)
196
198
        {
197
199
            void                 *vFuncs = reinterpret_cast <void *> (&funcs);
198
200
 
199
201
            /* Info must be initialized before the value */
200
202
            InSequence s;
201
203
 
202
 
            EXPECT_CALL (funcs, initializeInfo (GetSettingType (), _, vFuncs));
203
 
            EXPECT_CALL (funcs, initializeDefaultValue (GetSettingType (), _, _, vFuncs));
 
204
            EXPECT_CALL (funcs, initInfo (GetSettingType (), _, vFuncs));
 
205
            EXPECT_CALL (funcs, initDefaultValue (GetSettingType (), _, _, vFuncs));
204
206
 
205
207
            setting = AutoDestroy (ccsSettingDefaultImplNew (plugin.get (),
206
208
                                                             SETTING_NAME.c_str (),
210
212
                                                             SETTING_HINTS.c_str (),
211
213
                                                             SETTING_GROUP.c_str (),
212
214
                                                             SETTING_SUBGROUP.c_str (),
213
 
                                                             MockInitializerFuncs::wrapInitializeValue,
 
215
                                                             MockInitFuncs::wrapInitValue,
214
216
                                                             vFuncs,
215
 
                                                             MockInitializerFuncs::wrapInitializeInfo,
 
217
                                                             MockInitFuncs::wrapInitInfo,
216
218
                                                             vFuncs,
217
219
                                                             &ccsDefaultObjectAllocator,
218
220
                                                             &ccsDefaultInterfaceTable),
221
223
 
222
224
        virtual void SetUp ()
223
225
        {
224
 
            MockInitializerFuncs funcs;
 
226
            MockInitFuncs funcs;
225
227
 
226
228
            SetUpSetting (funcs);
227
229
 
237
239
        boost::shared_ptr <CCSSetting> setting;
238
240
};
239
241
 
 
242
}
 
243
 
240
244
TEST_F (CCSSettingDefaultImplTest, Construction)
241
245
{
242
246
    EXPECT_EQ (SETTING_TYPE, ccsSettingGetType (setting.get ()));
384
388
    private:
385
389
 
386
390
        const CCSSettingValuePtr &
387
 
        InitializedSpawnedValue (const CCSSettingValuePtr &value,
388
 
                                 CCSSettingType           type,
389
 
                                 const CCSSettingInfoPtr  &info)
 
391
        InitValue (const CCSSettingValuePtr &value,
 
392
                   CCSSettingType           type,
 
393
                   const CCSSettingInfoPtr  &info)
390
394
        {
391
395
            const CCSSettingPtr &setting (GetSetting (type, info));
392
396
            value->parent = setting.get ();
393
 
            mContainedValues.push_back (value);
 
397
            mValues.push_back (value);
394
398
 
395
 
            return mContainedValues.back ();
 
399
            return mValues.back ();
396
400
        }
397
401
 
398
402
    public:
399
403
 
400
404
        template <typename SettingValueType>
401
405
        const CCSSettingValuePtr &
402
 
        SpawnValueForInfoAndType (const SettingValueType  &rawValue,
403
 
                                  CCSSettingType          type,
404
 
                                  const CCSSettingInfoPtr &info)
 
406
        SpawnValue (const SettingValueType  &rawValue,
 
407
                    CCSSettingType          type,
 
408
                    const CCSSettingInfoPtr &info)
405
409
        {
406
410
 
407
411
            CCSSettingValuePtr  value (AutoDestroy (RawValueToCCSValue <SettingValueType> (rawValue),
408
412
                                                    ccsSettingValueUnref));
409
413
 
410
 
            return InitializedSpawnedValue (value, type, info);
 
414
            return InitValue (value, type, info);
411
415
        }
412
416
 
413
417
        const CCSSettingPtr &
446
450
         * as the values hold a weak reference to
447
451
         * it */
448
452
        CCSSettingPtr                    mSetting;
449
 
        std::vector <CCSSettingValuePtr> mContainedValues;
 
453
        std::vector <CCSSettingValuePtr> mValues;
450
454
 
451
455
};
452
456
 
470
474
{
471
475
    protected:
472
476
 
473
 
        ContainedValueGenerator  mContainedValueGenerator;
474
 
        CCSSettingValuePtr       mContainedValue;
 
477
        ContainedValueGenerator  mGenerator;
 
478
        CCSSettingValuePtr       mValue;
475
479
};
476
480
 
477
481
template <typename SettingValueType>
497
501
        getContainedValue (CCSSettingType          type,
498
502
                           const CCSSettingInfoPtr &info)
499
503
        {
500
 
            if (!mContainedValue)
501
 
                mContainedValue = mContainedValueGenerator.SpawnValueForInfoAndType (mRawValue,
502
 
                                                                                     type,
503
 
                                                                                     info);
 
504
            if (!mValue)
 
505
                mValue = mGenerator.SpawnValue (mRawValue,
 
506
                                                type,
 
507
                                                info);
504
508
 
505
 
            return mContainedValue;
 
509
            return mValue;
506
510
        }
507
511
 
508
512
    private:
531
535
                const cci::SettingValueListWrapper::Ptr &wrapper (SetupWrapper (type, info));
532
536
 
533
537
                mContainedWrapper =
534
 
                        mContainedValueGenerator.SpawnValueForInfoAndType (wrapper,
535
 
                                                                           type,
536
 
                                                                           info);
 
538
                        mContainedValueGenerator.SpawnValue (wrapper,
 
539
                                                             type,
 
540
                                                             info);
537
541
            }
538
542
 
539
543
            return mContainedWrapper;
612
616
    return boost::make_shared <ListValueContainer <SettingValueType> > (value);
613
617
}
614
618
 
 
619
class SetParam
 
620
{
 
621
    public:
 
622
 
 
623
        typedef boost::shared_ptr <SetParam> Ptr;
 
624
        typedef boost::function <void (MockInitFuncs &funcs)> SetUpSettingFunc;
 
625
 
 
626
        virtual ~SetParam () {};
 
627
 
 
628
        virtual void SetUpSetting (const SetUpSettingFunc &func) = 0;
 
629
        virtual void TearDownSetting () = 0;
 
630
        virtual CCSSettingType GetSettingType () = 0;
 
631
        virtual void         SetUpParam (const CCSSettingPtr &) = 0;
 
632
        virtual Bool setWithInvalidType () = 0;
 
633
        virtual Bool setToFailValue () = 0;
 
634
        virtual Bool setToNonDefaultValue () = 0;
 
635
        virtual Bool setToDefaultValue () = 0;
 
636
};
 
637
 
 
638
void stubInitInfo (CCSSettingType type,
 
639
                   CCSSettingInfo *dst,
 
640
                   void           *data)
 
641
{
 
642
    CCSSettingInfo *src = reinterpret_cast <CCSSettingInfo *> (data);
 
643
 
 
644
    ccsCopyInfo (src, dst, type);
 
645
}
 
646
 
 
647
void stubInitDefaultValue (CCSSettingType  type,
 
648
                           CCSSettingInfo  *info,
 
649
                           CCSSettingValue *dest,
 
650
                           void           *data)
 
651
{
 
652
    CCSSettingValue *src = reinterpret_cast <CCSSettingValue *> (data);
 
653
    CCSSetting      *oldDestParent = src->parent;
 
654
 
 
655
    /* Change the parent to this setting that's being initialized
 
656
     * as that needs to go into the setting's default value as
 
657
     * the parent entry */
 
658
    src->parent = dest->parent;
 
659
    ccsCopyValueInto (src, dest, type, info);
 
660
 
 
661
    /* Restore the old parent */
 
662
    src->parent = oldDestParent;
 
663
}
 
664
 
 
665
class StubInitFuncs :
 
666
    public MockInitFuncs
 
667
{
 
668
    public:
 
669
 
 
670
        StubInitFuncs (CCSSettingInfo  *info,
 
671
                       CCSSettingValue *value) :
 
672
            MockInitFuncs (),
 
673
            mInfo (info),
 
674
            mValue (value)
 
675
        {
 
676
            ON_CALL (*this, initInfo (_, _, _))
 
677
                    .WillByDefault (WithArgs <0, 1> (
 
678
                                        Invoke (this,
 
679
                                                &StubInitFuncs::initInfo)));
 
680
 
 
681
            ON_CALL (*this, initDefaultValue (_, _, _, _))
 
682
                    .WillByDefault (WithArgs <0, 1, 2> (
 
683
                                        Invoke (this,
 
684
                                                &StubInitFuncs::initializeValue)));
 
685
        }
 
686
 
 
687
        void initInfo (CCSSettingType type,
 
688
                       CCSSettingInfo *info)
 
689
        {
 
690
            stubInitInfo (type, info, reinterpret_cast <void *> (mInfo));
 
691
        }
 
692
 
 
693
        void initializeValue (CCSSettingType  type,
 
694
                              CCSSettingInfo  *info,
 
695
                              CCSSettingValue *value)
 
696
        {
 
697
            stubInitDefaultValue (type, info, value,
 
698
                                  reinterpret_cast <void *> (mValue));
 
699
        }
 
700
 
 
701
        CCSSettingInfo  *mInfo;
 
702
        CCSSettingValue *mValue;
 
703
};
 
704
 
615
705
template <typename SettingValueType>
616
706
struct SettingMutators
617
707
{
622
712
                                 SettingValueType *);
623
713
};
624
714
 
 
715
class InternalSetParam :
 
716
    public SetParam
 
717
{
 
718
    protected:
 
719
 
 
720
        InternalSetParam (const CCSSettingInfoPtr &info,
 
721
                                 CCSSettingType          type) :
 
722
            mInfo (info),
 
723
            mType (type)
 
724
        {
 
725
        }
 
726
 
 
727
        virtual void TearDownSetting ()
 
728
        {
 
729
            if (mSetting)
 
730
                setToDefaultValue ();
 
731
        }
 
732
 
 
733
        void InitDefaultsForSetting (const SetUpSettingFunc &func)
 
734
        {
 
735
            StubInitFuncs stubInitializers (mInfo.get (), mValue.get ());
 
736
 
 
737
            func (stubInitializers);
 
738
        }
 
739
 
 
740
        void TakeReferenceToCreatedSetting (const CCSSettingPtr &setting)
 
741
        {
 
742
            mSetting = setting;
 
743
        }
 
744
 
 
745
        const CCSSettingInterface * RedirectSettingInterface ()
 
746
        {
 
747
            const CCSSettingInterface *settingInterface =
 
748
                GET_INTERFACE (CCSSettingInterface, mSetting.get ());
 
749
            CCSSettingInterface tmpSettingInterface = *settingInterface;
 
750
 
 
751
            tmpSettingInterface.settingGetType =
 
752
                InternalSetParam::returnIncorrectSettingType;
 
753
 
 
754
            ccsObjectRemoveInterface (mSetting.get (),
 
755
                                      GET_INTERFACE_TYPE (CCSSettingInterface));
 
756
            ccsObjectAddInterface (mSetting.get (),
 
757
                                   (const CCSInterface *) &tmpSettingInterface,
 
758
                                   GET_INTERFACE_TYPE (CCSSettingInterface));
 
759
 
 
760
            return settingInterface;
 
761
        }
 
762
 
 
763
        void RestoreSettingInterface (const CCSSettingInterface *settingInterface)
 
764
        {
 
765
            /* Restore the old interface */
 
766
            ccsObjectRemoveInterface (mSetting.get (),
 
767
                                      GET_INTERFACE_TYPE (CCSSettingInterface));
 
768
            ccsObjectAddInterface (mSetting.get (),
 
769
                                   (const CCSInterface *) settingInterface,
 
770
                                   GET_INTERFACE_TYPE (CCSSettingInterface));
 
771
        }
 
772
 
 
773
        virtual Bool setToFailValue ()
 
774
        {
 
775
            return TRUE;
 
776
        }
 
777
 
 
778
        virtual CCSSettingType GetSettingType ()
 
779
        {
 
780
            return mType;
 
781
        }
 
782
 
 
783
    protected:
 
784
 
 
785
        CCSSettingInfoPtr  mInfo;
 
786
        CCSSettingValuePtr mValue;
 
787
        CCSSettingType     mType;
 
788
        CCSSettingPtr      mSetting;
 
789
 
 
790
    private:
 
791
 
 
792
        static const CCSSettingType incorrectSettingType = TypeNum;
 
793
        static CCSSettingType returnIncorrectSettingType (CCSSetting *setting)
 
794
        {
 
795
            return incorrectSettingType;
 
796
        }
 
797
};
 
798
 
 
799
template <typename SettingValueType>
 
800
class SetParamContainerStorage
 
801
{
 
802
    protected:
 
803
 
 
804
        typedef typename ValueContainer <SettingValueType>::Ptr ValueContainerPtr;
 
805
 
 
806
        SetParamContainerStorage (const ValueContainerPtr &defaultValue,
 
807
                                  const ValueContainerPtr &nonDefaultValue) :
 
808
            mDefault (defaultValue),
 
809
            mNonDefault (nonDefaultValue)
 
810
        {
 
811
        }
 
812
 
 
813
        ValueContainerPtr  mDefault;
 
814
        ValueContainerPtr  mNonDefault;
 
815
};
 
816
 
 
817
template <typename SettingValueType>
 
818
class TypedSetParam :
 
819
    /* Do not change the order of inheritance here, DefaultImplSetParamTemplatedBase
 
820
     * must be destroyed after DefaultImplSetParamBase as DefaultImplSetParamBase
 
821
     * has indirect weak references to variables in DefaultImplSetParamTemplatedBase
 
822
     */
 
823
   private SetParamContainerStorage <SettingValueType>,
 
824
   public  InternalSetParam
 
825
{
 
826
    public:
 
827
 
 
828
        typedef typename SettingMutators <SettingValueType>::SetFunction SetFunction;
 
829
        typedef typename SettingMutators <SettingValueType>::GetFunction GetFunction;
 
830
        typedef typename ValueContainer <SettingValueType>::Ptr ValueContainerPtr;
 
831
        typedef SetParamContainerStorage <SettingValueType> TemplateParent;
 
832
 
 
833
        TypedSetParam (const ValueContainerPtr &defaultValue,
 
834
                       CCSSettingType          type,
 
835
                       SetFunction             setFunction,
 
836
                       GetFunction             getFunction,
 
837
                       const CCSSettingInfoPtr &info,
 
838
                       const ValueContainerPtr &nonDefaultValue) :
 
839
            SetParamContainerStorage <SettingValueType> (defaultValue,
 
840
                                                                 nonDefaultValue),
 
841
            InternalSetParam (info, type),
 
842
            mSetFunction (setFunction),
 
843
            mGetFunction (getFunction)
 
844
        {
 
845
        }
 
846
 
 
847
        virtual void SetUpSetting (const SetUpSettingFunc &func)
 
848
        {
 
849
            /* Do delayed setup here */
 
850
            mValue = TemplateParent::mDefault->getContainedValue (mType, mInfo);
 
851
            mNonDefaultValue = TemplateParent::mNonDefault->getRawValue (mType, mInfo);
 
852
 
 
853
            InitDefaultsForSetting (func);
 
854
        }
 
855
 
 
856
        virtual void SetUpParam (const CCSSettingPtr &setting)
 
857
        {
 
858
            ASSERT_TRUE ((*mGetFunction) (setting.get (), &mDefaultValue));
 
859
 
 
860
            TakeReferenceToCreatedSetting (setting);
 
861
        }
 
862
 
 
863
        virtual Bool setWithInvalidType ()
 
864
        {
 
865
            CCSSettingInterface *iface = RedirectSettingInterface ();
 
866
            Bool ret = (*mSetFunction) (mSetting.get (), mNonDefaultValue, FALSE);
 
867
            RestoreSettingInterface (iface);
 
868
 
 
869
            return ret;
 
870
        }
 
871
 
 
872
        virtual Bool setToNonDefaultValue ()
 
873
        {
 
874
            return (*mSetFunction) (mSetting.get (), mNonDefaultValue, FALSE);
 
875
        }
 
876
 
 
877
        virtual Bool setToDefaultValue ()
 
878
        {
 
879
            return (*mSetFunction) (mSetting.get (), mDefaultValue, FALSE);
 
880
        }
 
881
 
 
882
    private:
 
883
 
 
884
        SettingValueType   mDefaultValue;
 
885
        SettingValueType   mNonDefaultValue;
 
886
 
 
887
    protected:
 
888
 
 
889
        SetFunction        mSetFunction;
 
890
        GetFunction        mGetFunction;
 
891
 
 
892
};
 
893
 
625
894
class SetWithDisallowedValueBase
626
895
{
627
896
    protected:
749
1018
        }
750
1019
};
751
1020
 
 
1021
template <typename SettingValueType>
 
1022
class SetFailureParam :
 
1023
    public TypedSetParam <SettingValueType>
 
1024
{
 
1025
    public:
 
1026
 
 
1027
        typedef TypedSetParam <SettingValueType> Parent;
 
1028
        typedef typename TypedSetParam <SettingValueType>::SetFunction SetFunction;
 
1029
        typedef typename TypedSetParam <SettingValueType>::GetFunction GetFunction;
 
1030
        typedef typename TypedSetParam <SettingValueType>::ValueContainerPtr ValueContainerPtr;
 
1031
 
 
1032
        SetFailureParam (const ValueContainerPtr &defaultValue,
 
1033
                         CCSSettingType          type,
 
1034
                         SetFunction             setFunction,
 
1035
                         GetFunction             getFunction,
 
1036
                         const CCSSettingInfoPtr &info,
 
1037
                         const ValueContainerPtr &nonDefault) :
 
1038
            TypedSetParam <SettingValueType> (defaultValue,
 
1039
                                              type,
 
1040
                                              setFunction,
 
1041
                                              getFunction,
 
1042
                                              info,
 
1043
                                              nonDefault)
 
1044
        {
 
1045
        }
 
1046
 
 
1047
        virtual Bool setToFailValue ()
 
1048
        {
 
1049
            typedef TypedSetParam <SettingValueType> Parent;
 
1050
            return SetWithDisallowedValue <SettingValueType> (Parent::mSetFunction,
 
1051
                                                              Parent::mSetting,
 
1052
                                                              Parent::mInfo) ();
 
1053
        }
 
1054
};
 
1055
 
 
1056
template <typename T>
 
1057
SetParam::Ptr
 
1058
SemanticsParamFor (const typename ValueContainer <T>::Ptr   &defaultValue,
 
1059
                   CCSSettingType                           type,
 
1060
                   typename SettingMutators<T>::SetFunction setFunc,
 
1061
                   typename SettingMutators<T>::GetFunction getFunc,
 
1062
                   const CCSSettingInfoPtr                  &settingInfo,
 
1063
                   const typename ValueContainer <T>::Ptr   &changeTo)
 
1064
{
 
1065
    return boost::make_shared <TypedSetParam <T> > (defaultValue,
 
1066
                                                    type,
 
1067
                                                    setFunc,
 
1068
                                                    getFunc,
 
1069
                                                    settingInfo,
 
1070
                                                    changeTo);
 
1071
}
 
1072
 
 
1073
template <typename T>
 
1074
SetParam::Ptr
 
1075
FailureSemanticsParamFor (const typename ValueContainer <T>::Ptr   &defaultValue,
 
1076
                          CCSSettingType                           type,
 
1077
                          typename SettingMutators<T>::SetFunction setFunc,
 
1078
                          typename SettingMutators<T>::GetFunction getFunc,
 
1079
                          const CCSSettingInfo                     &settingInfo,
 
1080
                          const typename ValueContainer <T>::Ptr   &changeTo)
 
1081
{
 
1082
    return boost::make_shared <SetFailureParam <T> > (defaultValue,
 
1083
                                                      type,
 
1084
                                                      setFunc,
 
1085
                                                      getFunc,
 
1086
                                                      settingInfo,
 
1087
                                                      changeTo);
 
1088
}
 
1089
 
 
1090
class SettingDefaultImplSet :
 
1091
    public CCSSettingDefaultImplTest,
 
1092
    public WithParamInterface <SetParam::Ptr>
 
1093
{
 
1094
    public:
 
1095
 
 
1096
        virtual void SetUp ()
 
1097
        {
 
1098
            GetParam ()->SetUpSetting (boost::bind (&CCSSettingDefaultImplTest::SetUpSetting, this, _1));
 
1099
            GetParam ()->SetUpParam (setting);
 
1100
        }
 
1101
 
 
1102
        virtual void TearDown ()
 
1103
        {
 
1104
            GetParam ()->TearDownSetting ();
 
1105
        }
 
1106
 
 
1107
        CCSSettingType GetSettingType ()
 
1108
        {
 
1109
            return GetParam ()->GetSettingType ();
 
1110
        }
 
1111
};
 
1112
 
 
1113
class SettingDefaulImplSetFailure :
 
1114
    public SettingDefaultImplSet
 
1115
{
 
1116
};
 
1117
 
752
1118
}