private void TestWriteNull_Xml(Type settingsClass)
{
SystemConfigurationHelper.GetExeConfiguration().RemoveSettingsValues(settingsClass);
try
{
var values = GetExeConfiguration().GetSettingsValues(settingsClass);
Assert.AreEqual(0, values.Count);
values = new Dictionary <string, string>();
values[LocalXmlSettingsBase.PropertyApp] = null;
SystemConfigurationHelper.GetExeConfiguration().PutSettingsValues(settingsClass, values);
values = GetExeConfiguration().GetSettingsValues(settingsClass);
Assert.AreEqual(0, values.Count);
LocalXmlSettingsBase settings = (LocalXmlSettingsBase)ApplicationSettingsHelper.GetSettingsClassInstance(settingsClass);
XmlDocument defaultDoc = new XmlDocument();
defaultDoc.LoadXml(LocalXmlSettingsBase.DefaultValueApp);
Assert.AreEqual(defaultDoc.DocumentElement.OuterXml, settings.App.DocumentElement.OuterXml);
}
finally
{
SystemConfigurationHelper.GetExeConfiguration().RemoveSettingsValues(settingsClass);
}
}
private static void ValidateStoredValues(Type type, MigrationScope migrationScope, SettingValue expectedValue)
{
var settings = ApplicationSettingsHelper.GetSettingsClassInstance(type);
foreach (SettingsProperty property in settings.Properties)
{
string expected = CreateSettingValue(property, migrationScope, expectedValue);
if (migrationScope == MigrationScope.User)
{
if (SettingsPropertyExtensions.IsAppScoped(property))
{
continue;
}
string actual = (string)settings[property.Name];
Assert.AreEqual(expected, actual);
}
else
{
if (SettingsPropertyExtensions.IsAppScoped(property))
{
string actual = (string)settings[property.Name];
Assert.AreEqual(expected, actual);
}
string shared = (string)ApplicationSettingsExtensions.GetSharedPropertyValue(settings, property.Name);
Assert.AreEqual(expected, shared);
}
}
}
private void TestWriteEmptyString_String(Type settingsClass)
{
var configuration = SystemConfigurationHelper.GetExeConfiguration();
var values = new Dictionary <string, string>();
values[MixedScopeSettingsBase.PropertyApp1] = "Test1";
values[MixedScopeSettingsBase.PropertyApp2] = "Test2";
configuration.PutSettingsValues(settingsClass, values);
values = GetExeConfiguration().GetSettingsValues(settingsClass);
Assert.AreEqual(2, values.Count);
Assert.AreEqual("Test1", values[MixedScopeSettingsBase.PropertyApp1]);
Assert.AreEqual("Test2", values[MixedScopeSettingsBase.PropertyApp2]);
values = new Dictionary <string, string>();
values[MixedScopeSettingsBase.PropertyApp1] = "";
values[MixedScopeSettingsBase.PropertyApp2] = "";
configuration.PutSettingsValues(settingsClass, values);
values = GetExeConfiguration().GetSettingsValues(settingsClass);
Assert.AreEqual(2, values.Count);
Assert.AreEqual("", values[MixedScopeSettingsBase.PropertyApp1]);
Assert.AreEqual("", values[MixedScopeSettingsBase.PropertyApp2]);
//For string values, empty string means empty string.
var settings = (MixedScopeSettingsBase)ApplicationSettingsHelper.GetSettingsClassInstance(settingsClass);
Assert.AreEqual("", settings.App1);
Assert.AreEqual("", settings.App2);
}
private void TestWriteNull_String(Type settingsClass)
{
var configuration = SystemConfigurationHelper.GetExeConfiguration();
var values = new Dictionary <string, string>();
values[MixedScopeSettingsBase.PropertyApp1] = "Test1";
values[MixedScopeSettingsBase.PropertyApp2] = "Test2";
configuration.PutSettingsValues(settingsClass, values);
values = GetExeConfiguration().GetSettingsValues(settingsClass);
Assert.AreEqual(2, values.Count);
Assert.AreEqual("Test1", values[MixedScopeSettingsBase.PropertyApp1]);
Assert.AreEqual("Test2", values[MixedScopeSettingsBase.PropertyApp2]);
values = new Dictionary <string, string>();
values[MixedScopeSettingsBase.PropertyApp1] = null;
values[MixedScopeSettingsBase.PropertyApp2] = null;
//writing null essentially means to reset it to the default, which is equivalent to removing it.
configuration.PutSettingsValues(settingsClass, values);
values = GetExeConfiguration().GetSettingsValues(settingsClass);
Assert.AreEqual(0, values.Count);
var settings = (MixedScopeSettingsBase)ApplicationSettingsHelper.GetSettingsClassInstance(settingsClass);
Assert.AreEqual(MixedScopeSettingsBase.PropertyApp1, settings.App1);
Assert.AreEqual(MixedScopeSettingsBase.PropertyApp2, settings.App2);
}
public void TestWriteEmptyString_String()
{
RemoveSettings();
var configuration = SystemConfigurationHelper.GetExeConfiguration();
var values = new Dictionary <string, string>();
values[LocalMixedScopeSettings.PropertyApp1] = "Test1";
values[LocalMixedScopeSettings.PropertyApp2] = "Test2";
SystemConfigurationHelper.PutSettingsValues(configuration, _settingsClass, values);
values = SystemConfigurationHelper.GetSettingsValues(GetExeConfiguration(), _settingsClass);
Assert.AreEqual(2, values.Count);
Assert.AreEqual("Test1", values[LocalMixedScopeSettings.PropertyApp1]);
Assert.AreEqual("Test2", values[LocalMixedScopeSettings.PropertyApp2]);
values = new Dictionary <string, string>();
values[LocalMixedScopeSettings.PropertyApp1] = "";
values[LocalMixedScopeSettings.PropertyApp2] = "";
SystemConfigurationHelper.PutSettingsValues(configuration, _settingsClass, values);
values = SystemConfigurationHelper.GetSettingsValues(GetExeConfiguration(), _settingsClass);
Assert.AreEqual(2, values.Count);
Assert.AreEqual("", values[LocalMixedScopeSettings.PropertyApp1]);
Assert.AreEqual("", values[LocalMixedScopeSettings.PropertyApp2]);
//For string values, empty string means empty string.
var settings = (LocalMixedScopeSettings)ApplicationSettingsHelper.GetSettingsClassInstance(_settingsClass);
Assert.AreEqual("", settings.App1);
Assert.AreEqual("", settings.App2);
}
public void TestWriteEmptyString_Xml()
{
Type settingsClass = typeof(LocalXmlSettings);
SystemConfigurationHelper.RemoveSettingsValues(SystemConfigurationHelper.GetExeConfiguration(), settingsClass);
try
{
var values = SystemConfigurationHelper.GetSettingsValues(GetExeConfiguration(), settingsClass);
Assert.AreEqual(0, values.Count);
values = new Dictionary <string, string>();
values[LocalXmlSettings.PropertyApp] = "";
SystemConfigurationHelper.PutSettingsValues(SystemConfigurationHelper.GetExeConfiguration(), settingsClass, values);
values = SystemConfigurationHelper.GetSettingsValues(GetExeConfiguration(), settingsClass);
Assert.AreEqual(1, values.Count);
Assert.AreEqual("", values[LocalXmlSettings.PropertyApp]);
//For xml values, empty string means "default".
LocalXmlSettings settings = (LocalXmlSettings)ApplicationSettingsHelper.GetSettingsClassInstance(settingsClass);
XmlDocument defaultDoc = new XmlDocument();
defaultDoc.LoadXml(LocalXmlSettings.DefaultValueApp);
Assert.AreEqual(defaultDoc.DocumentElement.OuterXml, settings.App.DocumentElement.OuterXml);
}
finally
{
SystemConfigurationHelper.RemoveSettingsValues(SystemConfigurationHelper.GetExeConfiguration(), settingsClass);
}
}
public void TestWriteNull_String()
{
RemoveSettings();
var configuration = SystemConfigurationHelper.GetExeConfiguration();
var values = new Dictionary <string, string>();
values[LocalMixedScopeSettings.PropertyApp1] = "Test1";
values[LocalMixedScopeSettings.PropertyApp2] = "Test2";
SystemConfigurationHelper.PutSettingsValues(configuration, _settingsClass, values);
values = SystemConfigurationHelper.GetSettingsValues(GetExeConfiguration(), _settingsClass);
Assert.AreEqual(2, values.Count);
Assert.AreEqual("Test1", values[LocalMixedScopeSettings.PropertyApp1]);
Assert.AreEqual("Test2", values[LocalMixedScopeSettings.PropertyApp2]);
values = new Dictionary <string, string>();
values[LocalMixedScopeSettings.PropertyApp1] = null;
values[LocalMixedScopeSettings.PropertyApp2] = null;
//writing null essentially means to reset it to the default, which is equivalent to removing it.
SystemConfigurationHelper.PutSettingsValues(configuration, _settingsClass, values);
values = SystemConfigurationHelper.GetSettingsValues(GetExeConfiguration(), _settingsClass);
Assert.AreEqual(0, values.Count);
var settings = (LocalMixedScopeSettings)ApplicationSettingsHelper.GetSettingsClassInstance(_settingsClass);
Assert.AreEqual(LocalMixedScopeSettings.PropertyApp1, settings.App1);
Assert.AreEqual(LocalMixedScopeSettings.PropertyApp2, settings.App2);
}
public void TestGetPreviousSharedValues_Exists()
{
ResetAllSettingsClasses();
string path = Path.GetDirectoryName(ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None).FilePath);
string fileName = String.Format("{0}{1}TestPrevious.exe.config", path, System.IO.Path.DirectorySeparatorChar);
TestConfigResourceToFile(fileName);
try
{
var settings = ApplicationSettingsHelper.GetSettingsClassInstance(_settingsClass);
settings.Reload();
foreach (SettingsProperty property in settings.Properties)
{
var actual = ApplicationSettingsExtensions.GetPreviousSharedPropertyValue(settings, property.Name, fileName);
var expected = CreateSettingValue(property, MigrationScope.Shared, SettingValue.Previous);
Assert.AreEqual(expected, actual);
}
}
finally
{
File.Delete(fileName);
}
}
public void TestReadStringSettings()
{
Type settingsClass = typeof(LocalMixedScopeSettings);
var settings = ApplicationSettingsHelper.GetSettingsClassInstance(settingsClass);
ApplicationSettingsExtensions.SetSharedPropertyValue(settings, LocalMixedScopeSettings.PropertyApp1, "TestApp1");
ApplicationSettingsExtensions.SetSharedPropertyValue(settings, LocalMixedScopeSettings.PropertyApp2, "TestApp2");
ApplicationSettingsExtensions.SetSharedPropertyValue(settings, LocalMixedScopeSettings.PropertyUser1, "TestUser1");
ApplicationSettingsExtensions.SetSharedPropertyValue(settings, LocalMixedScopeSettings.PropertyUser2, "TestUser2");
var reader = new ConfigurationFileReader(SystemConfigurationHelper.GetExeConfiguration().FilePath);
var path = new ConfigurationSectionPath(typeof(LocalMixedScopeSettings), SettingScope.Application);
var values = reader.GetSettingsValues(path);
Assert.AreEqual(2, values.Count);
Assert.AreEqual("TestApp1", values[LocalMixedScopeSettings.PropertyApp1]);
Assert.AreEqual("TestApp2", values[LocalMixedScopeSettings.PropertyApp2]);
path = new ConfigurationSectionPath(typeof(LocalMixedScopeSettings), SettingScope.User);
values = reader.GetSettingsValues(path);
Assert.AreEqual(2, values.Count);
Assert.AreEqual("TestUser1", values[LocalMixedScopeSettings.PropertyUser1]);
Assert.AreEqual("TestUser2", values[LocalMixedScopeSettings.PropertyUser2]);
SystemConfigurationHelper.RemoveSettingsValues(SystemConfigurationHelper.GetExeConfiguration(), settingsClass);
}
public void TestReadStringSettings(Type localSettingsClass)
{
var settings = ApplicationSettingsHelper.GetSettingsClassInstance(localSettingsClass);
settings.SetSharedPropertyValue(MixedScopeSettingsBase.PropertyApp1, "TestApp1");
settings.SetSharedPropertyValue(MixedScopeSettingsBase.PropertyApp2, "TestApp2");
settings.SetSharedPropertyValue(MixedScopeSettingsBase.PropertyUser1, "TestUser1");
settings.SetSharedPropertyValue(MixedScopeSettingsBase.PropertyUser2, "TestUser2");
var reader = new ConfigurationFileReader(SystemConfigurationHelper.GetExeConfiguration().FilePath);
var path = new ConfigurationSectionPath(localSettingsClass, SettingScope.Application);
var values = reader.GetSettingsValues(path);
Assert.AreEqual(2, values.Count);
Assert.AreEqual("TestApp1", values[MixedScopeSettingsBase.PropertyApp1]);
Assert.AreEqual("TestApp2", values[MixedScopeSettingsBase.PropertyApp2]);
path = new ConfigurationSectionPath(localSettingsClass, SettingScope.User);
values = reader.GetSettingsValues(path);
Assert.AreEqual(2, values.Count);
Assert.AreEqual("TestUser1", values[MixedScopeSettingsBase.PropertyUser1]);
Assert.AreEqual("TestUser2", values[MixedScopeSettingsBase.PropertyUser2]);
SystemConfigurationHelper.GetExeConfiguration().RemoveSettingsValues(localSettingsClass);
}
public void TestSimpleUserSettingsMigration()
{
ResetUpgradeSettings();
Type settingsClass = typeof(SimpleUserSettings);
PopulateSimpleStore(settingsClass);
Assert.IsTrue(SettingsMigrator.MigrateUserSettings(settingsClass));
var settings = ApplicationSettingsHelper.GetSettingsClassInstance(settingsClass);
SettingsProperty property = settings.Properties[SimpleUserSettings.PropertyUser];
string expected = CreateSettingValue(property, MigrationScope.User, SettingValue.Previous);
string actual = (string)settings[property.Name];
Assert.AreEqual(expected, actual);
expected = CreateSettingValue(property, MigrationScope.Shared, SettingValue.Current);
actual = (string)ApplicationSettingsExtensions.GetSharedPropertyValue(settings, property.Name);
Assert.AreEqual(expected, actual);
expected = CreateSettingValue(property, MigrationScope.User, SettingValue.Previous);
Assert.IsFalse(SettingsMigrator.MigrateUserSettings(settingsClass));
actual = (string)settings[property.Name];
Assert.AreEqual(expected, actual);
expected = CreateSettingValue(property, MigrationScope.Shared, SettingValue.Current);
actual = (string)ApplicationSettingsExtensions.GetSharedPropertyValue(settings, property.Name);
Assert.AreEqual(expected, actual);
}
public void TestReadWriteValues_Xml()
{
Type settingsClass = typeof(LocalXmlSettings);
SystemConfigurationHelper.RemoveSettingsValues(SystemConfigurationHelper.GetExeConfiguration(), settingsClass);
try
{
var values = SystemConfigurationHelper.GetSettingsValues(GetExeConfiguration(), settingsClass);
Assert.AreEqual(0, values.Count);
values = new Dictionary <string, string>();
values[LocalXmlSettings.PropertyUser] = LocalXmlSettings.DefaultValueUser;
values[LocalXmlSettings.PropertyApp] = LocalXmlSettings.DefaultValueApp;
SystemConfigurationHelper.PutSettingsValues(SystemConfigurationHelper.GetExeConfiguration(), settingsClass, values);
values = SystemConfigurationHelper.GetSettingsValues(GetExeConfiguration(), settingsClass);
Assert.AreEqual(1, values.Count);
LocalXmlSettings settings = (LocalXmlSettings)ApplicationSettingsHelper.GetSettingsClassInstance(settingsClass);
Assert.IsNull(ApplicationSettingsExtensions.GetSharedPropertyValue(settings, LocalXmlSettings.PropertyUser));
XmlDocument defaultDoc = new XmlDocument();
defaultDoc.LoadXml(LocalXmlSettings.DefaultValueApp);
Assert.AreEqual(defaultDoc.DocumentElement.OuterXml, settings.App.DocumentElement.OuterXml);
}
finally
{
SystemConfigurationHelper.RemoveSettingsValues(SystemConfigurationHelper.GetExeConfiguration(), settingsClass);
}
}
private void ValidateLocalMixedScopeSettingsValuesInConfig(System.Configuration.Configuration configuration, SettingValue settingValue)
{
Type settingsClass = typeof(LocalMixedScopeSettings);
var settings = ApplicationSettingsHelper.GetSettingsClassInstance(settingsClass);
settings.Reload();
SettingsProperty property = settings.Properties[LocalMixedScopeSettings.PropertyApp1];
string expected = CreateSettingValue(property, MigrationScope.Shared, settingValue);
string actual = (string)settings[property.Name];
Assert.AreEqual(expected, actual);
actual = (string)ApplicationSettingsExtensions.GetSharedPropertyValue(settings, property.Name);
Assert.AreEqual(expected, actual);
property = settings.Properties[LocalMixedScopeSettings.PropertyApp2];
expected = CreateSettingValue(property, MigrationScope.Shared, settingValue);
actual = (string)settings[property.Name];
Assert.AreEqual(expected, actual);
actual = (string)ApplicationSettingsExtensions.GetSharedPropertyValue(settings, property.Name);
Assert.AreEqual(expected, actual);
property = settings.Properties[LocalMixedScopeSettings.PropertyUser1];
expected = CreateSettingValue(property, MigrationScope.Shared, settingValue);
actual = (string)ApplicationSettingsExtensions.GetSharedPropertyValue(settings, property.Name);
Assert.AreEqual(expected, actual);
property = settings.Properties[LocalMixedScopeSettings.PropertyUser2];
expected = CreateSettingValue(property, MigrationScope.Shared, settingValue);
actual = (string)ApplicationSettingsExtensions.GetSharedPropertyValue(settings, property.Name);
Assert.AreEqual(expected, actual);
var values = SystemConfigurationHelper.GetSettingsValues(configuration, settingsClass, SettingScope.Application);
Assert.AreEqual(2, values.Count);
property = settings.Properties[LocalMixedScopeSettings.PropertyApp1];
expected = CreateSettingValue(property, MigrationScope.Shared, settingValue);
actual = values[property.Name];
Assert.AreEqual(expected, actual);
property = settings.Properties[LocalMixedScopeSettings.PropertyApp2];
expected = CreateSettingValue(property, MigrationScope.Shared, settingValue);
actual = values[property.Name];
Assert.AreEqual(expected, actual);
values = SystemConfigurationHelper.GetSettingsValues(configuration, settingsClass, SettingScope.User);
Assert.AreEqual(2, values.Count);
property = settings.Properties[LocalMixedScopeSettings.PropertyUser1];
expected = CreateSettingValue(property, MigrationScope.Shared, settingValue);
actual = values[property.Name];
Assert.AreEqual(expected, actual);
property = settings.Properties[LocalMixedScopeSettings.PropertyUser2];
expected = CreateSettingValue(property, MigrationScope.Shared, settingValue);
actual = values[property.Name];
Assert.AreEqual(expected, actual);
}
public static void ResetAll()
{
foreach (Type type in _testType.Assembly.GetTypes())
{
if (type.IsSubclassOf(_testType) && !type.IsAbstract)
{
ApplicationSettingsHelper.GetSettingsClassInstance(type).Reset();
}
}
}
public void RunApplication(string[] args)
{
CommandLine commandLine = new CommandLine(args);
foreach (SettingsGroupDescriptor group in SettingsGroupDescriptor.ListInstalledSettingsGroups(SettingsGroupFilter.LocalStorage))
{
Type type = Type.GetType(group.AssemblyQualifiedTypeName, true);
var settings = ApplicationSettingsHelper.GetSettingsClassInstance(type);
ApplicationSettingsExtensions.ImportSharedSettings(settings, commandLine.ConfigurationFilename);
}
}
private void TestGetPreviousSharedValues_NoneExist(Type settingsClass)
{
var settings = ApplicationSettingsHelper.GetSettingsClassInstance(settingsClass);
settings.Reload();
foreach (SettingsProperty property in settings.Properties)
{
var previous = settings.GetPreviousSharedPropertyValue(property.Name, null);
Assert.IsNull(previous);
}
}
public void TestGetPreviousSharedValues_NoneExist()
{
ResetAllSettingsClasses();
var settings = ApplicationSettingsHelper.GetSettingsClassInstance(_settingsClass);
settings.Reload();
foreach (SettingsProperty property in settings.Properties)
{
var previous = ApplicationSettingsExtensions.GetPreviousSharedPropertyValue(settings, property.Name, null);
Assert.IsNull(previous);
}
}
private static void TestMultipleSharedSettingsMigrated(Type mixedScopeSettingsClass)
{
if (!mixedScopeSettingsClass.IsSubclassOf(typeof(MixedScopeSettingsBase)))
{
throw new ArgumentException();
}
ResetSimpleStore();
ResetAllSettingsClasses();
PopulateSimpleStore(mixedScopeSettingsClass);
SettingsMigrator.MigrateSharedSettings(mixedScopeSettingsClass, null);
var settings = ApplicationSettingsHelper.GetSettingsClassInstance(mixedScopeSettingsClass);
SettingsProperty property = settings.Properties[MixedScopeSettingsBase.PropertyUser1];
string expected = CreateSettingValue(property, MigrationScope.User, SettingValue.Current);
var actual = (string)settings[property.Name];
Assert.AreEqual(expected, actual);
property = settings.Properties[MixedScopeSettingsBase.PropertyUser2];
expected = CreateSettingValue(property, MigrationScope.User, SettingValue.Current);
actual = (string)settings[property.Name];
Assert.AreEqual(expected, actual);
property = settings.Properties[MixedScopeSettingsBase.PropertyApp1];
expected = CreateSettingValue(property, MigrationScope.Shared, SettingValue.Previous);
actual = (string)settings.GetSharedPropertyValue(property.Name);
Assert.AreEqual(expected, actual);
actual = (string)settings[property.Name];
Assert.AreEqual(expected, actual);
property = settings.Properties[MixedScopeSettingsBase.PropertyApp2];
expected = CreateSettingValue(property, MigrationScope.Shared, SettingValue.Previous);
actual = (string)settings.GetSharedPropertyValue(property.Name);
Assert.AreEqual(expected, actual);
actual = (string)settings[property.Name];
Assert.AreEqual(expected, actual);
property = settings.Properties[MixedScopeSettingsBase.PropertyUser1];
expected = CreateSettingValue(property, MigrationScope.Shared, SettingValue.Previous);
actual = (string)settings.GetSharedPropertyValue(property.Name);
Assert.AreEqual(expected, actual);
property = settings.Properties[MixedScopeSettingsBase.PropertyUser2];
expected = CreateSettingValue(property, MigrationScope.Shared, SettingValue.Previous);
actual = (string)settings.GetSharedPropertyValue(property.Name);
Assert.AreEqual(expected, actual);
}
public void ReloadSettings()
{
try
{
Platform.Log(LogLevel.Info, "Forcing reload of MemoryManagementSettings.");
var groups = SettingsGroupDescriptor.ListInstalledSettingsGroups(SettingsGroupFilter.LocalStorage);
var settingsGroups = groups.First(g => g.Name == "ClearCanvas.ImageViewer.Common.MemoryManagementSettings");
var instance = ApplicationSettingsHelper.GetSettingsClassInstance(Type.GetType(settingsGroups.AssemblyQualifiedTypeName));
instance.Reload();
}
catch (Exception e)
{
ExceptionHandler.Report(e, Context.DesktopWindow);
}
}
public void TestCustomUserSettingsMigration()
{
ResetSimpleStore();
ResetAllSettingsClasses();
Type settingsClass = typeof(CustomMigrationMixedScopeSettings);
PopulateSimpleStore(settingsClass);
SettingsMigrator.MigrateUserSettings(settingsClass);
var settings = ApplicationSettingsHelper.GetSettingsClassInstance(settingsClass);
SettingsProperty property = settings.Properties[MixedScopeSettingsBase.PropertyUser1];
string expected = "CustomUser1";
var actual = (string)settings[property.Name];
Assert.AreEqual(expected, actual);
property = settings.Properties[MixedScopeSettingsBase.PropertyUser2];
expected = CreateSettingValue(property, MigrationScope.User, SettingValue.Previous);
actual = (string)settings[property.Name];
Assert.AreEqual(expected, actual);
property = settings.Properties[MixedScopeSettingsBase.PropertyApp1];
expected = CreateSettingValue(property, MigrationScope.Shared, SettingValue.Current);
actual = (string)settings.GetSharedPropertyValue(property.Name);
Assert.AreEqual(expected, actual);
actual = (string)settings[property.Name];
Assert.AreEqual(expected, actual);
property = settings.Properties[MixedScopeSettingsBase.PropertyApp2];
expected = CreateSettingValue(property, MigrationScope.Shared, SettingValue.Current);
actual = (string)settings.GetSharedPropertyValue(property.Name);
Assert.AreEqual(expected, actual);
actual = (string)settings[property.Name];
Assert.AreEqual(expected, actual);
property = settings.Properties[MixedScopeSettingsBase.PropertyUser1];
expected = CreateSettingValue(property, MigrationScope.Shared, SettingValue.Current);
actual = (string)settings.GetSharedPropertyValue(property.Name);
Assert.AreEqual(expected, actual);
property = settings.Properties[MixedScopeSettingsBase.PropertyUser2];
expected = CreateSettingValue(property, MigrationScope.Shared, SettingValue.Current);
actual = (string)settings.GetSharedPropertyValue(property.Name);
Assert.AreEqual(expected, actual);
}
private void TestGetSharedSettings_NoneExist(Type settingsClass)
{
RemoveSettings(settingsClass);
var settings = ApplicationSettingsHelper.GetSettingsClassInstance(settingsClass);
settings.Reload();
foreach (SettingsProperty property in settings.Properties)
{
var shared = settings.GetSharedPropertyValue(property.Name);
Assert.AreEqual(property.DefaultValue, shared);
if (SettingsPropertyExtensions.IsAppScoped(property))
{
Assert.AreEqual(property.DefaultValue, settings[property.Name]);
}
}
}
private static void TestMigrateXmlSettings(Type xmlSettingsClass)
{
if (!xmlSettingsClass.IsSubclassOf(typeof(LocalXmlSettingsBase)))
{
throw new ArgumentException();
}
var configuration = SystemConfigurationHelper.GetExeConfiguration();
var settings = (LocalXmlSettingsBase)ApplicationSettingsHelper.GetSettingsClassInstance(xmlSettingsClass);
var document = new XmlDocument();
document.LoadXml((string)settings.Properties[LocalXmlSettingsBase.PropertyApp].DefaultValue);
var node = document.SelectSingleNode("//test");
node.InnerText = "CurrentApp";
var values = new Dictionary <string, string>();
values[LocalXmlSettingsBase.PropertyApp] = document.InnerXml;
configuration.PutSettingsValues(xmlSettingsClass, values);
string directory = Path.GetDirectoryName(configuration.FilePath);
string previousExeFilename = String.Format("{0}{1}Previous.exe.config", directory, Path.DirectorySeparatorChar);
try
{
TestConfigResourceToFile(previousExeFilename);
SettingsMigrator.MigrateSharedSettings(xmlSettingsClass, previousExeFilename);
configuration = SystemConfigurationHelper.GetExeConfiguration();
settings = (LocalXmlSettingsBase)ApplicationSettingsHelper.GetSettingsClassInstance(xmlSettingsClass);
settings.Reload();
document = (XmlDocument)settings.GetSharedPropertyValue(LocalXmlSettingsBase.PropertyApp);
Assert.AreEqual("PreviousApp", document.SelectSingleNode("//test").InnerXml);
document = settings.App;
Assert.AreEqual("PreviousApp", document.SelectSingleNode("//test").InnerXml);
}
finally
{
File.Delete(previousExeFilename);
configuration.RemoveSettingsValues(xmlSettingsClass);
}
}
public void TestNonMigratableSharedSettings()
{
ResetUpgradeSettings();
Type settingsClass = typeof(NonMigratableSharedSettings);
PopulateSimpleStore(settingsClass);
Assert.IsFalse(SettingsMigrator.MigrateSharedSettings(settingsClass, null));
var settings = ApplicationSettingsHelper.GetSettingsClassInstance(settingsClass);
SettingsProperty property = settings.Properties[NonMigratableSharedSettings.PropertyApp];
string expected = CreateSettingValue(property, MigrationScope.Shared, SettingValue.Current);
Assert.AreEqual(expected, settings[property.Name]);
string current = (string)ApplicationSettingsExtensions.GetSharedPropertyValue(settings, property.Name);
Assert.AreEqual(expected, current);
}
private void TestGetSharedSettings_Exists(Type settingsClass)
{
RemoveSettings(settingsClass);
SystemConfigurationHelperTests.WriteSharedValuesToConfig(settingsClass, SettingValue.Current);
var settings = ApplicationSettingsHelper.GetSettingsClassInstance(settingsClass);
settings.Reload();
foreach (SettingsProperty property in settings.Properties)
{
var shared = settings.GetSharedPropertyValue(property.Name);
string expected = CreateSettingValue(property, MigrationScope.Shared, SettingValue.Current);
Assert.AreEqual(expected, shared);
if (SettingsPropertyExtensions.IsAppScoped(property))
{
Assert.AreEqual(expected, settings[property.Name]);
}
}
}
public void TestUserDefaultSettingsMigrated()
{
ResetUpgradeSettings();
Type settingsClass = typeof(SimpleUserSettings);
PopulateSimpleStore(settingsClass);
Assert.IsTrue(SettingsMigrator.MigrateSharedSettings(settingsClass, null));
var settings = ApplicationSettingsHelper.GetSettingsClassInstance(settingsClass);
SettingsProperty property = settings.Properties[SimpleUserSettings.PropertyUser];
string expected = CreateSettingValue(property, MigrationScope.User, SettingValue.Current);
Assert.AreEqual(expected, settings[property.Name]);
expected = CreateSettingValue(property, MigrationScope.Shared, SettingValue.Previous);
string current = (string)settings.GetSharedPropertyValue(property.Name);
Assert.AreEqual(expected, current);
}
private void TestSetSharedSettings(Type settingsClass)
{
if (!settingsClass.IsSubclassOf(typeof(MixedScopeSettingsBase)))
{
throw new ArgumentException();
}
RemoveSettings(settingsClass);
var settings = ApplicationSettingsHelper.GetSettingsClassInstance(settingsClass);
Assert.AreEqual(MixedScopeSettingsBase.PropertyApp1, settings[MixedScopeSettingsBase.PropertyApp1]);
Assert.AreEqual(MixedScopeSettingsBase.PropertyApp2, settings[MixedScopeSettingsBase.PropertyApp2]);
Assert.AreEqual(MixedScopeSettingsBase.PropertyUser1, settings[MixedScopeSettingsBase.PropertyUser1]);
Assert.AreEqual(MixedScopeSettingsBase.PropertyUser2, settings[MixedScopeSettingsBase.PropertyUser2]);
settings.SetSharedPropertyValue(MixedScopeSettingsBase.PropertyApp1, "TestApp1");
settings.SetSharedPropertyValue(MixedScopeSettingsBase.PropertyApp2, "TestApp2");
settings.SetSharedPropertyValue(MixedScopeSettingsBase.PropertyUser1, "TestUser1");
settings.SetSharedPropertyValue(MixedScopeSettingsBase.PropertyUser2, "TestUser2");
//There is no default, so this is a new instance.
settings = ApplicationSettingsHelper.GetSettingsClassInstance(settingsClass);
Assert.AreEqual("TestApp1", settings[MixedScopeSettingsBase.PropertyApp1]);
Assert.AreEqual("TestApp2", settings[MixedScopeSettingsBase.PropertyApp2]);
Assert.AreEqual("TestUser1", settings.GetSharedPropertyValue(MixedScopeSettingsBase.PropertyUser1));
Assert.AreEqual("TestUser2", settings.GetSharedPropertyValue(MixedScopeSettingsBase.PropertyUser2));
/*
* //Just because ... test setting a user value.
* settings[MixedScopeSettings.PropertyUser1] = "TestUserblah";
* settings.Save();
*
* settings = ApplicationSettingsHelper.GetSettingsClassInstance(settingsClass);
* Assert.AreEqual("TestUserblah", settings[MixedScopeSettings.PropertyUser1]);
* Assert.AreEqual("TestUser1", settings.GetSharedPropertyValue(MixedScopeSettingsBase.PropertyUser1));
* settings.Reset();
*/
}
public void TestReadXmlSettings()
{
Type settingsClass = typeof(LocalXmlSettings);
var settings = ApplicationSettingsHelper.GetSettingsClassInstance(settingsClass);
var appValue = @"<test><app/></test>";
XmlDocument appDocument = new XmlDocument();
appDocument.LoadXml(appValue);
ApplicationSettingsExtensions.SetSharedPropertyValue(settings, LocalXmlSettings.PropertyApp, appDocument);
var userValue = @"<test><user/></test>";
XmlDocument userDocument = new XmlDocument();
userDocument.LoadXml(userValue);
ApplicationSettingsExtensions.SetSharedPropertyValue(settings, LocalXmlSettings.PropertyUser, userDocument);
var reader = new ConfigurationFileReader(SystemConfigurationHelper.GetExeConfiguration().FilePath);
var path = new ConfigurationSectionPath(typeof(LocalXmlSettings), SettingScope.Application);
var values = reader.GetSettingsValues(path);
Assert.AreEqual(1, values.Count);
XmlDocument testDocument = new XmlDocument();
testDocument.LoadXml(values[LocalXmlSettings.PropertyApp]);
Assert.AreEqual(appDocument.InnerXml, testDocument.InnerXml);
path = new ConfigurationSectionPath(typeof(LocalXmlSettings), SettingScope.User);
values = reader.GetSettingsValues(path);
Assert.AreEqual(1, values.Count);
testDocument = new XmlDocument();
testDocument.LoadXml(values[LocalXmlSettings.PropertyUser]);
Assert.AreEqual(userDocument.InnerXml, testDocument.InnerXml);
SystemConfigurationHelper.RemoveSettingsValues(SystemConfigurationHelper.GetExeConfiguration(), settingsClass);
}
public static void PopulateSimpleStore(Type type)
{
ResetSimpleStore();
TestApplicationSettingsBase.ResetAll();
var settings = ApplicationSettingsHelper.GetSettingsClassInstance(type);
foreach (SettingsProperty property in settings.Properties)
{
var value = CreateSettingsPropertyValue(property, MigrationScope.User, SettingValue.Current);
if (value != null)
{
SimpleSettingsStore.Instance.CurrentUserValues.Add(value);
}
value = CreateSettingsPropertyValue(property, MigrationScope.User, SettingValue.Previous);
if (value != null)
{
SimpleSettingsStore.Instance.PreviousUserValues.Add(value);
}
value = CreateSettingsPropertyValue(property, MigrationScope.Shared, SettingValue.Current);
if (value != null)
{
SimpleSettingsStore.Instance.CurrentSharedValues.Add(value);
}
value = CreateSettingsPropertyValue(property, MigrationScope.Shared, SettingValue.Previous);
if (value != null)
{
SimpleSettingsStore.Instance.PreviousSharedValues.Add(value);
}
}
ValidateStoredValues(type, MigrationScope.Shared, SettingValue.Current);
ValidateStoredValues(type, MigrationScope.User, SettingValue.Current);
}
private static void ValidateLocalMixedScopeSettingsValuesInConfig(Type mixedScopeSettingsClass, System.Configuration.Configuration configuration, SettingValue settingValue)
{
if (!mixedScopeSettingsClass.IsSubclassOf(typeof(MixedScopeSettingsBase)))
{
throw new ArgumentException();
}
var settings = ApplicationSettingsHelper.GetSettingsClassInstance(mixedScopeSettingsClass);
settings.Reload();
SettingsProperty property = settings.Properties[MixedScopeSettingsBase.PropertyApp1];
string expected = CreateSettingValue(property, MigrationScope.Shared, settingValue);
var actual = (string)settings[property.Name];
Assert.AreEqual(expected, actual);
actual = (string)settings.GetSharedPropertyValue(property.Name);
Assert.AreEqual(expected, actual);
property = settings.Properties[MixedScopeSettingsBase.PropertyApp2];
expected = CreateSettingValue(property, MigrationScope.Shared, settingValue);
actual = (string)settings[property.Name];
Assert.AreEqual(expected, actual);
actual = (string)settings.GetSharedPropertyValue(property.Name);
Assert.AreEqual(expected, actual);
property = settings.Properties[MixedScopeSettingsBase.PropertyUser1];
expected = CreateSettingValue(property, MigrationScope.Shared, settingValue);
actual = (string)settings.GetSharedPropertyValue(property.Name);
Assert.AreEqual(expected, actual);
property = settings.Properties[MixedScopeSettingsBase.PropertyUser2];
expected = CreateSettingValue(property, MigrationScope.Shared, settingValue);
actual = (string)settings.GetSharedPropertyValue(property.Name);
Assert.AreEqual(expected, actual);
var values = configuration.GetSettingsValues(mixedScopeSettingsClass, SettingScope.Application);
Assert.AreEqual(2, values.Count);
property = settings.Properties[MixedScopeSettingsBase.PropertyApp1];
expected = CreateSettingValue(property, MigrationScope.Shared, settingValue);
actual = values[property.Name];
Assert.AreEqual(expected, actual);
property = settings.Properties[MixedScopeSettingsBase.PropertyApp2];
expected = CreateSettingValue(property, MigrationScope.Shared, settingValue);
actual = values[property.Name];
Assert.AreEqual(expected, actual);
values = configuration.GetSettingsValues(mixedScopeSettingsClass, SettingScope.User);
Assert.AreEqual(2, values.Count);
property = settings.Properties[MixedScopeSettingsBase.PropertyUser1];
expected = CreateSettingValue(property, MigrationScope.Shared, settingValue);
actual = values[property.Name];
Assert.AreEqual(expected, actual);
property = settings.Properties[MixedScopeSettingsBase.PropertyUser2];
expected = CreateSettingValue(property, MigrationScope.Shared, settingValue);
actual = values[property.Name];
Assert.AreEqual(expected, actual);
}
