Example #1
0
        public void Test()
        {
            var tddHandler = new TDDHandler();

            const string strValue = "test";

            NullValueSettings.NullValue   = null;
            NullValueSettings.NormalValue = strValue;

            NullValueSettings.SecureNullValue   = null;
            NullValueSettings.SecureNormalValue = strValue;

            NullValueSettings.SaveSettings();

            NullValueSettings.NullValue   = strValue;
            NullValueSettings.NormalValue = null;

            NullValueSettings.SecureNullValue   = strValue;
            NullValueSettings.SecureNormalValue = null;

            NullValueSettings.LoadSettings();

            Assert.IsTrue(strValue == NullValueSettings.NormalValue);
            Assert.IsNull(NullValueSettings.NullValue);

            Assert.IsTrue(strValue == NullValueSettings.SecureNormalValue);
            Assert.IsNull(NullValueSettings.SecureNullValue);

            tddHandler.CheckErrors();
        }
        public void Test()
        {
            var tddHandler = new TDDHandler();

            var settings = MethodSerializerSettings.Instance;

            CleanUpSettingsParams(settings);
            MethodSerializerSettings.LoadSettings();
            Compare(settings.m_SettingWasLoaded1, settings.m_SettingWasLoaded2,
                    settings);
            Compare(!settings.m_SettingWasSynchronized1, !settings.m_SettingWasSynchronized2,
                    settings);

            CleanUpSettingsParams(settings);
            MethodSerializerSettings.SaveSettings();
            Compare(settings.m_SettingWasSaved1, settings.m_SettingWasSaved2,
                    settings);
            Compare(settings.m_SettingWasSynchronized1, settings.m_SettingWasSynchronized2,
                    settings);

            CleanUpSettingsParams(settings);
            MethodSerializerSettings.DeleteSettings();
            Compare(settings.m_SettingWasDeleted1, settings.m_SettingWasDeleted2,
                    settings);
            Compare(settings.m_SettingWasSynchronized1, settings.m_SettingWasSynchronized2,
                    settings);

            tddHandler.CheckErrors();
        }
Example #3
0
        public void Test()
        {
            var tddHandler = new TDDHandler();

            var refSettings = new DifferentTypesLocalSettings();

            var refSettingsPlugin   = refSettings.GetObjectPlugin <IJSONSettingsPlugin>();
            var refSettingsDSPlugin = refSettings.GetObjectPlugin <ILocalDynamicSettingsPlugin>();

            for (int i = 0, iCount = 10; i < iCount; i++)
            {
                var settingName = String.Format("item{0}", i);
                refSettingsDSPlugin.SetSetting(settingName, i);
            }

            var refJsonSettings = refSettingsPlugin.SaveSettingsToJSON();

            var loadedSettings = new DifferentTypesLocalSettings();

            var loadedSettingsPlugin = loadedSettings.GetObjectPlugin <IJSONSettingsPlugin>();

            loadedSettingsPlugin.LoadSettingsFromJSON(refJsonSettings);

            DifferentTypesTest.CompareSettings(loadedSettings, refSettings);
            CompareDynamicSettings(loadedSettings, refSettings);

            tddHandler.CheckErrors();
        }
Example #4
0
        public void TestAddAndSetFunctions()
        {
            var tddHandler = new TDDHandler();

            var settings1_1 = new DynamicSettings1();
            var plugin1_1   = settings1_1.GetObjectPlugin <ILocalDynamicSettingsPlugin>();

            var dsn = "name1";

            var rand = new MyRandom();

            var randStringValue  = rand.NextString(10);
            var randDecimalValue = rand.NextDecimal();

            plugin1_1.SetSetting(dsn, randStringValue);
            var storedStringValue = plugin1_1.GetSetting <string>(dsn);

            Assert.AreEqual(randStringValue, storedStringValue);

            plugin1_1.SetSetting(dsn, randDecimalValue);
            var storedDecimalValue = plugin1_1.GetSetting <Decimal>(dsn);

            Assert.AreEqual(randDecimalValue, storedDecimalValue);

            tddHandler.CheckErrors();
        }
        public void Test()
        {
            var tddHandler = new TDDHandler();

            const String stringValue = "external string value";
            const Int32  int32Value  = 12345;

            const String stringKeyName = "v2.string";
            const String intKeyName    = "v2.int";

            var classPrefs = new NSUserDefaults();

            classPrefs.SetString(stringValue, stringKeyName);
            ExternalUserDefaultsClassSerializer.SetMyUserDefaults(classPrefs);

            var fieldPrefs = new NSUserDefaults();

            fieldPrefs.SetInt(int32Value, intKeyName);
            ExternalUserDefaultsFieldSerializer.SetMyUserDefaults(fieldPrefs);

            ExternalUserDefaultsSettings.IntValue    = 0;
            ExternalUserDefaultsSettings.StringValue = String.Empty;

            ExternalUserDefaultsSettings.LoadSettings();

            Assert.AreEqual(ExternalUserDefaultsSettings.IntValue, int32Value);
            Assert.AreEqual(ExternalUserDefaultsSettings.StringValue, stringValue);

            tddHandler.CheckErrors();
        }
Example #6
0
        public void TestCustomAndComplexObjectsAsSettings()
        {
            var tddHandler = new TDDHandler();

            var settings1_1 = new DynamicSettings1();
            var plugin1_1   = settings1_1.GetObjectPlugin <ILocalDynamicSettingsPlugin>();

            var rand    = new MyRandom();
            var fooList = new List <Foo>();

            for (int i = 0; i < 10; i++)
            {
                var foo = new Foo();
                foo.Value = rand.NextInt32();

                fooList.Add(foo);
            }

            var dsn1 = "name1";

            plugin1_1.SetSetting(dsn1, fooList);

            plugin1_1.SaveSettings();

            var settings1_2 = new DynamicSettings1();
            var plugin1_2   = settings1_2.GetObjectPlugin <ILocalDynamicSettingsPlugin>();

            plugin1_2.LoadSettings();

            var loadedFooList = plugin1_2.GetSetting <List <Foo> >(dsn1);

            Assert.AreEqual(fooList, loadedFooList);

            tddHandler.CheckErrors();
        }
Example #7
0
        public void TestContainsFunction()
        {
            var tddHandler = new TDDHandler();

            var settings1_1 = new DynamicSettings1();
            var plugin1_1   = settings1_1.GetObjectPlugin <ILocalDynamicSettingsPlugin>();

            var dsn1 = "name1";

            plugin1_1.SetSetting(dsn1, true);
            var dsn_contains1 = plugin1_1.Contains(dsn1);

            Assert.IsTrue(dsn_contains1);

            var dsn2 = "incorrect_name1";

            var dsn_contains2 = plugin1_1.Contains(dsn2);

            Assert.IsFalse(dsn_contains2);

            plugin1_1.DeleteSetting(dsn1);
            var dsn_contains3 = plugin1_1.Contains(dsn1);

            Assert.IsFalse(dsn_contains3);

            tddHandler.CheckErrors();
        }
Example #8
0
        public void Test()
        {
            var tddHandler = new TDDHandler();

            String   refString   = "Test";
            DateTime refDateTime = DateTime.Now;
            Int32    refInt32    = 10;

            NotLoadedValuesSettings.DeleteSettings();

            NotLoadedValuesSettings.StringValue   = refString;
            NotLoadedValuesSettings.DateTimeValue = refDateTime;
            NotLoadedValuesSettings.Int32Value    = refInt32;

            NotLoadedValuesSettings.SecureStringValue   = refString;
            NotLoadedValuesSettings.SecureDateTimeValue = refDateTime;
            NotLoadedValuesSettings.SecureInt32Value    = refInt32;

            NotLoadedValuesSettings.LoadSettings();

            Assert.AreEqual(refString, NotLoadedValuesSettings.StringValue);
            Assert.AreEqual(refDateTime, NotLoadedValuesSettings.DateTimeValue);
            Assert.AreEqual(refInt32, NotLoadedValuesSettings.Int32Value);

            Assert.AreEqual(refString, NotLoadedValuesSettings.SecureStringValue);
            Assert.AreEqual(refDateTime, NotLoadedValuesSettings.SecureDateTimeValue);
            Assert.AreEqual(refInt32, NotLoadedValuesSettings.SecureInt32Value);

            tddHandler.CheckErrors();
        }
        public void Test()
        {
            var tddHandler = new TDDHandler();

            Random rand = new MyRandom();

            var randInt1 = rand.NextInt32();
            var randInt2 = rand.NextInt32();
            var randInt3 = rand.NextInt32();
            var randInt4 = rand.NextInt32();

            // init values
            DifferentMemberTypesLocalSettings.m_staticField           = randInt1;
            DifferentMemberTypesLocalSettings.StaticProperty          = randInt2;
            DifferentMemberTypesLocalSettings.Instance.m_memberField  = randInt3;
            DifferentMemberTypesLocalSettings.Instance.MemberProperty = randInt4;

            DifferentMemberTypesLocalSettings.SaveSettings();

            // randomize values
            DifferentMemberTypesLocalSettings.m_staticField           = rand.NextInt32();
            DifferentMemberTypesLocalSettings.StaticProperty          = rand.NextInt32();
            DifferentMemberTypesLocalSettings.Instance.m_memberField  = rand.NextInt32();
            DifferentMemberTypesLocalSettings.Instance.MemberProperty = rand.NextInt32();

            DifferentMemberTypesLocalSettings.LoadSettings();

            // check results
            Assert.True(DifferentMemberTypesLocalSettings.m_staticField == randInt1);
            Assert.True(DifferentMemberTypesLocalSettings.StaticProperty == randInt2);
            Assert.True(DifferentMemberTypesLocalSettings.Instance.m_memberField == randInt3);
            Assert.True(DifferentMemberTypesLocalSettings.Instance.MemberProperty == randInt4);

            tddHandler.CheckErrors();
        }
Example #10
0
        public void Test()
        {
            var tddHandler = new TDDHandler();

            var settings = new DifferentTypesLocalSettings();

            settings.DeleteObjectSettings();

            Assert.IsFalse(settings.ContainsObjectSetting(s => s.m_Boolean));

            settings.SaveObjectSettings();

            Assert.IsTrue(settings.ContainsObjectSetting(s => s.m_Boolean));

            Assert.IsTrue(DifferentTypesLocalSettings.ContainsObjectSetting(settings, (DifferentTypesLocalSettings s) => s.m_Boolean));

            // static settings

            CollectionsSettings.DeleteSettings();

            Assert.IsFalse(CollectionsSettings.ContainsSetting(s => CollectionsSettings.IntList));

            CollectionsSettings.SaveSettings();

            Assert.IsTrue(CollectionsSettings.ContainsSetting(s => CollectionsSettings.IntList));

            tddHandler.CheckErrors();
        }
Example #11
0
        public void SecureTest()
        {
            var tddHandler = new TDDHandler();

            const string secureKey   = "v2.secureFoo";
            const string secureValue = "SecureFooStringValue";

            ActionsTestSettings.SecureFooString = secureValue;
            ActionsTestSettings.SaveSettings();

            string loadedSecureValue = ActionsTest.GetSecureStringValue(secureKey);

            Assert.AreEqual(ActionsTestSettings.SecureFooString, loadedSecureValue);
            Assert.AreEqual(secureValue, loadedSecureValue);

            ActionsTestSettings.SecureFooString = null;
            ActionsTestSettings.LoadSettings();
            Assert.AreEqual(ActionsTestSettings.SecureFooString, secureValue);

            ActionsTestSettings.DeleteSettings();
            string loadedNullSecureValue = ActionsTest.GetSecureStringValue(secureKey);

            Assert.IsNull(loadedNullSecureValue);
            Assert.IsNull(ActionsTestSettings.SecureFooString);

            tddHandler.CheckErrors();
        }
Example #12
0
        public void LocalTest()
        {
            var tddHandler = new TDDHandler();

            const string key   = "v2.foo";
            const string value = "FooStringValue";

            ActionsTestSettings.LocalFooString = value;
            ActionsTestSettings.SaveSettings();

            string loadedValue = GetLocalStringValue(key);

            Assert.AreEqual(loadedValue, value);

            ActionsTestSettings.LocalFooString = null;
            ActionsTestSettings.LoadSettings();
            Assert.AreEqual(ActionsTestSettings.LocalFooString, value);

            ActionsTestSettings.DeleteSettings();
            string loadedNullNSUserDefaultsValue = GetLocalStringValue(key);

            Assert.IsNull(loadedNullNSUserDefaultsValue);
            Assert.IsNull(ActionsTestSettings.LocalFooString);

            tddHandler.CheckErrors();
        }
        public void SecureTest()
        {
            var tddHandler = new TDDHandler();

            Test(ref DateTimeSettings.SecureDateTime, DateTime.Now);
            Test(ref DateTimeSettings.SecureDateTime, DateTime.UtcNow);

            tddHandler.CheckErrors();
        }
        public void LocalTest()
        {
            var tddHandler = new TDDHandler();

            var savedSettings = new DifferentTypesLocalSettings();

            savedSettings.SaveObjectSettings();

            var loadedSettings = new DifferentTypesLocalSettings();

            loadedSettings.LoadObjectSettings();

            CompareSettings(loadedSettings, savedSettings);

            tddHandler.CheckErrors();
        }
Example #15
0
        public void TestDynamicSettingsOrder()
        {
            var tddHandler = new TDDHandler();

            var settings1_1 = new DynamicSettings1();
            var plugin1_1   = settings1_1.GetObjectPlugin <ILocalDynamicSettingsPlugin>();

            const int settingsCount = 10;

            for (int i = 0; i < settingsCount; i++)
            {
                var settingName = String.Format("setting{0}", i);
                plugin1_1.SetSetting(settingName, i);
            }

            plugin1_1.SaveSettings();

            var settings1_2 = new DynamicSettings1();
            var plugin1_2   = settings1_2.GetObjectPlugin <ILocalDynamicSettingsPlugin>();

            plugin1_2.LoadSettings();

            int whileIndex = 0;

            using (var e1 = plugin1_1.GetEnumerator())
                using (var e2 = plugin1_2.GetEnumerator())
                {
                    while (e1.MoveNext() && e2.MoveNext())
                    {
                        // compare settings names
                        Assert.AreEqual(e1.Current, e2.Current);

                        var dynamicValue1_1 = plugin1_1.GetSetting <int>(e1.Current);
                        var dynamicValue1_2 = plugin1_2.GetSetting <int>(e2.Current);

                        // compare settings values
                        Assert.AreEqual(dynamicValue1_1, dynamicValue1_2);

                        whileIndex++;
                    }
                }

            Assert.AreEqual(plugin1_1.Count, whileIndex);
            Assert.AreEqual(plugin1_2.Count, whileIndex);

            tddHandler.CheckErrors();
        }
        public void Test()
        {
            var tddHandler = new TDDHandler();

            const string token = "cee39cf0f58b252d7add72db41ab209371bf3dd291cdae4c997ebfdd1c645472f2aa293b6221ff527d2f24d0780a4be813e8cc9f2c093097debbb213d8ecff1287685e8de2cc4200add6bb601b3e0328c9c96224e25da0fcb8cf5a16f24360ca3f0111cd4cb1535ebf8b9ab4140a6248";

            Issue2Settings.UserToken = token;

            Issue2Settings.SaveSettings();

            Issue2Settings.UserToken = null;
            Issue2Settings.LoadSettings();

            Assert.AreEqual(token, Issue2Settings.UserToken);

            tddHandler.CheckErrors();
        }
Example #17
0
        public void TestDefaultValues()
        {
            var tddHandler = new TDDHandler();

            var settings1_1 = new DynamicSettings1();
            var plugin1_1   = settings1_1.GetObjectPlugin <ILocalDynamicSettingsPlugin>();

            // try to get setting with no default value
            const string settingName = "setting";

            Assert.Throws <KeyNotFoundException>(() =>
            {
                plugin1_1.GetSetting <string>(settingName);
            });

            // set default value
            const string settingDefaultValue = "default value";

            plugin1_1.SetDefaultSettings(new Dictionary <string, object>()
            {
                { settingName, settingDefaultValue },
            });

            var setting = plugin1_1.GetSetting <string>(settingName);

            Assert.AreEqual(settingDefaultValue, setting);

            // set setting value and try to get it
            const string settingValue = "value";

            plugin1_1.SetSetting(settingName, settingValue);
            setting = plugin1_1.GetSetting <string>(settingName);
            Assert.AreEqual(settingValue, setting);

            plugin1_1.DeleteSetting(settingName);

            // reset defaults
            plugin1_1.SetDefaultSettings(null);
            Assert.Throws <KeyNotFoundException>(() =>
            {
                plugin1_1.GetSetting <string>(settingName);
            });

            tddHandler.CheckErrors();
        }
Example #18
0
        public void TestRandomValues()
        {
            var tddHandler = new TDDHandler();

            var settings1_1 = new DynamicSettings1();
            var plugin1_1   = settings1_1.GetObjectPlugin <ILocalDynamicSettingsPlugin>();

            var dsn1 = "name1";
            var dsn2 = "name2";

            var rand          = new MyRandom();
            var randValue     = rand.NextDouble();
            var randEnumValue = (EEnumValues)rand.Next((int)EEnumValues.Ten);

            plugin1_1.SetSetting(dsn1, randValue);
            plugin1_1.SetSetting(dsn2, randEnumValue);

            var storedValue1 = plugin1_1.GetSetting <double>(dsn1);

            Assert.AreEqual(randValue, storedValue1);

            var storedEnum1 = plugin1_1.GetSetting <EEnumValues>(dsn2);

            Assert.AreEqual(randEnumValue, storedEnum1);

            plugin1_1.SaveSettings();

            var settings1_2 = new DynamicSettings1();
            var plugin1_2   = settings1_2.GetObjectPlugin <ILocalDynamicSettingsPlugin>();

            plugin1_2.LoadSettings();

            var storedValue2 = plugin1_2.GetSetting <double>(dsn1);

            Assert.AreEqual(randValue, storedValue2);

            var storedEnum2 = plugin1_2.GetSetting <EEnumValues>(dsn2);

            Assert.AreEqual(randEnumValue, storedEnum2);

            tddHandler.CheckErrors();
        }
Example #19
0
        public void TestInterferenceBetweenDifferentSettingsClasses()
        {
            var tddHandler = new TDDHandler();

            var settings1_1 = new DynamicSettings1();
            var plugin1_1   = settings1_1.GetObjectPlugin <ILocalDynamicSettingsPlugin>();

            plugin1_1.SetSetting("test", 0);
            plugin1_1.SaveSettings();

            var settings2_1 = new DynamicSettings2();
            var plugin2_1   = settings2_1.GetObjectPlugin <ILocalDynamicSettingsPlugin>();

            plugin2_1.LoadSettings();

            Assert.IsTrue(plugin1_1.Count == 1);
            Assert.IsTrue(plugin2_1.Count == 0);

            tddHandler.CheckErrors();
        }
Example #20
0
        public void TestAddAndGetFunctions()
        {
            var tddHandler = new TDDHandler();

            var settings1_1 = new DynamicSettings1();
            var plugin1_1   = settings1_1.GetObjectPlugin <ILocalDynamicSettingsPlugin>();

            const int    settingsCount     = 100;
            const string settingNameFormat = "setting{0}";

            for (int i = 0; i < settingsCount; i++)
            {
                var settingName = String.Format(settingNameFormat, i);
                plugin1_1.SetSetting(settingName, i);
            }

            plugin1_1.SaveSettings();

            var settings1_2 = new DynamicSettings1();
            var plugin1_2   = settings1_2.GetObjectPlugin <ILocalDynamicSettingsPlugin>();

            plugin1_2.LoadSettings();

            int index1_2 = 0;

            foreach (var settingName in plugin1_2)
            {
                var dynamicValue1_1 = plugin1_1.GetSetting <int>(settingName);
                var dynamicValue1_2 = plugin1_2.GetSetting <int>(settingName);

                Assert.AreEqual(dynamicValue1_1, index1_2);
                Assert.AreEqual(dynamicValue1_1, dynamicValue1_2);

                index1_2++;
            }

            Assert.AreEqual(index1_2, settingsCount);
            Assert.AreEqual(index1_2, plugin1_2.Count);

            tddHandler.CheckErrors();
        }
        public void DefaultValueTest()
        {
            var tddHandler = new TDDHandler();

            // this local DateTime value was specified in the settings
            DateTime localDateTime = DateTime.ParseExact(DateTimeSettings.DefaultDateTimeLocalStringValue,
                                                         "o", CultureInfo.InvariantCulture,
                                                         DateTimeStyles.RoundtripKind);
            // this UTC DateTime value was specified in the settings
            DateTime utcDateTime = DateTime.ParseExact(DateTimeSettings.DefaultDateTimeUtcStringValue,
                                                       "o", CultureInfo.InvariantCulture,
                                                       DateTimeStyles.RoundtripKind);

            DateTimeSettings.DeleteSetting(s => DateTimeSettings.DateTimeLocalValue);
            DateTimeSettings.DeleteSetting(s => DateTimeSettings.DateTimeUtcValue);

            // after delete operation all fields has defaul values
            Assert.AreEqual(DateTimeKind.Local, DateTimeSettings.DateTimeLocalValue.Kind);
            Assert.AreEqual(localDateTime, DateTimeSettings.DateTimeLocalValue);

            Assert.AreEqual(DateTimeKind.Utc, DateTimeSettings.DateTimeUtcValue.Kind);
            Assert.AreEqual(utcDateTime, DateTimeSettings.DateTimeUtcValue);

            // Invalidate value
            DateTimeSettings.DateTimeLocalValue = new DateTime();
            // Load from default value
            DateTimeSettings.LoadSetting(s => DateTimeSettings.DateTimeLocalValue);
            // Check consistency
            Assert.AreEqual(DateTimeKind.Local, DateTimeSettings.DateTimeLocalValue.Kind);
            Assert.AreEqual(localDateTime, DateTimeSettings.DateTimeLocalValue);

            // Invalidate value
            DateTimeSettings.DateTimeUtcValue = new DateTime();
            // Load from default value
            DateTimeSettings.LoadSetting(s => DateTimeSettings.DateTimeUtcValue);
            // Check consistency
            Assert.AreEqual(DateTimeKind.Utc, DateTimeSettings.DateTimeUtcValue.Kind);
            Assert.AreEqual(utcDateTime, DateTimeSettings.DateTimeUtcValue);

            tddHandler.CheckErrors();
        }
        public void Test()
        {
            var tddHandler = new TDDHandler();

            CustomObjectSettings.FooClassInstance       = new FooClass();
            CustomObjectSettings.SecureFooClassInstance = new FooClass();

            Random rand = new MyRandom();

            Int32 fooValue       = rand.NextInt32();
            Int32 secureFooValue = rand.NextInt32();

            CustomObjectSettings.FooClassInstance.IntValue       = fooValue;
            CustomObjectSettings.SecureFooClassInstance.IntValue = secureFooValue;

            FooEnum fooEnumValue       = (FooEnum)rand.Next((Int32)FooEnum.One, (Int32)FooEnum.Ten);
            FooEnum secureFooEnumValue = (FooEnum)rand.Next((Int32)FooEnum.One, (Int32)FooEnum.Ten);

            CustomObjectSettings.FooEnumValue       = fooEnumValue;
            CustomObjectSettings.SecureFooEnumValue = secureFooEnumValue;
            CustomObjectSettings.SaveSettings();

            CustomObjectSettings.FooClassInstance       = null;
            CustomObjectSettings.SecureFooClassInstance = null;
            CustomObjectSettings.FooEnumValue           = FooEnum.Zero;
            CustomObjectSettings.SecureFooEnumValue     = FooEnum.Zero;

            CustomObjectSettings.LoadSettings();

            Assert.IsNotNull(CustomObjectSettings.FooClassInstance);
            Assert.IsTrue(typeof(FooClass) == CustomObjectSettings.FooClassInstance.GetType());
            Assert.AreEqual(CustomObjectSettings.FooClassInstance.IntValue, fooValue);
            Assert.AreEqual(CustomObjectSettings.FooEnumValue, fooEnumValue);

            Assert.IsNotNull(CustomObjectSettings.SecureFooClassInstance);
            Assert.IsTrue(typeof(FooClass) == CustomObjectSettings.SecureFooClassInstance.GetType());
            Assert.AreEqual(CustomObjectSettings.SecureFooClassInstance.IntValue, secureFooValue);
            Assert.AreEqual(CustomObjectSettings.SecureFooEnumValue, secureFooEnumValue);

            tddHandler.CheckErrors();
        }
Example #23
0
        public void Test()
        {
            var logHandler = new TDDHandler();

            const String stringKeyName = "v2.string";
            const String intKeyName    = "v2.int";

            const String stringValue = "external string value";
            const Int32  intValue    = 12345;

            Context classContext = Application.Context;
            Context fieldContext = Application.Context;

            ISharedPreferences classPrefs = classContext.GetSharedPreferences("classPrefs", FileCreationMode.Private);
            ISharedPreferences fieldPrefs = fieldContext.GetSharedPreferences("fieldPrefs", FileCreationMode.Private);

            var classPrefsEditor = classPrefs.Edit();

            classPrefsEditor.PutString(stringKeyName, stringValue);
            classPrefsEditor.Commit();

            var fieldPrefsEditor = fieldPrefs.Edit();

            fieldPrefsEditor.PutInt(intKeyName, intValue);
            fieldPrefsEditor.Commit();

            ExternalSharedPreferencesClassSerializer.SetMySharedPreferences(classPrefs);
            ExternalSharedPreferencesFieldSerializer.SetMySharedPreferences(fieldPrefs);

            ExternalSharedPreferencesSettings.IntValue    = 0;
            ExternalSharedPreferencesSettings.StringValue = String.Empty;

            ExternalSharedPreferencesSettings.LoadSettings();

            Assert.AreEqual(ExternalSharedPreferencesSettings.IntValue, intValue);
            Assert.AreEqual(ExternalSharedPreferencesSettings.StringValue, stringValue);

            logHandler.CheckErrors();
        }
        public void Test()
        {
            var tddHandler = new TDDHandler();

            DefaultValueSettings.DeleteSettings();

            DefaultValueSettings.LoadSetting(s => DefaultValueSettings.IntValue);
            Assert.AreEqual(DefaultValueSettings.DefailtIntValue, DefaultValueSettings.IntValue);

            DefaultValueSettings.LoadSetting(s => DefaultValueSettings.EnumValue);
            Assert.AreEqual(DefaultValueSettings.DefailtEnumValue, DefaultValueSettings.EnumValue);

            DefaultValueSettings.LoadSetting(s => DefaultValueSettings.StringValue);
            Assert.AreEqual(DefaultValueSettings.DefailtStringValue, DefaultValueSettings.StringValue);

            DefaultValueSettings.LoadSetting(s => DefaultValueSettings.NullValue);
            Assert.IsNull(DefaultValueSettings.NullValue);

            DefaultValueSettings.LoadSetting(s => DefaultValueSettings.NullableValue);
            Assert.IsNull(DefaultValueSettings.NullableValue);

            const string notSetValue = "not set test";

            DefaultValueSettings.ValueNotSet = notSetValue;
            DefaultValueSettings.LoadSetting(s => DefaultValueSettings.ValueNotSet);
            Assert.AreEqual(notSetValue, DefaultValueSettings.ValueNotSet);

            DefaultValueSettings.LoadSetting(s => DefaultValueSettings.IncorrectDefaultValueType);
            Assert.AreEqual(GetTypeDefaultValue(DefaultValueSettings.IncorrectDefaultValueType),
                            DefaultValueSettings.IncorrectDefaultValueType);

            DefaultValueSettings.TypeDefaultValue = 123;
            DefaultValueSettings.LoadSetting(s => DefaultValueSettings.TypeDefaultValue);
            Assert.AreEqual(GetTypeDefaultValue(DefaultValueSettings.TypeDefaultValue),
                            DefaultValueSettings.TypeDefaultValue);

            tddHandler.CheckErrors();
        }
Example #25
0
        public void TestEnumValues()
        {
            var tddHandler = new TDDHandler();

            var settings1_1 = new DynamicSettings1();
            var plugin1_1   = settings1_1.GetObjectPlugin <ILocalDynamicSettingsPlugin>();

            var dsn       = "test";
            var enumValue = EEnumValues.One;

            plugin1_1.SetSetting(dsn, enumValue);

            plugin1_1.SaveSettings();

            var settings1_2 = new DynamicSettings1();
            var plugin1_2   = settings1_2.GetObjectPlugin <ILocalDynamicSettingsPlugin>();

            plugin1_2.LoadSettings();
            var loadedEnumvalue = plugin1_2.GetSetting <EEnumValues>(dsn);

            Assert.AreEqual(enumValue, loadedEnumvalue);

            tddHandler.CheckErrors();
        }
        //------------------------------------------------------------------------------
        void Test(String func)
        {
            var tddHandler = new TDDHandler();

            { // library serializer
                LibrarySerializer.s_CreationCount = 0;

                SettingsConfiguration.Serializer = new LibrarySerializer();

                Invoke(typeof(SimpleSettings), func);

                Assert.IsTrue(LibrarySerializer.s_CreationCount == 1);
            }

            { // class serializer over library serializer
                LibrarySerializer.s_CreationCount = 0;
                ClassSerializer.s_CreationCount   = 0;

                Invoke(typeof(ClassSerializerSettings), func);

                Assert.IsTrue(LibrarySerializer.s_CreationCount == 0);
                Assert.IsTrue(ClassSerializer.s_CreationCount == 1);
            }

            { // field serializer over class and library serializers
                LibrarySerializer.s_CreationCount = 0;
                ClassSerializer.s_CreationCount   = 0;
                FieldSerializer.s_CreationCount   = 0;

                Invoke(typeof(FieldSerializerSettings), func);

                Assert.IsTrue(LibrarySerializer.s_CreationCount == 0);
                Assert.IsTrue(ClassSerializer.s_CreationCount == 0);
                Assert.IsTrue(FieldSerializer.s_CreationCount == 1);
            }

            { // field and class serializer over library serializer
                LibrarySerializer.s_CreationCount = 0;
                ClassSerializer.s_CreationCount   = 0;
                FieldSerializer.s_CreationCount   = 0;

                Invoke(typeof(CompoundSerializerSettings), func);

                Assert.IsTrue(LibrarySerializer.s_CreationCount == 0);
                Assert.IsTrue(ClassSerializer.s_CreationCount == 1);
                Assert.IsTrue(FieldSerializer.s_CreationCount == 1);
            }
            { // field and library serializers
                FieldSerializer.s_CreationCount   = 0;
                LibrarySerializer.s_CreationCount = 0;

                // recreate for apropriate s_CreationCount value
                SettingsConfiguration.Serializer = new LibrarySerializer();

                Invoke(typeof(FieldAndLibrarySerializerSettings), func);

                Assert.IsTrue(FieldSerializer.s_CreationCount == 1);
                Assert.IsTrue(LibrarySerializer.s_CreationCount == 1);
            }

            tddHandler.CheckErrors();
        }
        public void Test()
        {
            var tddHandler = new TDDHandler();

            const Int32 iterations = 10000;

            InitializeCollections(iterations);

            for (Int32 i = 0; i < iterations; i++)
            {
                CollectionsSettings.IntList.Add(i);
                CollectionsSettings.Int2StringDictionary.Add(i, i.ToString());
                CollectionsSettings.IntSet.Add(i);

                CollectionsSettings.SecureIntList.Add(i);
                CollectionsSettings.SecureInt2StringDictionary.Add(i, i.ToString());
                CollectionsSettings.SecureIntSet.Add(i);
            }

            CollectionsSettings.SaveSettings();

            // reset existing values
            InitializeCollections(iterations);

            CollectionsSettings.LoadSettings();

            // Check collections size
            Assert.AreEqual(CollectionsSettings.IntList.Count, iterations);
            Assert.AreEqual(CollectionsSettings.Int2StringDictionary.Count, iterations);
            Assert.AreEqual(CollectionsSettings.IntSet.Count, iterations);

            Assert.AreEqual(CollectionsSettings.SecureIntList.Count, iterations);
            Assert.AreEqual(CollectionsSettings.SecureInt2StringDictionary.Count, iterations);
            Assert.AreEqual(CollectionsSettings.SecureIntSet.Count, iterations);

            for (Int32 i = 0; i < iterations; i++)
            {
                // Check list
                Assert.AreEqual(CollectionsSettings.IntList[i], i);

                // Check dictionary
                string strValue;
                CollectionsSettings.Int2StringDictionary.TryGetValue(i, out strValue);
                Assert.IsTrue(strValue == i.ToString());

                // Check hash set
                Assert.IsTrue(CollectionsSettings.IntSet.Contains(i));

                // Check secure list
                Assert.AreEqual(CollectionsSettings.SecureIntList[i], i);

                // Check secure dictionary
                string secureStrValue;
                CollectionsSettings.SecureInt2StringDictionary.TryGetValue(i, out secureStrValue);

                Assert.IsTrue(secureStrValue == i.ToString());

                // Check secure hash set
                Assert.IsTrue(CollectionsSettings.SecureIntSet.Contains(i));

                tddHandler.CheckErrors();
            }
        }
Example #28
0
        //------------------------------------------------------------------------------
        void Test(string func, TDDData.SerializerActions action)
        {
            var tddHandler = new TDDHandler();

            { // library serializer
                SettingsConfiguration.Serializer = new LibrarySerializer();
                Invoke(typeof(SimpleSettings), func);

                Type librarySerializerType = typeof(LibrarySerializer);
                var  serializerTypes       = new List <String>()
                {
                    librarySerializerType.FullName,
                    librarySerializerType.FullName,
                };
                if (IsSyncAction(action))
                {
                    serializerTypes.Add(librarySerializerType.FullName);
                }

                var actions = new List <TDDData.SerializerActions>()
                {
                    action, action
                };
                if (IsSyncAction(action))
                {
                    actions.Add(TDDData.SerializerActions.Synchronize);
                }

                var securityFlags = new List <bool>()
                {
                    false, true
                };
                if (IsSyncAction(action))
                {
                    securityFlags.Add(false);
                }

                CheckSerializerTypeUsage(serializerTypes);
                CheckSerializerActionUsage(actions);
                CheckActionSecurityUsage(securityFlags);
            }

            { // class serializer over library serializer
                Invoke(typeof(ClassSerializerSettings), func);

                Type classSerializerType = typeof(ClassSerializer);

                var serializerTypes = new List <String>()
                {
                    classSerializerType.FullName,
                    classSerializerType.FullName,
                };
                if (IsSyncAction(action))
                {
                    serializerTypes.Add(classSerializerType.FullName);
                }

                var actions = new List <TDDData.SerializerActions>()
                {
                    action, action
                };
                if (IsSyncAction(action))
                {
                    actions.Add(TDDData.SerializerActions.Synchronize);
                }

                var securityFlags = new List <bool>()
                {
                    false, true
                };
                if (IsSyncAction(action))
                {
                    securityFlags.Add(false);
                }

                CheckSerializerTypeUsage(serializerTypes);
                CheckSerializerActionUsage(actions);
                CheckActionSecurityUsage(securityFlags);
            }

            { // field serializer over class and library serializers
                Invoke(typeof(FieldSerializerSettings), func);

                Type fieldSerializerType = typeof(FieldSerializer);

                var serializerTypes = new List <String>()
                {
                    fieldSerializerType.FullName,
                    fieldSerializerType.FullName,
                };
                if (IsSyncAction(action))
                {
                    serializerTypes.Add(fieldSerializerType.FullName);
                }

                var actions = new List <TDDData.SerializerActions>()
                {
                    action, action
                };
                if (IsSyncAction(action))
                {
                    actions.Add(TDDData.SerializerActions.Synchronize);
                }

                var securityFlags = new List <bool>()
                {
                    false, true
                };
                if (IsSyncAction(action))
                {
                    securityFlags.Add(false);
                }

                CheckSerializerTypeUsage(serializerTypes);
                CheckSerializerActionUsage(actions);
                CheckActionSecurityUsage(securityFlags);
            }

            { // field and class serializer over library serializer
                Invoke(typeof(CompoundSerializerSettings), func);

                Type fieldSerializerType = typeof(FieldSerializer);
                Type classSerializerType = typeof(ClassSerializer);

                var serializerTypes = new List <String>()
                {
                    classSerializerType.FullName,
                    classSerializerType.FullName,
                    fieldSerializerType.FullName,
                    fieldSerializerType.FullName,
                };
                if (IsSyncAction(action))
                {
                    serializerTypes.Add(classSerializerType.FullName);
                    serializerTypes.Add(fieldSerializerType.FullName);
                }

                var actions = new List <TDDData.SerializerActions>()
                {
                    action, action, action, action
                };
                if (IsSyncAction(action))
                {
                    actions.Add(TDDData.SerializerActions.Synchronize);
                    actions.Add(TDDData.SerializerActions.Synchronize);
                }

                var securityFlags = new List <bool>()
                {
                    false, true, false, true
                };
                if (IsSyncAction(action))
                {
                    securityFlags.Add(false);
                    securityFlags.Add(false);
                }

                CheckSerializerTypeUsage(serializerTypes);
                CheckSerializerActionUsage(actions);
                CheckActionSecurityUsage(securityFlags);
            }

            { // field and library serializers
                Invoke(typeof(FieldAndLibrarySerializerSettings), func);

                Type fieldSerializerType   = typeof(FieldSerializer);
                Type librarySerializerType = typeof(LibrarySerializer);

                var serializerTypes = new List <String>()
                {
                    fieldSerializerType.FullName,
                    librarySerializerType.FullName,
                    fieldSerializerType.FullName,
                    librarySerializerType.FullName,
                };
                if (IsSyncAction(action))
                {
                    serializerTypes.Add(fieldSerializerType.FullName);
                    serializerTypes.Add(librarySerializerType.FullName);
                }

                var actions = new List <TDDData.SerializerActions>()
                {
                    action, action, action, action
                };
                if (IsSyncAction(action))
                {
                    actions.Add(TDDData.SerializerActions.Synchronize);
                    actions.Add(TDDData.SerializerActions.Synchronize);
                }

                var securityFlags = new List <bool>()
                {
                    false, false, true, true
                };
                if (IsSyncAction(action))
                {
                    securityFlags.Add(false);
                    securityFlags.Add(false);
                }

                CheckSerializerTypeUsage(serializerTypes);
                CheckSerializerActionUsage(actions);
                CheckActionSecurityUsage(securityFlags);
            }

            { // built in serializers
                SettingsConfiguration.Serializer = null;

                Invoke(typeof(SimpleSettings), func);

                var serializerTypes = new List <String>()
                {
                    "Advexp.ISettingsSerializerImpl",
                    "Advexp.ISettingsSerializerImpl",
                };
                if (IsSyncAction(action))
                {
                    serializerTypes.Add("Advexp.ISettingsSerializerImpl");
                }

                var actions = new List <TDDData.SerializerActions>()
                {
                    action, action
                };
                if (IsSyncAction(action))
                {
                    actions.Add(TDDData.SerializerActions.Synchronize);
                }

                var securityFlags = new List <bool>()
                {
                    false, true
                };
                if (IsSyncAction(action))
                {
                    securityFlags.Add(false);
                }

                CheckSerializerTypeUsage(serializerTypes);
                CheckSerializerActionUsage(actions);
                CheckActionSecurityUsage(securityFlags);
            }

            tddHandler.CheckErrors();
        }
Example #29
0
        public void TestDynamicSettingsCustomOrder()
        {
            var tddHandler = new TDDHandler();

            //==============================

            var settings1_1 = new DynamicSettings1();
            var plugin1_1   = settings1_1.GetObjectPlugin <ILocalDynamicSettingsPlugin>();

            const int    settingsCount     = 50;
            const string settingNameFormat = "setting{0}";

            var settingsOrder = new List <string>();

            for (int i = 0; i < settingsCount; i++)
            {
                var settingName = String.Format(settingNameFormat, i);
                plugin1_1.SetSetting(settingName, i);

                settingsOrder.Add(settingName);
            }

            plugin1_1.SaveSettings();

            var settings1_2 = new DynamicSettings1();
            var plugin1_2   = settings1_2.GetObjectPlugin <ILocalDynamicSettingsPlugin>();

            plugin1_2.LoadSettings();

            // set custom filter

            settingsOrder.Shuffle();
            plugin1_2.SetSettingsOrder(settingsOrder);

            int index = 0;

            foreach (var ds in plugin1_2)
            {
                Assert.AreEqual(settingsOrder[index], ds);
                index++;
            }

            //==============================

            // save and restore settings in the new instance
            // check settings custom order

            settingsOrder.Shuffle();
            plugin1_2.SetSettingsOrder(settingsOrder);

            plugin1_2.SaveSettings();

            var settings1_3 = new DynamicSettings1();
            var plugin1_3   = settings1_3.GetObjectPlugin <ILocalDynamicSettingsPlugin>();

            plugin1_3.LoadSettings();

            // compare with custom order
            CompareDynamicSettings(plugin1_2, plugin1_3);

            plugin1_2.SetSettingsOrder(null);
            plugin1_3.SetSettingsOrder(null);

            // compare with default order
            CompareDynamicSettings(plugin1_2, plugin1_3);

            //==============================

            // set empty custom filter

            plugin1_2.SetSettingsOrder(new List <string>());
            Assert.AreEqual(0, plugin1_2.Count);

            //==============================

            // reset custom filter

            plugin1_2.SetSettingsOrder(null);

            index = 0;
            foreach (var ds in plugin1_2)
            {
                Assert.AreEqual(String.Format(settingNameFormat, index), ds);
                index++;
            }

            //==============================

            // add new dynamic setting when custom filter was set

            const string newDynamicSettingName = "new";

            plugin1_2.SetSettingsOrder(settingsOrder);
            plugin1_2.SetSetting(newDynamicSettingName, 1);

            index = 0;
            foreach (var ds in plugin1_2)
            {
                if (index < settingsOrder.Count)
                {
                    Assert.AreEqual(settingsOrder[index], ds);
                    index++;
                }
                else
                {
                    Assert.AreEqual(newDynamicSettingName, ds);
                }
            }

            //==============================

            // delete existing dynamic setting when custom filter was set

            var rng = new MyRandom();
            var randomTargetIndex = rng.Next(settingsCount);
            var targetSettingName = String.Format(settingNameFormat, randomTargetIndex);

            plugin1_2.SetSettingsOrder(settingsOrder);
            var preCount = plugin1_2.Count;

            plugin1_2.DeleteSetting(targetSettingName);
            settingsOrder.Remove(targetSettingName);

            Assert.AreEqual(preCount - 1, plugin1_2.Count);
            Assert.AreEqual(settingsOrder.Count, plugin1_2.Count);

            index = 0;
            foreach (var ds in plugin1_2)
            {
                Assert.AreEqual(settingsOrder[index], ds);
                index++;
            }

            tddHandler.CheckErrors();
        }