public void EventsTest()
{
// prepare
var settings = new TestSettings(1, JsonSettingsSerializer.Default);
var settingChangedEventArgs = (SettingChangedEventArgs?)null;
var settingChangingEventArgs = (SettingChangingEventArgs?)null;
settings.SettingChanged += (_, e) => settingChangedEventArgs = e;
settings.SettingChanging += (_, e) => settingChangingEventArgs = e;
// reset value
settings.ResetValue(TestSettings.Int32Key);
Assert.IsNull(settingChangingEventArgs, "Should not receive SettingChanging event.");
Assert.IsNull(settingChangedEventArgs, "Should not receive SettingChanged event.");
// modify value
var testValue = TestSettings.TestValues[TestSettings.Int32Key];
settings.SetValue(TestSettings.Int32Key, testValue);
Assert.IsNotNull(settingChangingEventArgs, "Should receive SettingsChanging event.");
Assert.AreEqual(TestSettings.Int32Key, settingChangingEventArgs?.Key, "Key reported by SettingChanging is incorrect.");
Assert.AreEqual(TestSettings.Int32Key.DefaultValue, settingChangingEventArgs?.Value, "Current value reported by SettingChanging is incorrect.");
Assert.AreEqual(testValue, settingChangingEventArgs?.NewValue, "New value reported by SettingChanging is incorrect.");
Assert.IsNotNull(settingChangedEventArgs, "Should receive SettingChanged event.");
Assert.AreEqual(TestSettings.Int32Key.DefaultValue, settingChangedEventArgs?.PreviousValue, "Previous value reported by SettingChanged is incorrect.");
Assert.AreEqual(testValue, settingChangedEventArgs?.Value, "Current value reported by SettingChanged is incorrect.");
// modify by same value
settingChangingEventArgs = null;
settingChangedEventArgs = null;
settings.SetValue(TestSettings.Int32Key, testValue);
Assert.IsNull(settingChangingEventArgs, "Should not receive SettingChanging event.");
Assert.IsNull(settingChangedEventArgs, "Should not receive SettingChanged event.");
}
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.");
}
}
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.");
}
}
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.");
}
}
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.");
}
}
public void UpgradingTest()
{
// prepare settings with older version
var settings = new TestSettings(1, this.CreateSettingsSerializer());
foreach (var keyValue in TestSettings.TestValues)
{
settings.SetValue(keyValue.Key, keyValue.Value);
}
// save to memory
var data = new MemoryStream().Use((stream) =>
{
settings.Save(stream);
return(stream.ToArray());
});
// create settings with newer version
var newSettings = new TestSettings(2, this.CreateSettingsSerializer());
// load from memory
using (var stream = new MemoryStream(data))
newSettings.Load(stream);
// check upgrading state
Assert.IsTrue(newSettings.IsOnUpgradeCalled, "Upgrading should happens after loading.");
Assert.AreEqual(1, newSettings.OldVersion, "Incorrect old version when upgrading.");
newSettings.IsOnUpgradeCalled = false;
// save and load new settings
data = new MemoryStream().Use((stream) =>
{
newSettings.Save(stream);
return(stream.ToArray());
});
using (var stream = new MemoryStream(data))
newSettings.Load(stream);
// check upgrading state
Assert.IsFalse(newSettings.IsOnUpgradeCalled, "Upgrading should not happens after loading.");
}
