[PreventExecutionContextLeaks] // Workaround for https://github.com/nunit/nunit/issues/3283 public static void Passed_synchronization_context_may_not_be_null([Values] PostOverload overload) { switch (overload) { case PostOverload.Action: Should.Throw <ArgumentNullException>( () => AmbientTasks.Post(synchronizationContext: null !, (Action?)null)) .ParamName.ShouldBe("synchronizationContext"); break; case PostOverload.SendOrPostCallback: Should.Throw <ArgumentNullException>( () => AmbientTasks.Post(synchronizationContext: null !, null, state: null)) .ParamName.ShouldBe("synchronizationContext"); break; case PostOverload.AsyncAction: Should.Throw <ArgumentNullException>( () => AmbientTasks.Post(synchronizationContext: null !, (Func <Task>?)null)) .ParamName.ShouldBe("synchronizationContext"); break; default: throw new NotImplementedException(); } }
public void Test200() { Should.Throw <ArgumentNullException>(() => JsRuntimeAssertExtensions.ShouldBeElementReferenceTo(null !, null !)) .ParamName.ShouldBe("actualArgument"); Should.Throw <ArgumentNullException>(() => JsRuntimeAssertExtensions.ShouldBeElementReferenceTo(string.Empty, null !)) .ParamName.ShouldBe("expectedTargetElement"); }
public void Test003() { using var sut = CreateSut(); Should.Throw <ArgumentNullException>(() => sut.Find(null !).ToList()) .ParamName.ShouldNotBeEmpty(); }
public static void SetParam(ParamName paramName, string ParamVal) { QueryExecPDA q = new QueryExecPDA(); string sql = "update MainParams set {0}='{1}'"; string name = "*"; switch (paramName) { case ParamName.idGu: name = "idGU"; break; case ParamName.expDate: name = "expDate"; break; case ParamName.impDate: name = "impDate"; break; case ParamName.impState: name = "impState"; break; case ParamName.expState: name = "expState"; break; case ParamName.isLight: name = "isLight"; break; } q.Execute(string.Format(sql, name, ParamVal)); }
public void RemoveParam(ParamName name) { if (parameters != null) { parameters.Remove(name); } }
public static string GetParam(ParamName paramName) { QuerySelectPDA q=new QuerySelectPDA(); string sql = "select {0} from MainParams"; string name="*"; switch(paramName) { case ParamName.idGu: name="idGU"; break; case ParamName.expDate:name="expDate"; break; case ParamName.impDate: name="impDate"; break; case ParamName.impState: name="impState"; break; case ParamName.expState: name="expState"; break; case ParamName.isLight: name="isLight"; break; } q.Select(string.Format(sql, name)); List<DataRows> rows = q.GetRows(); if (rows.Count > 0) return rows[0].FieldByNameDef(name, ""); else return ""; }
public int Execute(string SQL, Hashtable ParametersList) { int _rows_affected = 0; if (String.IsNullOrEmpty(SQL)) { throw new ArgumentException("Parameter 'SQL' may not be null or empty.", "SQL"); } if (ParametersList.Count <= 0) { throw new ArgumentException("Parameter 'ParametersList' may not be null or empty.", "ParametersList"); } SqlCommand _SqlCommand = new SqlCommand(SQL, this._SqlConnection); foreach (string ParamName in ParametersList.Keys) { if (!String.IsNullOrEmpty(ParamName) && !String.IsNullOrEmpty(ParamName.Trim())) { _SqlCommand.Parameters.AddWithValue( (this._parameter_prefix + ParamName + this._parameter_suffix) , ParametersList[ParamName] ); } } _rows_affected = _SqlCommand.ExecuteNonQuery(); return(_rows_affected); }
public void SetParamValue(ParamName name, Object value) { if (parameters == null) { parameters = new Dictionary <ParamName, Object>(); } parameters[name] = value; }
public Object GetParamValue(ParamName name) { if (parameters != null) { return(parameters[name]); } return(null); }
public void Constructor_NullOrWhitespace(string name) { // act ArgumentException exception = Assert.Throws <ArgumentException>(() => _ = AssetName.Parse(name, null)); // assert exception !.ParamName.Should().Be("rawName"); exception.Message.Should().Be("The asset name can't be null or empty. (Parameter 'rawName')"); }
public static void GetInteger(ParamName param, out int val) { unsafe { fixed(int *ptr = &val) { Delegates.GetIntegerv(param, ptr); } } }
public override bool Equals(object obj) { if (obj as GroupParam == null) { return(false); } GroupParam otherGroupParam = obj as GroupParam; return(ParamName.Equals(otherGroupParam.ParamName) && ParamValue == otherGroupParam.ParamValue); }
public bool TryGetOptionalEnumValue <T>(ParamName paramName, out T value) where T : struct { if (ValueSet.TryGetValue(paramName.ToString(), out object rawValue)) { return(TryConvertEnumValue(paramName, rawValue, out value)); } value = default(T); return(false); }
public T GetEnumValue <T>(ParamName paramName) where T : struct { if (!GetRequiredValue(paramName, out object rawValue)) { return(default(T)); } TryConvertEnumValue(paramName, rawValue, out T value); return(value); }
public static void GetFloat(ParamName param, out float val) { unsafe { fixed(float *ptr = &val) { Delegates.GetFloatv(param, ptr); } } }
internal static ServiceErrorInfo WrongMessageValueType(ParamName paramName, Type actualType, Type expectedType) { string message = string.Format( CultureInfo.CurrentCulture, Strings.WrongMessageValueType, paramName, actualType, expectedType); return(new ServiceErrorInfo(ServiceCommandErrorCode.WrongMessageValueType, message)); }
/// <summary> /// This is for listing Promoted Graph Parameters /// And is used in GraphParameterEditor /// </summary> /// <param name="title"></param> /// <param name="id"></param> /// <param name="v"></param> /// <param name="ignore"></param> public ParameterView(string title, string id, GraphParameterValue v, params string[] ignore) { InitializeComponent(); Param = v; IsReadOnly = true; Params.Set(v, ignore, false, true); Id = id; ParamName.Placeholder = Properties.Resources.TITLE_PARAMETER_NAME; ParamName.Set(title); DisplayDefaultParam(); Collapse(); }
private bool GetRequiredValue(ParamName paramName, out object value) { if (ValueSet.TryGetValue(paramName.ToString(), out value)) { return(true); } LastError = ServiceCommandResponse.CreateError( CommandName, ServiceErrorInfo.MissingRequiredMessageValue(paramName)); return(false); }
/// <summary> /// This is for listing Promoted Graph Parameters /// And is used in GraphParameterEditor /// </summary> /// <param name="title"></param> /// <param name="id"></param> /// <param name="v"></param> /// <param name="ignore"></param> public ParameterView(string title, string id, GraphParameterValue v, params string[] ignore) { InitializeComponent(); Param = v; IsReadOnly = true; Params.Set(v, ignore, false, true); Id = id; ParamName.Placeholder = "Parameter Name"; ParamName.Set(title); DisplayDefaultParam(); Collapse(); }
public bool Matches(string resource, string field) { if (resource != null && field != null) { return((Resource.ToLower() == resource.ToLower()) && (ParamName.ToLower() == field.ToLower())); } else { return(false); } }
public bool GetComParameterValue(ParamName name, out int result) { ComParameter param = GetComParameterByName(name.ToString()); if (param is null) { result = 0; return(false); } else { result = param.ComParamValue; return(true); } }
private bool TryConvertEnumValue <T>(ParamName paramName, object rawValue, out T value) where T : struct { try { value = (T)Enum.Parse(typeof(T), rawValue.ToString()); return(true); } catch (Exception e) when(e is ArgumentException || e is OverflowException) { LastError = ServiceCommandResponse.CreateError( CommandName, ServiceErrorInfo.WrongMessageValueType(paramName, rawValue.GetType(), typeof(T))); value = default(T); return(false); } }
private MethodInfo GetOriginalMethod(Type T, string MethodName, bool SearchOnlyInGeneric, bool Strict, bool UsePotential, out Dictionary <string, string> GenericMap, params string[] TypeName) { Func <string, string, bool> CheckCaseSensitive; Func <string, string, bool> Check; Func <MethodInfo, bool> CheckParams; string[] typeName; string methodName; MethodInfo[] methods; MethodInfo Result; if (SearchOnlyInGeneric) { methods = T.GetMethods().Where(S => S.ContainsGenericParameters).ToArray(); } else { methods = T.GetMethods(); } if (Strict) { methodName = MethodName; typeName = TypeName; CheckCaseSensitive = (ParamName, CheckName) => ParamName == CheckName; Check = (ParamName, CheckName) => ParamName != CheckName; } else { methodName = MethodName.ToUpper(); typeName = TypeName.Select(x => x.ToUpper()).ToArray(); CheckCaseSensitive = (ParamName, CheckName) => ParamName.ToUpper() == CheckName; Check = (ParamName, CheckName) => !ParamName.ToUpper().Contains(CheckName); } Dictionary <string, string> GM = null; if (UsePotential) { CheckParams = M => Similar(M, Strict, ref GM, typeName); } else { CheckParams = M => M.GetParameters().Where((P, i) => Check(P.ParameterType.FullName, typeName[i])).FirstOrDefault() == null; } Result = methods.Select(M => new { Method = M, Prs = M.GetParameters() }).Where(M => ( (CheckCaseSensitive(M.Method.Name, methodName)) && (M.Prs.Length == typeName.Length) && CheckParams(M.Method) )).Select(M => M.Method).FirstOrDefault(); GenericMap = GM; return(Result); }
private void InitNameField() { if (Param == null) { return; } var prop = Param.GetType().GetProperty("Name"); if (prop == null) { return; } ParamName.Placeholder = "Parameter Name"; ParamName.Set(prop, Param, IsReadOnly); }
private void InitNameField() { if (Param == null) { return; } var prop = Param.GetType().GetProperty("Name"); if (prop == null) { return; } ParamName.Placeholder = Properties.Resources.TITLE_PARAMETER_NAME; ParamName.Set(prop, Param, IsReadOnly); }
public int GetIntValue(ParamName paramName) { if (!GetRequiredValue(paramName, out object rawValue)) { return(0); } if (rawValue is int value) { return(value); } LastError = ServiceCommandResponse.CreateError( CommandName, ServiceErrorInfo.WrongMessageValueType(paramName, rawValue.GetType(), typeof(int))); return(0); }
public string GetStringValue(ParamName paramName) { if (!GetRequiredValue(paramName, out object rawValue)) { return(null); } if (rawValue is string value) { return(value); } LastError = ServiceCommandResponse.CreateError( CommandName, ServiceErrorInfo.WrongMessageValueType(paramName, rawValue.GetType(), typeof(string))); return(null); }
/// <summary> /// Элемент с двумя заданными параметрами и категориями, к которым он относится /// </summary> /// <param name="param1">Параметр 1</param> /// <param name="valueparam1">Значения параметра 1</param> /// <param name="param2">Параметр 2</param> /// <param name="valueparam2">Значение параметра 2</param> /// <param name="Title">Название</param> /// <param name="cats">Категории</param> public Element(ParamName param1, double valueparam1, ParamName param2, double valueparam2, string Title = null, List <WorkTypeClass.Category> cats = null) { Categories = new List <WorkTypeClass.Category>(); Params[param1] = valueparam1; Params[param2] = valueparam2; if (Title != null) { this.Title = Title; } if (cats != null) { foreach (WorkTypeClass.Category cat in cats) { Categories.Add(cat); } } }
public override int GetHashCode() { int hash = 1; if (ParamName.Length != 0) { hash ^= ParamName.GetHashCode(); } if (ParamValue != 0F) { hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(ParamValue); } if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } return(hash); }
public static void ParametersAreCheckedForNull() { // Arrange IServiceCollection?services = new ServiceCollection(); Func <IServiceProvider, StatsDConfiguration>?configurationFactory = null; string?host = null; // Act and Assert Should.Throw <ArgumentNullException>(() => services.AddStatsD(configurationFactory !)).ParamName.ShouldBe("configurationFactory"); Should.Throw <ArgumentNullException>(() => services.AddStatsD(host !)).ParamName.ShouldBe("host"); // Arrange services = null; // Act and Assert Should.Throw <ArgumentNullException>(() => services !.AddStatsD(configurationFactory !)).ParamName.ShouldBe("services"); Should.Throw <ArgumentNullException>(() => services !.AddStatsD(host !)).ParamName.ShouldBe("services"); }
void ParseAfter_ParamNames() { if (this.Params == null) { int Counter = 0; string Line; int Index2, Index; for (int i = this.DocLet.LastLineIndex + 1; Counter < 3 && i < this.DocLet.Lines.Length; i++) { Counter++; Line = this.DocLet.Lines[i].Trim(); if (!string.IsNullOrWhiteSpace(Line)) { Index = Line.IndexOf('('); if (Index != -1) { Index2 = Line.IndexOf(')', Index + 1); if (Index2 != -1) { string S = Line.Substring(Index + 1, Index2 - (Index + 1)); if (!string.IsNullOrWhiteSpace(S)) { string[] Parts = S.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries); if (Parts.Length > 0) { FuncParam Param; this.Params = new List <FuncParam>(); foreach (var ParamName in Parts) { S = ParamName.Trim(); Param = FuncParam.CreateParam(this, S); this.Params.Add(Param); } } } } return; } } } } }
return new SqlParameter(ParamName,Value);