Esempio n. 1
0
        public void DefaultValuesTest()
        {
            // prepare
            var settings = new TestSettings(1, JsonSettingsSerializer.Default);

            // check all values
            foreach (var key in TestSettings.AllKeys)
            {
                var value = settings.GetValueOrDefault(key);
                Assert.AreEqual(key.DefaultValue, value, "Value should be default value.");
            }

            // modify values
            foreach (var key in TestSettings.AllKeys)
            {
                if (!TestSettings.TestValues.TryGetValue(key, out var value))
                {
                    continue;
                }
                settings.SetValue(key, value);
                Assert.AreNotEqual(value, key.DefaultValue, "Test value should be different from default value.");
                Assert.AreEqual(value, settings.GetValueOrDefault(key), "Value should be same as set one.");
            }

            // reset all values
            settings.ResetValues();

            // check all values
            foreach (var key in TestSettings.AllKeys)
            {
                var value = settings.GetValueOrDefault(key);
                Assert.AreEqual(key.DefaultValue, value, "Value should be default value.");
            }
        }
Esempio n. 2
0
        public void CopyingTest()
        {
            // prepare base settings
            var baseSettings = new TestSettings(1, JsonSettingsSerializer.Default);

            foreach (var key in TestSettings.AllKeys)
            {
                if (!TestSettings.TestValues.TryGetValue(key, out var value))
                {
                    continue;
                }
                baseSettings.SetValue(key, value);
                Assert.AreNotEqual(value, key.DefaultValue, "Test value should be different from default value.");
                Assert.AreEqual(value, baseSettings.GetValueOrDefault(key), "Value should be same as set one.");
            }

            // copy settings
            var copiedSettings = new TestSettings(baseSettings, JsonSettingsSerializer.Default);

            foreach (var key in TestSettings.AllKeys)
            {
                var baseValue   = baseSettings.GetValueOrDefault(key);
                var copiedValue = copiedSettings.GetValueOrDefault(key);
                Assert.AreEqual(baseValue, copiedValue, "Value should be same as base.");
            }

            // reset bae settings.
            baseSettings.ResetValues();

            // check copied settings
            foreach (var key in TestSettings.AllKeys)
            {
                Assert.AreNotEqual(copiedSettings.GetValueOrDefault(key), key.DefaultValue, "Copied value should be affected by base.");
            }
        }
Esempio n. 3
0
        public void SerializingToMemoryTest()
        {
            // prepare empty settings
            var settings = new TestSettings(1, this.CreateSettingsSerializer());

            // save to memory
            var data = new MemoryStream().Use((stream) =>
            {
                settings.Save(stream);
                return(stream.ToArray());
            });

            // modify values
            foreach (var keyValue in TestSettings.TestValues)
            {
                var key   = keyValue.Key;
                var value = keyValue.Value;
                settings.SetValue(key, value);
                Assert.AreNotEqual(value, key.DefaultValue, "Test value should be different from default value.");
                Assert.AreEqual(value, settings.GetValueOrDefault(key), "Value should be same as set one.");
            }

            // load from memory
            using (var stream = new MemoryStream(data))
                settings.Load(stream);

            // check values
            Assert.IsFalse(settings.IsOnUpgradeCalled, "Setting upgrading should not be called.");
            foreach (var key in TestSettings.AllKeys)
            {
                Assert.AreEqual(key.DefaultValue, settings.GetValueOrDefault(key), "Value should be same as default value.");
            }

            // modify values
            foreach (var keyValue in TestSettings.TestValues)
            {
                settings.SetValue(keyValue.Key, keyValue.Value);
            }

            // save to memory
            data = new MemoryStream().Use((stream) =>
            {
                settings.Save(stream);
                return(stream.ToArray());
            });

            // reset and load from memory
            settings.ResetValues();
            using (var stream = new MemoryStream(data))
                settings.Load(stream);

            // check values
            Assert.IsFalse(settings.IsOnUpgradeCalled, "Setting upgrading should not be called.");
            foreach (var keyValue in TestSettings.TestValues)
            {
                Assert.AreEqual(keyValue.Value, settings.GetValueOrDefault(keyValue.Key), "Value should be same as value before saving.");
            }
        }
Esempio n. 4
0
        public void SerializingToFileTest()
        {
            // prepare empty settings
            var settings = new TestSettings(1, this.CreateSettingsSerializer());

            // save to file
            var filePath = Path.Combine(Path.GetDirectoryName(Process.GetCurrentProcess().MainModule.FileName).AsNonNull(), this.testFileName);

            settings.Save(filePath);

            // modify values
            foreach (var keyValue in TestSettings.TestValues)
            {
                var key   = keyValue.Key;
                var value = keyValue.Value;
                settings.SetValue(key, value);
                Assert.AreNotEqual(value, key.DefaultValue, "Test value should be different from default value.");
                Assert.AreEqual(value, settings.GetValueOrDefault(key), "Value should be same as set one.");
            }

            // load from file
            settings.Load(filePath);

            // check values
            Assert.IsFalse(settings.IsOnUpgradeCalled, "Setting upgrading should not be called.");
            foreach (var key in TestSettings.AllKeys)
            {
                Assert.AreEqual(key.DefaultValue, settings.GetValueOrDefault(key), "Value should be same as default value.");
            }

            // modify values
            foreach (var keyValue in TestSettings.TestValues)
            {
                settings.SetValue(keyValue.Key, keyValue.Value);
            }

            // save to file
            settings.Save(filePath);

            // reset and load from file
            settings.ResetValues();
            settings.Load(filePath);

            // check values
            Assert.IsFalse(settings.IsOnUpgradeCalled, "Setting upgrading should not be called.");
            foreach (var keyValue in TestSettings.TestValues)
            {
                Assert.AreEqual(keyValue.Value, settings.GetValueOrDefault(keyValue.Key), "Value should be same as value before saving.");
            }
        }