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); }
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)); }