protected virtual void SetPropertyValue([NotNull] ITest test,
[NotNull] TestParameter testParameter,
[CanBeNull] object value)
{
Assert.ArgumentNotNull(test, nameof(test));
Assert.ArgumentNotNull(testParameter, nameof(testParameter));
Type testType = test.GetType();
string propertyName = testParameter.Name;
PropertyInfo propertyInfo = testType.GetProperty(propertyName);
Assert.NotNull(propertyInfo,
"Property not found for test type {0}: {1}",
testType.Name, propertyName);
MethodInfo setMethod = propertyInfo.GetSetMethod();
Assert.NotNull(setMethod,
"Set method not found for property {0} on test type {1}",
propertyName, testType.Name);
setMethod.Invoke(test, new[] { value });
}
protected void gridParamMaster_RowCommand(object sender, GridViewCommandEventArgs e)
{
int index;
if (e.CommandName == "DeleteParam")
{
int paramId = Int32.Parse(e.CommandArgument.ToString());
//gridParamMaster.SelectedIndex = index;
// int paramId = int.Parse(gridParamMaster.SelectedDataKey.Values["Id"].ToString());
mGr.DeleteTestParameter(paramId, this.LabTestId, this.UserId);
IQCareMsgBox.NotifyAction("Test Parameter has been deleted", "Success Deletion", false, this, "");
this.PopulateParameters();
return;
}
else if (e.CommandName == "Modify")
{
index = Int32.Parse(e.CommandArgument.ToString());
gridParamMaster.SelectedIndex = index;
int paramId = int.Parse(gridParamMaster.SelectedDataKey.Values["Id"].ToString());
GridViewRow row = (gridParamMaster.Rows[index]);
string paramName = row.Cells[0].Text.Trim();
string refernece = row.Cells[1].Text.Trim();
TestParameter param = new TestParameter()
{
Id = paramId, LabTestId = this.LabTestId, ReferenceId = refernece, Name = paramName, DeleteFlag = false
};
Session[SessionKey.TestParameters] = param;
Guid g = Guid.NewGuid();
string theUrl = "./ManageTestParameter.aspx?key=" + g.ToString();
Response.Redirect(theUrl, true);
return;
}
}
public TestParameter Get(long ID)
{
TestParameter obj = new TestParameter();
try
{
SqlParameter[] paramList = new SqlParameter[] {
new SqlParameter("@ParameterID", ID)
};
DataTable dt = Execute.RunSP_DataTable(Connection, "SPGET_TestParameters_ID", paramList);
obj.Description = Convert.ToString(dt.Rows[0]["Description"]);
obj.Parameter = Convert.ToString(dt.Rows[0]["Parameter"]);
obj.ParameterID = Convert.ToInt64(dt.Rows[0]["ParameterID"]);
obj.Type = Convert.ToString(dt.Rows[0]["Type"]);
return(obj);
}
catch (Exception ex)
{
throw new Exception(ex.Message, ex);
}
}
public void IsIgnoreWithTest()
{
object value = null;
var ableFalse = new IgnoreWhenNullable(false);
Assert.False(ableFalse.IsIgnoreWith(value));
value = 1;
Assert.False(ableFalse.IsIgnoreWith(value));
var parameter = TestParameter.Create(null);
Assert.False(ableFalse.IsIgnoreWith(parameter));
parameter = TestParameter.Create("laojiu");
Assert.False(ableFalse.IsIgnoreWith(parameter));
value = null;
var ableTrue = new IgnoreWhenNullable(true);
Assert.True(ableTrue.IsIgnoreWith(value));
value = 1;
Assert.False(ableTrue.IsIgnoreWith(value));
parameter = TestParameter.Create(null);
Assert.True(ableTrue.IsIgnoreWith(parameter));
parameter = TestParameter.Create("laojiu");
Assert.False(ableTrue.IsIgnoreWith(parameter));
}
protected static void AddConstructorParameters(
[NotNull] List <TestParameter> parameters,
[NotNull] Type qaTestType,
int constructorIndex,
[NotNull] IList <int> ignoreParameters)
{
ConstructorInfo constr = qaTestType.GetConstructors()[constructorIndex];
IList <ParameterInfo> constrParams = constr.GetParameters();
for (var iParam = 0; iParam < constrParams.Count; iParam++)
{
if (ignoreParameters.Contains(iParam))
{
continue;
}
ParameterInfo constrParam = constrParams[iParam];
var testParameter = new TestParameter(
constrParam.Name, constrParam.ParameterType,
TestImplementationUtils.GetDescription(constrParam),
isConstructorParameter: true);
parameters.Add(testParameter);
}
}
public long AddNewTestParameter(TestParameter pNewParam)
{
DBTestParameter pDBParam = DBConversionHelper.ToDBParam(pNewParam);
long nNewID = __pDB.InsertNewTestParameter(pDBParam);
return(nNewID);
}
private void LoadTestCCParameters()
{
TestParameter desiredVariable = ((CCTestWorkspace)testWorkspace).GetDesiredValueVariable();
if (desiredVariable != null)
{
tbDesiredVarName.Text = desiredVariable.parameterName;
tbDesiredVarFrom.Text = tbActualVarFrom.Text = desiredVariable.from.ToString();
tbDesiredVarTo.Text = tbActualVarTo.Text = desiredVariable.to.ToString();
}
TestParameter actualVariable = ((CCTestWorkspace)testWorkspace).GetActualValueVariable();
if (actualVariable != null)
{
tbActualVarName.Text = actualVariable.parameterName;
}
foreach (TestParameter ccTestParameter in ((CCTestWorkspace)testWorkspace).GetCalibrationVairables())
{
string[] items = new string[5];
items[0] = ccTestParameter.parameterName;
items[1] = ccTestParameter.from.ToString();
items[2] = ccTestParameter.to.ToString();
items[3] = ccTestParameter.parameterDataType.dataTypeName;
items[4] = ccTestParameter.valueForTest.ToString();
ListViewItem listViewItem = new ListViewItem(items);
lvCalibrationVariables.Items.Add(listViewItem);
btnCalibrationVarRemove.Enabled = true;
}
tbSimulationTime.Text = testWorkspace.GetSimulationTime().ToString();
tbInitialDsrdTest.Text = tbDesiredVarFrom.Text;
tbFinalDsrdTest.Text = tbDesiredVarTo.Text;
modelRunningTimeCurrentMilisec = ((CCTestWorkspace)testWorkspace).GetModelRunningTime();
}
public TestParameter GetLabTestParameterById(int LabTestId, int ParameterId)
{
DataTable dt = this.GetTestParameters(LabTestId, ParameterId);
TestParameter param = null;
if (null != dt && dt.Rows.Count == 1)
{
DataRow row = dt.Rows[0];
param = new TestParameter()
{
Id = Convert.ToInt32(row["Id"]),
Name = row["ParameterName"].ToString(),
ReferenceId = row["ReferenceId"].ToString(),
LabTestId = Convert.ToInt32(row["LabTestId"]),
DataType = row["DataType"].ToString(),
Rank = Convert.ToDecimal(row["OrdRank"]),
LoincCode = row["LoincCode"].ToString(),
ResultConfig = null,
DeleteFlag = Convert.ToBoolean(row["DeleteFlag"]),
ResultOption = null
};
}
return(param);
}
protected bool TryGetArgumentValue(
[NotNull] TestParameter parameter,
[NotNull] IOpenDataset datasetContext,
[CanBeNull] out object value)
{
return(TryGetArgumentValue(parameter, datasetContext, null, out value));
}
internal HtmlTestParameter([NotNull] TestParameter testParameter)
{
Name = testParameter.Name;
Description = StringUtils.IsNotEmpty(testParameter.Description)
? testParameter.Description
: null;
Type = TestImplementationUtils.GetParameterTypeString(testParameter);
}
public void Command_WithParamToByteArray()
{
var parameter = new TestParameter {
Data = new byte[] { 0x98, 0x76, 0x54, 0x32, 0x10 }
};
var command = new Command(OpcodeGroup.InformationalParameters, 0x12345);
command.Parameters.Add(parameter);
Assert.AreEqual(command.ToByteArray(), new byte[] { 0x45, 0x33, 0x05, 0x98, 0x76, 0x54, 0x32, 0x10 });
}
/// <summary>
/// Initializes a new instance of the <see cref="DatasetTestParameterValue"/> class.
/// </summary>
/// <param name="testParameter">The test parameter.</param>
/// <param name="dataset">The dataset.</param>
/// <param name="filterExpression">The filter expression.</param>
/// <param name="usedAsReferenceData">Indicates that this dataset is used as valid reference data for
/// the quality condition. if only reference datasets are loaded in a work context for a given
/// quality condition, the quality condition is not applied</param>
public DatasetTestParameterValue([NotNull] TestParameter testParameter,
[CanBeNull] Dataset dataset = null,
[CanBeNull] string filterExpression = null,
bool usedAsReferenceData = false)
: base(testParameter)
{
_datasetValue = dataset;
_filterExpression = filterExpression;
_usedAsReferenceData = usedAsReferenceData;
}
private void ModelUnderTestCCSettings_Shown(object sender, EventArgs e)
{
UpdateTimeEstimates();
float from = 0, to = 0;
TestParameter desiredVariable = ((CCTestWorkspace)testWorkspace).GetDesiredValueVariable();
from = desiredVariable.from;
to = desiredVariable.to;
parentCCSettingsForm.CreateLabelsWithNewRanges(from,to);
}
private void RemoveUnoptimisedParameter()
{
if (lbUnoptimisedParameters.SelectedItem != null)
{
TestParameter testParameter = (TestParameter)lbUnoptimisedParameters.SelectedItem;
parameterManager.RemoveParameter(testParameter, ParameterType.Unoptimised);
//currentTest.UnoptimisedStoredProcedureParameters.Remove(testParameter);
//logHelper.Log($"Removed: {testParameter}");
}
}
public void MetadataImport_XmlDocumentation_TestParameters()
{
TestModel testModel = PopulateTestTree();
Test test = GetDescendantByName(testModel.RootTest, typeof(ParameterizedTest).Name);
TestParameter fieldParameter = GetParameterByName(test, "FieldParameter");
TestParameter propertyParameter = GetParameterByName(test, "PropertyParameter");
Assert.AreEqual("<summary>\nA field parameter.\n</summary>", fieldParameter.Metadata.GetValue(MetadataKeys.XmlDocumentation));
Assert.AreEqual("<summary>\nA property parameter.\n</summary>", propertyParameter.Metadata.GetValue(MetadataKeys.XmlDocumentation));
}
private void loadVariables()
{
tbSimulationTime.Text = testWorkspace.GetSimulationTime().ToString();
lvVariables.Items.Clear();
if (cmbVarType.SelectedIndex == 0 || cmbVarType.SelectedIndex == 1)
{
for (int i = 0; i < ((SLTestWorkspace)testWorkspace).inputVariables.Count; ++i)
{
TestParameter inputVar = ((SLTestWorkspace)testWorkspace).inputVariables[i];
string[] items = new string[6];
items[0] = inputVar.blockInfo.blockTag;
items[1] = "Input";
items[2] = inputVar.parameterDataType.dataTypeName.ToString();
items[3] = inputVar.parameterDataType.minDataType.ToString();
items[4] = inputVar.parameterDataType.maxDataType.ToString();
items[5] = inputVar.blockInfo.blockPath.ToString();
ListViewItem listViewItem = new ListViewItem(items);
lvVariables.Items.Add(listViewItem);
}
}
if (cmbVarType.SelectedIndex == 0 || cmbVarType.SelectedIndex == 2)
{
for (int i = 0; i < ((SLTestWorkspace)testWorkspace).calibrationVariables.Count; ++i)
{
TestParameter calibVar = ((SLTestWorkspace)testWorkspace).calibrationVariables[i];
string[] items = new string[6];
items[0] = calibVar.blockInfo.blockTag;
items[1] = "Configuration";
items[2] = calibVar.parameterDataType.dataTypeName.ToString();
items[3] = calibVar.parameterDataType.minDataType.ToString();
items[4] = calibVar.parameterDataType.maxDataType.ToString();
items[5] = calibVar.blockInfo.blockPath.ToString();
ListViewItem listViewItem = new ListViewItem(items);
lvVariables.Items.Add(listViewItem);
}
}
if (cmbVarType.SelectedIndex == 0 || cmbVarType.SelectedIndex == 3)
{
for (int i = 0; i < ((SLTestWorkspace)testWorkspace).outputVariables.Count; ++i)
{
TestParameter outVar = ((SLTestWorkspace)testWorkspace).outputVariables[i];
string[] items = new string[6];
items[0] = outVar.blockInfo.blockTag;
items[1] = "Outuput";
items[2] = outVar.parameterDataType.dataTypeName.ToString();
items[3] = outVar.parameterDataType.minDataType.ToString();
items[4] = outVar.parameterDataType.maxDataType.ToString();
items[5] = outVar.blockInfo.blockPath.ToString();
ListViewItem listViewItem = new ListViewItem(items);
lvVariables.Items.Add(listViewItem);
}
}
}
/// <summary>
/// Recreates a <see cref="TestParameter" /> object from the test data.
/// </summary>
/// <remarks>
/// <para>
/// Because a test parameter data object does not contain all of the details of the original
/// test parameter some information may be lost in the round trip.
/// </para>
/// </remarks>
/// <returns>The test parameter.</returns>
public TestParameter ToTestParameter()
{
var testParameter = new TestParameter(Name, CodeElement)
{
Id = Id
};
testParameter.Metadata.Clear();
testParameter.Metadata.AddAll(Metadata);
return(testParameter);
}
protected override void SetPropertyValue(ITest test, TestParameter testParameter,
object value)
{
if (testParameter.Name == _existsRowGroupFilterName)
{
((QaGroupConstraints)test).ExistsRowGroupFilters = new[] { (string)value };
}
else
{
base.SetPropertyValue(test, testParameter, value);
}
}
protected override void SetPropertyValue(ITest test, TestParameter testParameter,
object value)
{
if (string.Equals(testParameter.Name,
_parameterNameApplyFilterInDatabase,
StringComparison.OrdinalIgnoreCase))
{
return;
}
base.SetPropertyValue(test, testParameter, value);
}
protected bool TryGetArgumentValue(
[NotNull] TestParameter parameter,
[NotNull] IOpenDataset datasetContext,
[CanBeNull] out object value,
[CanBeNull] out List <TableConstraint> tableConstraint)
{
List <TableConstraint> constraints = new List <TableConstraint>();
bool success = TryGetArgumentValue(parameter, datasetContext, constraints, out value);
tableConstraint = constraints;
return(success);
}
public async Task It_Creates_From_Task_T()
{
var receivedParameter = default(TestParameter);
var factory = new DynamicCommandBuilderFactory();
var command = factory.CreateFromTask <TestParameter>(DefaultCommandName, async(ct, p) => receivedParameter = p).Build();
var parameter = new TestParameter();
await command.Execute(parameter);
receivedParameter.Should().Be(parameter);
}
protected override void SetPropertyValue(ITest test, TestParameter testParameter,
object value)
{
if (testParameter.Name == _groupConditionName)
{
((QaLineGroupConstraints)test).GroupConditions = new[] { (string)value };
}
else
{
base.SetPropertyValue(test, testParameter, value);
}
}
private static object GetValue([NotNull] TestParameterValue paramVal,
[NotNull] TestParameter parameter,
[NotNull] IOpenDataset datasetContext)
{
Assert.ArgumentNotNull(paramVal, nameof(paramVal));
Assert.ArgumentNotNull(parameter, nameof(parameter));
Assert.ArgumentNotNull(datasetContext, nameof(datasetContext));
var scalarParameterValue = paramVal as ScalarTestParameterValue;
if (scalarParameterValue != null)
{
if (scalarParameterValue.DataType == null)
{
scalarParameterValue.DataType = parameter.Type;
_msg.VerboseDebugFormat(
"DataType of scalarParameterValue {0} needed to be initialized.",
scalarParameterValue.TestParameterName);
}
return(scalarParameterValue.GetValue());
}
var datasetParameterValue = paramVal as DatasetTestParameterValue;
if (datasetParameterValue != null)
{
if (datasetParameterValue.DatasetValue == null &&
!parameter.IsConstructorParameter)
{
return(null);
}
Dataset dataset =
Assert.NotNull(datasetParameterValue.DatasetValue, "dataset is null");
datasetParameterValue.DataType = parameter.Type;
// TODO: Test in AO11 context and consider not running this test
Assert.True(datasetContext.CanOpen(dataset), "Cannot open dataset {0} of type {1}",
dataset, parameter.Type);
object result = datasetContext.OpenDataset(dataset, datasetParameterValue.DataType);
Assert.NotNull(result, "Dataset not found in current context: {0}",
dataset.Name);
return(result);
}
throw new ArgumentException($"Unhandled type {paramVal.GetType()}");
}
protected void SaveLabParameter(object sender, EventArgs e)
{
TestParameter parameter = null;
if (this.OpenMode == "NEW" && this.ParameterId == -1)
{
parameter = new TestParameter()
{
Id = -1,
LabTestId = this.LabTestId,
DeleteFlag = false,
DataType = ddlDataType.SelectedValue,
LoincCode = textLoincCode.Text,
Rank = textRank.Text != ""? Convert.ToDecimal(textRank.Text) : 0.00M,
Name = textParameterName.Text,
ReferenceId = textReference.Text,
ResultConfig = null,
ResultOption = null
};
if (ddlDataType.SelectedValue == "NUMERIC")
{
parameter.ResultConfig = this.UnitConfig;
}
else if (ddlDataType.SelectedValue == "SELECTLIST")
{
parameter.ResultOption = this.ParseResultOptions();
}
}
else
{
parameter = (TestParameter)Session[SessionKey.TestParameters];
parameter.DataType = ddlDataType.SelectedValue;
parameter.LoincCode = textLoincCode.Text;
// parameter.ReferenceId = textReference.Text;
parameter.LabTestId = this.LabTestId;
parameter.Name = textParameterName.Text;
parameter.DeleteFlag = false;
if (ddlDataType.SelectedValue == "NUMERIC")
{
parameter.ResultConfig = this.UnitConfig;
}
else if (ddlDataType.SelectedValue == "SELECTLIST")
{
parameter.ResultOption = this.ParseResultOptions();
}
}
TestParameter result = mGr.SaveLabTestParameter(parameter, this.UserId);
this.OpenMode = "EDIT";
IQCareMsgBox.NotifyAction(result.Name + " has been saved successfully", "Success: Save Parameter", false, this, "javascript:window.location='./TestParameterMaster.aspx'; return true;");
this.BindParameter(result);
}
protected override void SetPropertyValue(ITest test, TestParameter parameter,
object value)
{
if (parameter.Name.Equals(MatchIsErrorName,
StringComparison.CurrentCultureIgnoreCase) ||
parameter.Name.Equals(PatternDescriptionName,
StringComparison.CurrentCultureIgnoreCase))
{
return;
}
base.SetPropertyValue(test, parameter, value);
}
public static void Main(string[] args)
{
var testParameter = new TestParameter(1000, 100, 100);
var types = new[] { typeof(MatrixModel), typeof(MapListModel), typeof(MapMapModel), typeof(ListModel) };
Test(testParameter, types);
Thread.Sleep(1000000);
}
private static void TestWorld(TestParameter testParameter, World[] allWorlds, int worldIndex, long[,,] times,
int execution)
{
var world = allWorlds[worldIndex];
var newActors = InitActors(testParameter);
var localTimes = TestWorld(world, newActors);
for (var timeIndex = 0; timeIndex < localTimes.Length; timeIndex++)
{
times[worldIndex, execution, timeIndex + 1] = localTimes[timeIndex];
}
world.Reset();
}
public async Task It_Executes_With_Parameter_T()
{
var executeStrategyParameter = default(TestParameter);
var strategy = new ActionCommandStrategy <TestParameter>(
execute: p => executeStrategyParameter = p
);
var command = new DynamicCommand(DefaultCommandName, strategy);
var parameter = new TestParameter();
await command.Execute(parameter);
executeStrategyParameter.Should().Be(parameter);
}
public Dictionary <string, string> Index([FromBody] TestParameter parameter)
{
if (!ModelState.IsValid)
{
return(new Dictionary <string, string>()
{
{ "error", ModelState.Values.First(w => w.Errors.Count > 0).Errors[0].ErrorMessage }
});
}
return(new Dictionary <string, string>()
{
{ "access_token", parameter.access_token },
{ "passport_token", parameter.passport_token },
});
}
protected void gridParamMaster_RowDataBound(object sender, GridViewRowEventArgs e)
{
try
{
if (e.Row.RowType == DataControlRowType.DataRow)
{
TestParameter row = ((TestParameter)e.Row.DataItem);
e.Row.Cells[2].Text = row.DataType == "SELECTLIST" ? "Select List" : (row.DataType == "NUMERIC") ? "Numeric" : row.DataType;
e.Row.Cells[5].Text = row.DeleteFlag ? "In Active" : "Active";
}
}
catch (Exception ex)
{
this.ShowErrorMessage(ref ex);
}
}
public bool IsStupid(TestParameter m)
{
return m.Value == 1;
}
