public string GetSetting(Stream stream, IJsonSerializer json, ILogger <LiveTvService> logger)
{
SettingValue root = json.DeserializeFromStream <SettingValue>(stream);
UtilsHelper.DebugInformation(logger, string.Format("[NextPVR] GetSetting Response: {0}", json.SerializeToString(root)));
return(root.value);
}
void IVimCustomSettingSource.SetSettingValue(string name, SettingValue settingValue)
{
if (!settingValue.IsToggle)
{
return;
}
bool value = ((SettingValue.Toggle)settingValue).Item;
switch (name)
{
case UseEditorIndentName:
_vimApplicationSettings.UseEditorIndent = value;
break;
case UseEditorDefaultsName:
_vimApplicationSettings.UseEditorDefaults = value;
break;
case UseEditorTabAndBackspaceName:
_vimApplicationSettings.UseEditorTabAndBackspace = value;
break;
case UseEditorCommandMarginName:
_vimApplicationSettings.UseEditorCommandMargin = value;
break;
default:
value = false;
break;
}
}
SettingValue IVimCustomSettingSource.GetSettingValue(string name)
{
bool value;
switch (name)
{
case UseEditorIndentName:
value = _vimApplicationSettings.UseEditorIndent;
break;
case UseEditorDefaultsName:
value = _vimApplicationSettings.UseEditorDefaults;
break;
case UseEditorTabAndBackspaceName:
value = _vimApplicationSettings.UseEditorTabAndBackspace;
break;
case UseEditorCommandMarginName:
value = _vimApplicationSettings.UseEditorCommandMargin;
break;
case CleanMacros:
value = _vimApplicationSettings.CleanMacros;
break;
default:
value = false;
break;
}
return(SettingValue.NewToggle(value));
}
public void Change_setting_to_db()
{
var command = RepositoryFactory.Command<IAppSettingCommands>();
const int newValueInt = 2;
const string newValueString = "newValue";
const int changeValueInt = 4;
const string changeValueString = "changeValue";
var intSetting = new SettingValue<int>("changeIntVal", 245, new DatabaseSettingProvider());
var stringSetting = new SettingValue<string>("changeStringVal", "defaultValue", new DatabaseSettingProvider());
// create
intSetting.SaveValue(newValueInt);
stringSetting.SaveValue(newValueString);
Assert.AreEqual(newValueInt, intSetting.Value);
Assert.AreEqual(newValueString, stringSetting.Value);
// check if db is really empty
Assert.AreEqual(newValueInt.ToString(CultureInfo.InvariantCulture), command.Get(intSetting.Name).Value);
Assert.AreEqual(newValueString, command.Get(stringSetting.Name).Value);
// change
intSetting.SaveValue(changeValueInt);
stringSetting.SaveValue(changeValueString);
Assert.AreEqual(changeValueInt, intSetting.Value);
Assert.AreEqual(changeValueString, stringSetting.Value);
// check if db is really empty
Assert.AreEqual(changeValueInt.ToString(CultureInfo.InvariantCulture), command.Get(intSetting.Name).Value);
Assert.AreEqual(changeValueString, command.Get(stringSetting.Name).Value);
}
public void LoadSettingValuesForCountry()
{
string policeNumber = "";
string ambulanceNumber = "";
string fireNumber = "";
string notes = "";
try
{
if (SettingKey != null && SettingKey == "EmergencyLocale")
{
if (SettingValue != null && SettingValue.Trim() != "")
{
GlobalData.GetEmergencyNumbersForCountry(SettingValue.Trim(), out policeNumber, out ambulanceNumber, out fireNumber, out notes);
}
PoliceNumber = policeNumber;
AmbulanceNumber = ambulanceNumber;
FireNumber = fireNumber;
Notes = notes;
}
}
catch (Exception e)
{
Log.Error(TAG, "LoadSettingValuesForCountry: Exception - " + e.Message);
throw;
}
}
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
SettingValue settingValue = value as SettingValue;
if (settingValue != null)
{
MembershipSetting settings = new MembershipSetting();
settings.SettingValueID = settingValue.Id;
settings.AllowOnlyAlphanumericUserNames = base.GetFieldValue <bool>(settingValue, "AllowOnlyAlphanumericUserNames");
settings.CookieValidationIntervalInMinutes = base.GetFieldValue <int>(settingValue, "CookieValidationIntervalInMinutes");
settings.LastActivityTimeUpdateIntervalInSeconds = base.GetFieldValue <int>(settingValue, "LastActivityTimeUpdateIntervalInSeconds");
settings.MinimumPasswordRequiredLength = base.GetFieldValue <int>(settingValue, "MinimumPasswordRequiredLength");
settings.PasswordResetTokenExpireTimeInHours = base.GetFieldValue <int>(settingValue, "PasswordResetTokenExpireTimeInHours");
settings.RequireDigitInPassword = base.GetFieldValue <bool>(settingValue, "RequireDigitInPassword");
settings.RequireLowercaseInPassword = base.GetFieldValue <bool>(settingValue, "RequireLowercaseInPassword");
settings.RequireNonLetterOrDigitInPassword = base.GetFieldValue <bool>(settingValue, "RequireNonLetterOrDigitInPassword");
settings.RequireUniqueEmailForUsers = base.GetFieldValue <bool>(settingValue, "RequireUniqueEmailForUsers");
settings.RequireUppercaseInPassword = base.GetFieldValue <bool>(settingValue, "RequireUppercaseInPassword");
settings.Comment = base.GetFieldValue <string>(settingValue, "Comment");
return(settings);
}
else
{
throw new InvalidCastException();
}
}
internal static void WriteSharedValuesToConfig(Type type, SettingValue settingValue)
{
var configuration = SystemConfigurationHelper.GetExeConfiguration();
var values = CreateSettingsValues(type, MigrationScope.Shared, settingValue);
SystemConfigurationHelper.PutSettingsValues(configuration, _settingsClass, values);
}
SettingValue IVimCustomSettingSource.GetSettingValue(string name)
{
switch (name)
{
case UseEditorIndentName:
return(SettingValue.NewToggle(_vimApplicationSettings.UseEditorIndent));
case UseEditorDefaultsName:
return(SettingValue.NewToggle(_vimApplicationSettings.UseEditorDefaults));
case UseEditorTabAndBackspaceName:
return(SettingValue.NewToggle(_vimApplicationSettings.UseEditorTabAndBackspace));
case UseEditorCommandMarginName:
return(SettingValue.NewToggle(_vimApplicationSettings.UseEditorCommandMargin));
case CleanMacrosName:
return(SettingValue.NewToggle(_vimApplicationSettings.CleanMacros));
case HideMarksName:
return(SettingValue.NewString(_vimApplicationSettings.HideMarks));
default:
Debug.Assert(false);
return(SettingValue.NewToggle(false));
}
}
public NLedgerConfiguration(IEnumerable <ISettingDefinition> externalDefinitions = null)
{
var isAttyDefinition = AddDefinition(new BoolSettingDefinition("IsAtty", IsAttyDescription, true));
var isTimeZoneIdDefinition = AddDefinition(new TimeZoneSettingDefinition("TimeZoneId", TimeZoneDescription, TimeZoneInfo.Local));
var outputEncodingDefinition = AddDefinition(new EncodingSettingDefinition("OutputEncoding", OutputEncodingDescription, Encoding.Default));
var ansiTerminalEmulationDefinition = AddDefinition(new BoolSettingDefinition("AnsiTerminalEmulation", AnsiTerminalEmulationDescription, true));
var defaultPagerDefinition = AddDefinition(new StringSettingDefinition("DefaultPager", DefaultPagerDescription));
var disableUserSettingsDefinition = AddDefinition(new BoolSettingDefinition("DisableUserSettings", DisableUserSettingsDescription, false, SettingScopeEnum.Application));
if (externalDefinitions != null && externalDefinitions.Any())
{
Definitions = Definitions.Concat(externalDefinitions).ToList();
}
SettingsContainer = new NLedgerSettingsContainer(Definitions);
IsAtty = new SettingValue <bool>(SettingsContainer, isAttyDefinition);
TimeZoneId = new SettingValue <TimeZoneInfo>(SettingsContainer, isTimeZoneIdDefinition);
OutputEncoding = new SettingValue <Encoding>(SettingsContainer, outputEncodingDefinition);
AnsiTerminalEmulation = new SettingValue <bool>(SettingsContainer, ansiTerminalEmulationDefinition);
DefaultPager = new SettingValue <string>(SettingsContainer, defaultPagerDefinition);
DisableUserSettings = new SettingValue <bool>(SettingsContainer, disableUserSettingsDefinition);
SettingsContainer.EffectiveScope = DisableUserSettings.Value ? SettingScopeEnum.Application : SettingScopeEnum.User;
}
public List <SettingValue> GetSettingsValues()
{
using (SqlConnection connection = new SqlConnection(Settings.Current.StorageSource))
{
connection.Open();
using (SqlCommand command = new SqlCommand("Zesty_ServerSetting_List", connection))
{
command.CommandType = System.Data.CommandType.StoredProcedure;
using (SqlDataReader reader = command.ExecuteReader())
{
List <SettingValue> values = new List <SettingValue>();
while (reader.Read())
{
SettingValue settingValue = new SettingValue();
settingValue.Key = reader.Get <string>("Key");
settingValue.Value = reader.Get <string>("Value");
settingValue.Order = reader.Get <int>("Order");
values.Add(settingValue);
}
return(values);
}
}
}
}
private void GetValueFromAddEditDialog(AddSettingValueViewModel vm, ref SettingValue settingValue)
{
switch (vm.ValueType)
{
case Infrastructure.Enumerations.ValueType.Boolean:
settingValue.BooleanValue = vm.BooleanValue;
settingValue.ValueType = textBoolean;
break;
case Infrastructure.Enumerations.ValueType.DataTime:
settingValue.DateTimeValue = vm.DateTimeValue;
settingValue.ValueType = textDateTime;
break;
case Infrastructure.Enumerations.ValueType.Decimal:
settingValue.DecimalValue = vm.DecimalValue;
settingValue.ValueType = textDecimal;
break;
case Infrastructure.Enumerations.ValueType.Integer:
settingValue.IntegerValue = vm.IntegerValue;
settingValue.ValueType = textInteger;
break;
case Infrastructure.Enumerations.ValueType.LongText:
settingValue.LongTextValue = vm.LongTextValue;
settingValue.ValueType = textLongText;
break;
case Infrastructure.Enumerations.ValueType.ShortText:
settingValue.ShortTextValue = vm.ShortTextValue;
settingValue.ValueType = textShortText;
break;
}
}
public void SetFakeActivePackageSource(PackageSource packageSource)
{
ActivePackageSourceSettings.Clear();
var setting = new SettingValue(packageSource.Name, packageSource.Source, false);
ActivePackageSourceSettings.Add(setting);
}
public static int DecodeQuerySetting(byte[] buffer, int offset, out SettingValue setting)
{
System.Diagnostics.Debug.Assert((CommandCodes)(buffer[offset] >> 4) == CommandCodes.QuerySetting);
setting = (SettingValue)(buffer[offset] & 0xF);
return(2);
}
public static int GetSettingResponseLength(SettingValue setting)
{
switch (setting)
{
case SettingValue.Brightness: return(2);
case SettingValue.HoldTimings: return(3);
case SettingValue.IdleTimeout: return(3);
case SettingValue.FadeValue: return(3);
case SettingValue.AnimBookmarkPos: return(3);
case SettingValue.AnimReadPos: return(3);
case SettingValue.AnimPlayState: return(2);
case SettingValue.ButtonState: return(2);
case SettingValue.BufferFullness: return(2);
case SettingValue.Caps: return(5);
}
//throw new NotImplementedException("Unimplemented SettingValue length! (" + setting + ")");
return(1);
}
/* ----------------------------------------------------------------- */
///
/// Set
///
/// <summary>
/// ViewModel に設定内容を反映させます。
/// </summary>
///
/// <remarks>
/// 一部の値は無効化されます。
/// </remarks>
///
/* ----------------------------------------------------------------- */
private void Set(SettingViewModel vm, SettingValue src)
{
vm.Language = src.Language;
vm.Format = src.Format;
vm.SaveOption = src.SaveOption;
vm.Resolution = src.Resolution;
vm.Grayscale = src.Grayscale;
vm.ImageFilter = src.ImageFilter;
vm.IsAutoOrientation = src.Orientation == Orientation.Auto;
vm.IsLandscape = src.Orientation == Orientation.Landscape;
vm.IsPortrait = src.Orientation == Orientation.Portrait;
vm.Linearization = src.Linearization;
vm.PostProcess = src.PostProcess;
vm.UserProgram = src.UserProgram;
vm.CheckUpdate = src.CheckUpdate;
// see remarks
// vm.Source = src.Source;
// vm.Destination = src.Destination;
vm.PostProcess = src.PostProcess != PostProcess.Open &&
src.PostProcess != PostProcess.OpenDirectory ?
src.PostProcess :
PostProcess.None;
}
public void EmptyConstantIsEqualToNullValuedObject()
{
var nullValue = new SettingValue(null);
Assert.AreEqual(SettingValue.Empty, nullValue);
Assert.AreNotSame(SettingValue.Empty, nullValue);
}
public override void OnSettingChanged(uint settingId, SettingValue value)
{
switch ((SettingId)settingId)
{
case SettingId.BeginColorValue:
_particleEmitters.ForEach(emitter =>
emitter.BeginColor = value);
break;
case SettingId.EmissionRateValue:
_particleEmitters.ForEach(emitter =>
emitter.EmissionRate = value);
break;
case SettingId.ParticleSpeedValue:
_particleEmitters.ForEach(emitter =>
emitter.Speed = value.ToSingle());
break;
case SettingId.ParticleLifeValue:
_particleEmitters.ForEach(emitter =>
emitter.Life = value.ToSingle());
break;
case SettingId.ParticleBeginSizeValue:
_particleEmitters.ForEach(emitter =>
emitter.BeginSize = value.ToSingle());
break;
case SettingId.ParticleEndSizeValue:
_particleEmitters.ForEach(emitter =>
emitter.EndSize = value.ToSingle());
break;
}
}
/// <summary>
/// Accepts a value that is either a comma-separated list of DUNS numbers or in the form @filename in which
/// filename is a file containing DUNS numbers
/// </summary>
/// <param name="Key"></param>
/// <param name="Value"></param>
/// <returns></returns>
public override bool Accept(string Key, string Value)
{
if (Key.ToLower() == SettingKey.ToLower())
{
if (Value != string.Empty && Value.Substring(0, 1) == "@")
{
using (StreamReader sr = new StreamReader(Value.Substring(1)))
{
while ((Value = sr.ReadLine()) != null)
{
SettingValue.AddRange(Value.Split(','));
SettingInitialized = true;
}
}
}
else
{
SettingValue.AddRange(Value.Split(','));
SettingInitialized = true;
}
SettingValue.RemoveAll(Str => string.IsNullOrEmpty(Str)); // ensure there are no empties
return(true);
}
return(false);
}
public void ActivePackageSourceReturnsNullIfNotPresentInNuGetConfig()
{
// Act
//Create nuget.config that has active package source defined
string nugetConfigFileFolder = NuGet.Configuration.Test.TestFilesystemUtility.CreateRandomTestFolder();
string nugetConfigFilePath = Path.Combine(nugetConfigFileFolder, "nuget.Config");
File.Create(nugetConfigFilePath).Close();
string enabledReplacement = @"<add key='" + NuGetConstants.V2FeedName + "' value='" + NuGetConstants.V2FeedUrl + "' />";
string fileContents = CreateNuGetConfigContent(enabledReplacement);
fileContents = fileContents.Replace("<activePackageSource>", string.Empty);
fileContents = fileContents.Replace("</activePackageSource>", string.Empty);
File.WriteAllText(nugetConfigFilePath, fileContents);
Settings settings = new Settings(nugetConfigFileFolder, "nuget.config");
PackageSourceProvider before = new PackageSourceProvider(settings);
Assert.Null(before.ActivePackageSourceName);
SettingValue newActiveValue = new SettingValue(NuGetConstants.V3FeedName, NuGetConstants.V3FeedUrl, false);
before.SaveActivePackageSource(new PackageSource(NuGetConstants.V3FeedUrl, NuGetConstants.V3FeedName));
Assert.Equal(NuGetConstants.V3FeedName, before.ActivePackageSourceName);
//Clean up
NuGet.Configuration.Test.TestFilesystemUtility.DeleteRandomTestFolders(nugetConfigFileFolder);
}
public void TrySetValue3()
{
foreach (var cur in _settings.Settings)
{
SettingValue value = null;
if (cur.Kind.IsToggle)
{
value = SettingValue.NewToggle(true);
}
else if (cur.Kind.IsString)
{
value = SettingValue.NewString("foo");
}
else if (cur.Kind.IsNumber)
{
value = SettingValue.NewNumber(42);
}
else
{
throw new Exception("failed");
}
Assert.True(_settings.TrySetValue(cur.Abbreviation, value));
}
}
public static int GetFullCommandLength(CommandCodes command, byte[] buffer, int offset)
{
switch (command)
{
case CommandCodes.UpdateSetting:
{
SettingValue setting = (SettingValue)(buffer[offset] & 0xF);
return(GetSettingUpdateLength(setting));
}
case CommandCodes.WriteRect:
{
Target targetBuffer;
PixelFormat format;
byte x, y;
byte width, height;
byte bufferLength;
int headerLen = BadgeCommands.DecodeWriteRect(buffer, offset, out targetBuffer, out format, out x, out y, out width, out height, out bufferLength);
return(headerLen + bufferLength);
}
case CommandCodes.WriteMemory:
{
byte numDWords;
short address;
byte bufferLength;
int headerLen = BadgeCommands.DecodeWriteMemory(buffer, offset, out address, out numDWords, out bufferLength);
return(headerLen + bufferLength);
}
default: return(GetMinCommandLength(command));
}
}
public static int GetFullResponseLength(ResponseCodes response, byte[] buffer, int offset)
{
switch (response)
{
case ResponseCodes.Setting:
{
SettingValue setting = (SettingValue)(buffer[offset] & 0xF);
return(GetSettingResponseLength(setting));
}
case ResponseCodes.Pixels:
{
PixelFormat format;
byte width;
byte height;
byte bufferLength;
int headerLen = BadgeResponses.DecodePixels(buffer, offset, out format, out width, out height, out bufferLength);
return(headerLen + bufferLength);
}
case ResponseCodes.Memory:
{
byte numDWords;
short address;
byte bufferLength;
int headerLen = BadgeResponses.DecodeMemory(buffer, offset, out numDWords, out address, out bufferLength);
return(headerLen + bufferLength);
}
default: return(GetMinResponseLength(response));
}
}
public void TrySetValue3()
{
var settings = Create();
foreach (var cur in settings.AllSettings)
{
SettingValue value = null;
if (cur.Kind.IsToggleKind)
{
value = SettingValue.NewToggleValue(true);
}
else if (cur.Kind.IsStringKind)
{
value = SettingValue.NewStringValue("foo");
}
else if (cur.Kind.IsNumberKind)
{
value = SettingValue.NewNumberValue(42);
}
else
{
Assert.Fail();
}
Assert.IsTrue(settings.TrySetValue(cur.Abbreviation, value));
}
}
private SettingValue DeserializeVariableRef(JsonReader reader)
{
var result = new SettingValue {
FromVariable = new VariableRef()
};
var varRef = result.FromVariable;
while (reader.Read())
{
if (reader.TokenType == JsonToken.EndObject)
{
break;
}
var propertyName = (string)reader.Value;
reader.Read();
switch (propertyName)
{
case Constants.PackageId:
varRef.PackageId = (string)reader.Value;
break;
case Constants.VariableName:
varRef.VariableName = (string)reader.Value;
break;
case Constants.Default:
varRef.DefaultValue = (string)reader.Value; // default to string for now
break;
}
}
return(varRef.IsEmpty ? null : result);
}
static PackageSource CreatePackageSourceFromSetting(SettingValue savedPackageSource)
{
string source = savedPackageSource.Value;
string name = savedPackageSource.Key;
return(new PackageSource(source, name));
}
public override void OnSettingChanged(uint settingId, SettingValue value)
{
switch ((SettingId)settingId)
{
case SettingId.ColorValue:
_color = value;
break;
case SettingId.XPositionValue:
_x0Pos = value;
break;
case SettingId.YPositionValue:
_y0Pos = value;
break;
case SettingId.XSizeValue:
_xSize = value;
break;
case SettingId.YSizeValue:
_ySize = value;
break;
}
}
public override void OnSettingChanged(uint settingId, SettingValue value)
{
switch ((SettingId)settingId)
{
case SettingId.RedColorValue:
_cr = value;
break;
case SettingId.GreenColorValue:
_cg = value;
break;
case SettingId.BlueColorValue:
_cb = value;
break;
case SettingId.XScaleValue:
_xScale = value;
break;
case SettingId.YScaleValue:
_yScale = value;
break;
}
}
IList <SettingValue> ISettings.GetSettingValues(string section, bool isPath)
{
List <SettingValue> result = new List <SettingValue>();
if (section == "packageSources")
{
foreach (PackageSourceItem item in this.packageSources)
{
SettingValue value = new SettingValue(item.Name, item.Path, this, false);
value.AdditionalData.Add("protocolVersion", item.ProtocolVersion);
result.Add(value);
}
}
else if (section == "disabledPackageSources")
{
}
else
{
Console.WriteLine("Unresolved GetSettingValues({0}, {1})", section, isPath);
IList <SettingValue> baseValue = new Settings(this.projectRootPath).GetSettingValues(section, isPath);
foreach (SettingValue item in baseValue)
{
Console.WriteLine(" {0}: {1}, + {2} additional", item.Key, item.Value, item.AdditionalData.Count);
}
}
return(result);
}
private void ValidateValuesInConfig(MigrationScope migrationScope, SettingValue settingValue)
{
var configuration = GetExeConfiguration();
var values = SystemConfigurationHelper.GetSettingsValues(configuration, _settingsClass);
ValidateValues(values, migrationScope, settingValue);
}
public override void OnSettingChanged(uint settingId, SettingValue value)
{
switch ((SettingId)settingId)
{
case SettingId.Color:
_color = value;
break;
case SettingId.NumBars:
lock (_barsLock)
{
_numBars = value;
_barSize = (int)(Width / _numBars);
_lastBar = -1;
InitBars();
}
break;
case SettingId.MaxBarLife:
lock (_barsLock)
{
_maxBarLife = value;
}
break;
}
}
public void DiscriminatedUnions()
{
Run(BlockCaretLocation.BottomLeft, BlockCaretLocation.BottomRight);
Run(CaretColumn.NewInLastLine(0), CaretColumn.NewInLastLine(1));
Run(CaretColumn.NewInLastLine(0), CaretColumn.NewInLastLine(2));
Run(CaseSpecifier.IgnoreCase, CaseSpecifier.None);
Run(ChangeCharacterKind.Rot13, ChangeCharacterKind.ToggleCase);
Run(CharSearchKind.TillChar, CharSearchKind.ToChar);
Run(KeyRemapMode.Language, KeyRemapMode.Normal);
Run(DirectiveKind.If, DirectiveKind.Else);
Run(MagicKind.NoMagic, MagicKind.Magic);
Run(MatchingTokenKind.Braces, MatchingTokenKind.Brackets);
Run(MotionContext.AfterOperator, MotionContext.Movement);
Run(MotionKind.LineWise, MotionKind.CharacterWiseExclusive);
Run(NumberFormat.Alpha, NumberFormat.Decimal);
Run(NumberValue.NewAlpha('c'), NumberValue.NewDecimal(1));
Run(OperationKind.CharacterWise, OperationKind.LineWise);
Run(QuickFix.Next, QuickFix.Previous);
Run(RegisterOperation.Delete, RegisterOperation.Yank);
Run(SectionKind.Default, SectionKind.OnCloseBrace);
Run(SentenceKind.Default, SentenceKind.NoTrailingCharacters);
Run(SettingKind.Number, SettingKind.String);
Run(SelectionKind.Exclusive, SelectionKind.Inclusive);
Run(SettingValue.NewNumber(1), SettingValue.NewNumber(2));
Run(TextObjectKind.AlwaysCharacter, TextObjectKind.AlwaysLine);
Run(UnmatchedTokenKind.CurlyBracket, UnmatchedTokenKind.Paren);
Run(WordKind.BigWord, WordKind.NormalWord);
}
void IVimCustomSettingSource.SetSettingValue(string name, SettingValue settingValue)
{
Assert.Equal(name, Name);
if (settingValue.IsString)
{
Value = ((SettingValue.String)settingValue).Item;
}
}
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);
}
// Use this for initialization
void Awake () {
if (setting == null)
{
DontDestroyOnLoad(gameObject);
setting = this;
}
else if(setting != this)
{
Destroy(gameObject);
}
}
public void Change_setting_to_db_check_string_null()
{
var command = RepositoryFactory.Command<IAppSettingCommands>();
const string newValueString = "newValue";
var stringSetting = new SettingValue<string>("changeStringVal", "defaultValue", new DatabaseSettingProvider());
// create
stringSetting.SaveValue(newValueString);
Assert.AreEqual(newValueString, stringSetting.Value);
// check if db is really empty
Assert.AreEqual(newValueString, command.Get(stringSetting.Name).Value);
// change
stringSetting.SaveValue(null);
Assert.AreEqual(null, stringSetting.Value);
// check if db is really empty
Assert.AreEqual(null, command.Get(stringSetting.Name).Value);
}
private void ValidateValues(Dictionary<string, string> values, MigrationScope migrationScope, SettingValue settingValue)
{
if (settingValue == SettingValue.Default)
{
Assert.AreEqual(0, values.Count);
return;
}
var expected = CreateSettingsValues(_settingsClass, migrationScope, settingValue);
ValidateValues(values, expected);
}
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);
}
}
}
public static SettingsPropertyValue CreateSettingsPropertyValue(SettingsProperty property, MigrationScope migrationScope, SettingValue settingValue)
{
var value = CreateSettingValue(property, migrationScope, settingValue);
if (value == null)
return null;
return new SettingsPropertyValue(property) { SerializedValue = value };
}
public static Dictionary<string, string> CreateSettingsValues(Type type, MigrationScope migrationScope, SettingValue settingValue)
{
var values = new Dictionary<string, string>();
SettingsGroupDescriptor group = new SettingsGroupDescriptor(type);
foreach (var property in SettingsPropertyDescriptor.ListSettingsProperties(group))
{
var value = CreateSettingValue(property, migrationScope, settingValue);
if (value != null)
values[property.Name] = value;
}
return values;
}
public void Save_setting_to_config___not_implemented()
{
var intSetting = new SettingValue<int>("newIntVal", 245, new ConfigSettingProvider());
intSetting.SaveValue(1);
}
public static string CreateSettingValue(SettingsPropertyDescriptor property, MigrationScope migrationScope, SettingValue settingValue)
{
if (settingValue == SettingValue.Default)
return property.DefaultValue;
if (migrationScope == MigrationScope.User && property.Scope == SettingScope.Application)
return null;
if (property.Scope == SettingScope.User && migrationScope == MigrationScope.Shared)
return CreateUserDefaultSettingValue(property.Name, settingValue);
return CreateSettingValue(property.Name, settingValue);
}
public static string CreateSettingValue(string propertyName, SettingValue settingValue)
{
return String.Format("{0}{1}", settingValue, propertyName);
}
public static string CreateUserDefaultSettingValue(string propertyName, SettingValue settingValue)
{
return String.Format("{0}{1}{2}", settingValue, "Default", propertyName);
}
public void LoadPackageSources_ReadsSourcesWithProtocolVersionFromPackageSourceSections()
{
// Arrange
var settings = new Mock<ISettings>();
var settingWithV3Protocol1 = new SettingValue("Source2", "https://source-with-newer-protocol", false);
settingWithV3Protocol1.AdditionalData["protocolVersion"] = "3";
var settingWithV3Protocol2 = new SettingValue("Source3", "Source3", false);
settingWithV3Protocol2.AdditionalData["protocolVersion"] = "3";
var sourcesSettings = new[]
{
new SettingValue("Source1", "https://some-source.org", false),
settingWithV3Protocol1,
settingWithV3Protocol2,
new SettingValue("Source3", "Source3", false),
new SettingValue("Source4", "//Source4", false)
};
settings.Setup(s => s.GetSettingValues("packageSources", true))
.Returns(sourcesSettings);
settings.Setup(s => s.GetNestedValues("packageSourceCredentials", "Source3"))
.Returns(new[]
{
new KeyValuePair<string, string>("Username", "source3-user"),
new KeyValuePair<string, string>("ClearTextPassword", "source3-password"),
});
settings.Setup(s => s.GetSettingValues("disabledPackageSources", false))
.Returns(new[]
{
new SettingValue("Source4", "true", isMachineWide: false)
});
var provider = CreatePackageSourceProvider(settings.Object,
providerDefaultPrimarySources: null,
providerDefaultSecondarySources: null,
migratePackageSources: null);
// Act
var values = provider.LoadPackageSources().ToList();
// Assert
Assert.Collection(values,
source =>
{
Assert.Equal("Source1", source.Name);
Assert.Equal("https://some-source.org", source.Source);
Assert.Null(source.UserName);
Assert.Null(source.Password);
Assert.Equal(2, source.ProtocolVersion);
Assert.True(source.IsEnabled);
},
source =>
{
Assert.Equal("Source2", source.Name);
Assert.Equal("https://source-with-newer-protocol", source.Source);
Assert.Null(source.UserName);
Assert.Null(source.Password);
Assert.Equal(3, source.ProtocolVersion);
Assert.True(source.IsEnabled);
},
source =>
{
Assert.Equal("Source3", source.Name);
Assert.Equal("Source3", source.Source);
Assert.Equal("source3-user", source.UserName);
Assert.Equal("source3-password", source.Password);
Assert.Equal(3, source.ProtocolVersion);
Assert.True(source.IsEnabled);
},
source =>
{
Assert.Equal("Source4", source.Name);
Assert.Equal("//Source4", source.Source);
Assert.Null(source.UserName);
Assert.Null(source.Password);
Assert.Equal(2, source.ProtocolVersion);
Assert.False(source.IsEnabled);
});
}
public void ActivePackageSourceReturnsNullIfNotPresentInNuGetConfig()
{
// Act
//Create nuget.config that has active package source defined
string nugetConfigFileFolder = TestFilesystemUtility.CreateRandomTestFolder();
var nugetConfigFilePath = Path.Combine(nugetConfigFileFolder, "nuget.Config");
File.Create(nugetConfigFilePath).Close();
var enabledReplacement = @"<add key='" + NuGetConstants.V2FeedName + "' value='" + NuGetConstants.V2FeedUrl + "' />";
var fileContents = CreateNuGetConfigContent(enabledReplacement);
fileContents = fileContents.Replace("<activePackageSource>", string.Empty);
fileContents = fileContents.Replace("</activePackageSource>", string.Empty);
File.WriteAllText(nugetConfigFilePath, fileContents);
Settings settings = new Settings(nugetConfigFileFolder, "nuget.config");
PackageSourceProvider before = new PackageSourceProvider(settings);
Assert.Null(before.ActivePackageSourceName);
SettingValue newActiveValue = new SettingValue(NuGetConstants.V3FeedName, NuGetConstants.V3FeedUrl, false);
before.SaveActivePackageSource(new PackageSource(NuGetConstants.V3FeedUrl, NuGetConstants.V3FeedName));
Assert.Equal(NuGetConstants.V3FeedName, before.ActivePackageSourceName);
//Clean up
TestFilesystemUtility.DeleteRandomTestFolders(nugetConfigFileFolder);
}
public void Get_setting_from_config_fallback_to_default()
{
const int defaultInt = 245;
const string defaultString = "defaultValue";
var intSetting = new SettingValue<int>("intVal", defaultInt, new ConfigSettingProvider());
var stringSetting = new SettingValue<string>("stringVal", defaultString, new ConfigSettingProvider());
Assert.AreEqual(defaultInt, intSetting.Value);
Assert.AreEqual(defaultString, stringSetting.Value);
}
void IVimCustomSettingSource.SetSettingValue(string name, SettingValue settingValue)
{
if (!settingValue.IsToggle)
{
return;
}
bool value = ((SettingValue.Toggle)settingValue).Item;
switch (name)
{
case UseEditorIndentName:
_vimApplicationSettings.UseEditorIndent = value;
break;
case UseEditorDefaultsName:
_vimApplicationSettings.UseEditorDefaults = value;
break;
case UseEditorTabAndBackspaceName:
_vimApplicationSettings.UseEditorTabAndBackspace = value;
break;
default:
value = false;
break;
}
}
public bool TrySetValue(string settingName, SettingValue value)
{
throw new NotImplementedException();
}
public static string CreateSettingValue(SettingsProperty property, MigrationScope migrationScope, SettingValue settingValue)
{
return CreateSettingValue(SettingsPropertyHelper.GetDescriptor(property), migrationScope, settingValue);
}
private void ValidateValuesInConfig(Type settingsClass, MigrationScope migrationScope, SettingValue settingValue)
{
var configuration = GetExeConfiguration();
var values = configuration.GetSettingsValues(settingsClass);
ValidateValues(settingsClass, values, migrationScope, settingValue);
}
public static string CreateSettingValue(PropertyInfo property, MigrationScope migrationScope, SettingValue settingValue)
{
return CreateSettingValue(new SettingsPropertyDescriptor(property), migrationScope, settingValue);
}
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);
}
private void ValidateValues(Dictionary<string, string> values, MigrationScope migrationScope, SettingValue settingValue)
{
var expected = CreateSettingsValues(_settingsClass, migrationScope, settingValue);
ValidateValues(values, expected);
}
internal static void WriteSharedValuesToConfig(Type type, SettingValue settingValue)
{
var configuration = SystemConfigurationHelper.GetExeConfiguration();
var values = CreateSettingsValues(type, MigrationScope.Shared, settingValue);
SystemConfigurationHelper.PutSettingsValues(configuration, _settingsClass, values);
}
private void ValidateValuesInConfig(MigrationScope migrationScope, SettingValue settingValue)
{
var configuration = GetExeConfiguration();
var values = SystemConfigurationHelper.GetSettingsValues(configuration, _settingsClass);
ValidateValues(values, migrationScope, settingValue);
}
public bool RemoveSettingValue(SettingValue instance)
{
if (instance != null)
{
Db.SettingValue.DeleteOnSubmit(instance);
Db.SettingValue.Context.SubmitChanges();
return true;
}
return false;
}
public void Get_setting_from_db_fallback_to_default()
{
var command = RepositoryFactory.Command<IAppSettingCommands>();
const int defaultInt = 245;
const string defaultString = "defaultValue";
var intSetting = new SettingValue<int>("intVal", defaultInt, new DatabaseSettingProvider());
var stringSetting = new SettingValue<string>("stringVal", defaultString, new DatabaseSettingProvider());
Assert.AreEqual(defaultInt, intSetting.Value);
Assert.AreEqual(defaultString, stringSetting.Value);
// check if db is really empty
Assert.IsNull(command.Get(intSetting.Name));
Assert.IsNull(command.Get(stringSetting.Name));
}
