[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;
}
}
}
}
}
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));
}
return new SqlParameter(ParamName,Value);
