public void AddHandler(object sender, EventArgs args)
{
DataDictionary.Tests.Step step = (DataDictionary.Tests.Step)DataDictionary.Generated.acceptor.getFactory().createStep();
step.Name = "Step" + (GetNodeCount(false) + 1);
createStep(step);
}
/// <summary>
/// Executes the action
/// </summary>
/// <param name="e"></param>
protected override void OnClick(EventArgs e)
{
Step newStep = (Step)acceptor.getFactory().createStep();
newStep.Enclosing = TimeLineControl.TestCase;
SubStep subStep = (SubStep)acceptor.getFactory().createSubStep();
subStep.Name = "Substep 1";
newStep.appendSubSteps(subStep);
TestCase testCase = GetTestCase();
if (Step != null)
{
newStep.Name = "NewStep";
int index = TimeLineControl.Steps.IndexOf(Step);
testCase.Steps.Insert(index + 1, newStep);
newStep.setFather(testCase);
}
else
{
newStep.Name = "Step " + (TimeLineControl.Steps.Count + 1);
testCase.Steps.Add(newStep);
newStep.setFather(testCase);
}
base.OnClick(e);
}
/// <summary>
/// The sub step relative to the mouse position
/// </summary>
/// <returns></returns>
private SubStep SubStepRelatedToMousePosition()
{
SubStep retVal = null;
ModelEvent evt = GetEventUnderMouse();
if (evt != null && evt.Instance != null)
{
retVal = EnclosingFinder <SubStep> .find(evt.Instance as IEnclosed, true);
if (retVal == null)
{
Step step = evt.Instance as Step;
if (step != null && step.SubSteps.Count > 0)
{
retVal = (SubStep)step.SubSteps[step.SubSteps.Count - 1];
}
}
}
if (retVal == null && Steps != null && Steps.Count > 0)
{
Step step = (Step)Steps[Steps.Count - 1];
if (step.SubSteps.Count > 0)
{
retVal = (SubStep)step.SubSteps[step.SubSteps.Count - 1];
}
}
return(retVal);
}
/// <summary>
/// Creates a step in a test case
/// </summary>
/// <param name="enclosing"></param>
/// <param name="name"></param>
/// <returns></returns>
protected SubStep CreateSubStep(Step enclosing, string name)
{
SubStep retVal = (SubStep)Factory.createSubStep();
enclosing.appendSubSteps(retVal);
retVal.Name = name;
return(retVal);
}
/// <summary>
/// Creates a new translation based on a step
/// </summary>
/// <param name="step"></param>
private void createTranslation(DataDictionary.Tests.Step step)
{
DataDictionary.Tests.Translations.Translation translation = (DataDictionary.Tests.Translations.Translation)DataDictionary.Generated.acceptor.getFactory().createTranslation();
DataDictionary.Tests.Translations.SourceText sourceText = (DataDictionary.Tests.Translations.SourceText)DataDictionary.Generated.acceptor.getFactory().createSourceText();
sourceText.Name = step.getDescription();
translation.appendSourceTexts(sourceText);
createTranslation(translation);
}
/// <summary>
/// Creates a new step
/// </summary>
/// <param name="step"></param>
/// <returns></returns>
public StepTreeNode createStep(DataDictionary.Tests.Step step)
{
step.Enclosing = Item;
StepTreeNode retVal = new StepTreeNode(step);
Item.appendSteps(step);
Nodes.Add(retVal);
return(retVal);
}
public override void visit(Step obj, bool visitSubNodes)
{
DataDictionary.Tests.Step step = (DataDictionary.Tests.Step)obj;
if (Translation == EfsSystem.Instance.FindTranslation(step))
{
step.AddInfo("Translation " + Translation.Name + " used");
}
base.visit(obj, visitSubNodes);
}
/// <summary>
/// Selects the current step by clicking on the label
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void toolStripLabel4_Click(object sender, EventArgs e)
{
if (EFSSystem.Runner != null)
{
DataDictionary.Tests.Step step = EFSSystem.Runner.CurrentStep();
if (step != null)
{
MDIWindow.Select(step);
}
}
}
/// <summary>
/// Describes a specific Subset-076 specification issue
/// </summary>
/// <param name="paragraph"></param>
private void DescribeSpecIssue(Paragraph paragraph)
{
if (paragraph.SubParagraphs.Count > 0)
{
Report.AddSubParagraph(paragraph.Name);
Report.AddTable(new[] { "SubSequence", "Test case", "Step", "Comment" }, new[] { 60, 20, 10, 80 });
foreach (Paragraph subParagraph in paragraph.SubParagraphs)
{
DescribeSpecIssue(subParagraph);
}
Report.CloseSubParagraph();
}
else
{
Report.AddRow(paragraph.ExpressionText);
Report.SetLastRowColor(IssueColor(paragraph));
if (paragraph.Implementations.Count > 0)
{
foreach (ReqRef reqRef in paragraph.Implementations)
{
SubSequence subSequence = EnclosingFinder <SubSequence> .find(reqRef, true);
TestCase testCase = EnclosingFinder <TestCase> .find(reqRef, true);
Step step = EnclosingFinder <Step> .find(reqRef, true);
Report.AddRow(
subSequence != null ? subSequence.Name : "",
testCase != null ? testCase.getFeature().ToString(CultureInfo.InvariantCulture) : "",
step != null ? step.getTCS_Order().ToString(CultureInfo.InvariantCulture) : "",
reqRef.Comment);
}
}
}
}
/// <summary>
/// Creates a step in a test case
/// </summary>
/// <param name="enclosing"></param>
/// <param name="name"></param>
/// <returns></returns>
protected SubStep CreateSubStep(Step enclosing, string name)
{
SubStep retVal = (SubStep) Factory.createSubStep();
enclosing.appendSubSteps(retVal);
retVal.Name = name;
return retVal;
}
/// <summary>
/// Imports the subsequence stored in the database
/// </summary>
/// <param name="subSequence"></param>
/// <param name="subSequenceId"></param>
private void ImportInitialValues(SubSequence subSequence, int subSequenceId)
{
// Level is a reserved word...
string sql =
"SELECT D_LRBG, TSW_TestSeqSCItl.Level, Mode, NID_LRBG, Q_DIRLRBG, Q_DIRTRAIN, Q_DLRBG, RBC_ID, RBCPhone FROM TSW_TestSeqSCItl WHERE TestSequenceID = " +
subSequenceId;
OleDbDataAdapter adapter = new OleDbDataAdapter(sql, Connection);
DataSet dataSet = new DataSet();
adapter.Fill(dataSet);
if (dataSet.Tables.Count > 0)
{
foreach (DataRow dataRow in dataSet.Tables[0].Rows)
{
int i = 0;
// ReSharper disable InconsistentNaming
string D_LRBG = dataRow.ItemArray.GetValue(i++) as string;
string Level = dataRow.ItemArray.GetValue(i++) as string;
string Mode = dataRow.ItemArray.GetValue(i++) as string;
string NID_LRBG = dataRow.ItemArray.GetValue(i++) as string;
string Q_DIRLRBG = dataRow.ItemArray.GetValue(i++) as string;
string Q_DIRTRAIN = dataRow.ItemArray.GetValue(i++) as string;
string Q_DLRBG = dataRow.ItemArray.GetValue(i++) as string;
string RBC_ID = dataRow.ItemArray.GetValue(i++) as string;
string RBCPhone = dataRow.ItemArray.GetValue(i++) as string;
// ReSharper restore InconsistentNaming
subSequence.setD_LRBG(D_LRBG);
subSequence.setLevel(Level);
subSequence.setMode(Mode);
subSequence.setNID_LRBG(NID_LRBG);
subSequence.setQ_DIRLRBG(Q_DIRLRBG);
subSequence.setQ_DIRTRAIN(Q_DIRTRAIN);
subSequence.setQ_DLRBG(Q_DLRBG);
subSequence.setRBC_ID(RBC_ID);
subSequence.setRBCPhone(RBCPhone);
TestCase testCase = (TestCase)acceptor.getFactory().createTestCase();
testCase.Name = "Setup";
subSequence.appendTestCases(testCase);
Step initializeTrainDataStep = (Step)acceptor.getFactory().createStep();
initializeTrainDataStep.setTCS_Order(0);
initializeTrainDataStep.setDistance("0");
initializeTrainDataStep.setDescription("Initialize train data");
initializeTrainDataStep.setTranslationRequired(true);
testCase.appendSteps(initializeTrainDataStep);
Step defaultValuesStep = (Step)acceptor.getFactory().createStep();
defaultValuesStep.setTCS_Order(0);
defaultValuesStep.setDistance("0");
defaultValuesStep.setDescription("Set default values");
defaultValuesStep.setTranslationRequired(true);
testCase.appendSteps(defaultValuesStep);
Step manualSetupStep = (Step)acceptor.getFactory().createStep();
manualSetupStep.setTCS_Order(0);
manualSetupStep.setDistance("0");
manualSetupStep.setDescription("Manual setup test sequence");
manualSetupStep.setTranslationRequired(false);
testCase.appendSteps(manualSetupStep);
}
}
else
{
throw new Exception("Cannot find entry in table TSW_TestSeqSCItl WHERE TestSequenceID = " + subSequenceId);
}
}
/// <summary>
/// Refreshes the display
/// </summary>
override public void Refresh()
{
if (!DoingRefresh)
{
try
{
DoingRefresh = true;
string selectedFrame = frameToolStripComboBox.Text;
string selectedSequence = subSequenceSelectorComboBox.Text;
if (EFSSystem.Runner == null)
{
toolStripTimeTextBox.Text = "0";
toolStripCurrentStepTextBox.Text = "<none>";
}
else
{
toolStripTimeTextBox.Text = "" + EFSSystem.Runner.Time;
DataDictionary.Tests.Step currentStep = EFSSystem.Runner.CurrentStep();
if (currentStep != null)
{
toolStripCurrentStepTextBox.Text = currentStep.Name;
}
else
{
toolStripCurrentStepTextBox.Text = "<none>";
}
Frame = EFSSystem.Runner.SubSequence.Frame;
selectedFrame = EFSSystem.Runner.SubSequence.Frame.Name;
selectedSequence = EFSSystem.Runner.SubSequence.Name;
}
testBrowserTreeView.Refresh();
evcTimeLineControl.Refresh();
frameToolStripComboBox.Items.Clear();
List <string> frames = new List <string>();
foreach (DataDictionary.Dictionary dictionary in EFSSystem.Dictionaries)
{
foreach (DataDictionary.Tests.Frame frame in dictionary.Tests)
{
frames.Add(frame.Name);
}
}
frames.Sort();
foreach (string frame in frames)
{
if (frame != null)
{
frameToolStripComboBox.Items.Add(frame);
}
}
frameToolStripComboBox.Text = selectedFrame;
frameToolStripComboBox.ToolTipText = selectedFrame;
if (Frame == null || frameToolStripComboBox.Text.CompareTo(Frame.Name) != 0)
{
subSequenceSelectorComboBox.Items.Clear();
foreach (DataDictionary.Dictionary dictionary in EFSSystem.Dictionaries)
{
Frame = dictionary.findFrame(frameToolStripComboBox.Text);
if (Frame != null)
{
foreach (DataDictionary.Tests.SubSequence subSequence in Frame.SubSequences)
{
subSequenceSelectorComboBox.Items.Add(subSequence.Name);
}
break;
}
}
if (subSequenceSelectorComboBox.Items.Count > 0)
{
subSequenceSelectorComboBox.Text = subSequenceSelectorComboBox.Items[0].ToString();
}
else
{
subSequenceSelectorComboBox.Text = "";
}
EFSSystem.Runner = null;
}
if (EFSSystem.Runner != null)
{
subSequenceSelectorComboBox.Text = EFSSystem.Runner.SubSequence.Name;
}
subSequenceSelectorComboBox.ToolTipText = subSequenceSelectorComboBox.Text;
testBrowserStatusLabel.Text = frames.Count + " frame(s) loaded";
}
finally
{
DoingRefresh = false;
}
}
base.Refresh();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="step"></param>
public StepActivation(Step step)
: base(step.Name, step, null)
{
Step = step;
}
private void fillBrakingParametersExpectations(TestCase aTestCase, int stepNumber, string name,
string expression, List<double> distanceValues, List<double> speedValues, List<double> values)
{
Step aStep = new Step();
aStep.Name = String.Format("Step{0} - {1}", stepNumber, name);
aTestCase.AddModelElement(aStep);
SubStep aSubStep = new SubStep();
aSubStep.Name = String.Format("SubStep1 - Verify {0} values", name);
aStep.AddModelElement(aSubStep);
for (int i = 0; i < values.Count; i++)
{
if (values[i] != -1)
{
Expectation expectation = new Expectation();
expectation.ExpressionText = String.Format(CultureInfo.InvariantCulture, expression,
Math.Round(distanceValues[i], 2), Math.Round(speedValues[i], 2), Math.Round(values[i], 4));
aSubStep.AddModelElement(expectation);
}
}
}
/// <summary>
/// Creates a new translation based on a step's source text
/// </summary>
/// <param name="step"></param>
private void CreateTranslation(Step step)
{
CreateTranslation(Translation.CreateDefault(Item.Translations, step.CreateSourceText()));
}
/// <summary>
/// Provides the translation for the given step
/// </summary>
/// <param name="step"></param>
/// <returns></returns>
public Tests.Translations.Translation FindTranslation(Step step)
{
return FindTranslation(step.getDescription(), step.Comment);
}
/// <summary>
/// Imports the steps in a sub sequence
/// </summary>
/// <param name="subSequence"></param>
private void importSteps(DataDictionary.Tests.SubSequence subSequence)
{
string sql = "SELECT TCSOrder, Distance, FT_NUMBER, TC_NUMBER, ST_STEP, ST_DESCRIPTION, UserComment, ST_IO, ST_INTERFACE, ST_COMMENTS, TestLevelIn, TestLevelOut, TestModeIn, TestModeOut FROM TSW_TCStep ORDER BY TCSOrder";
OleDbDataAdapter adapter = new OleDbDataAdapter(sql, Connection);
DataSet dataSet = new DataSet();
adapter.Fill(dataSet);
if (dataSet.Tables.Count > 0)
{
DataDictionary.Tests.TestCase testCase = null;
foreach (DataRow dataRow in dataSet.Tables[0].Rows)
{
object[] items = dataRow.ItemArray;
int order = (int)items[0];
int distance = (int)items[1];
int feature = (int)items[2];
int testCaseNr = (int)items[3];
string stepType = items[4] as string;
string description = items[5] as string;
string userComment = items[6] as string;
string io = items[7] as string;
string intrface = items[8] as string;
string comment = items[9] as string;
string testLevelIn = items[10] as string;
string testLevelOut = items[11] as string;
string testModeIn = items[12] as string;
string testModeOut = items[13] as string;
// we do not want to import steps "Followed by" or "Preceded by"
if (io != null && stepType != null && !stepType.Equals("Followed by") && !stepType.Equals("Preceded by"))
{
if (testCase != null)
{
if (testCase.getFeature() != feature || testCase.getCase() != testCaseNr)
{
testCase = null;
}
}
if (testCase == null)
{
testCase = (DataDictionary.Tests.TestCase)DataDictionary.Generated.acceptor.getFactory().createTestCase();
testCase.Name = "Feature " + feature + " Test case " + testCaseNr;
testCase.setCase(testCaseNr);
testCase.setFeature(feature);
subSequence.appendTestCases(testCase);
}
DataDictionary.Tests.Step step = (DataDictionary.Tests.Step)DataDictionary.Generated.acceptor.getFactory().createStep();
step.Name = "Step " + order;
step.setTCS_Order(order);
step.setDistance(distance);
step.setDescription(description);
step.setUserComment(userComment);
step.setIO_AsString(io);
if (intrface != null)
{
step.setInterface_AsString(intrface);
}
step.setComment(comment);
if (testLevelIn != null)
{
step.setLevelIN_AsString(testLevelIn);
}
if (testLevelOut != null)
{
step.setLevelOUT_AsString(testLevelOut);
}
if (testModeIn != null)
{
step.setModeIN_AsString(testModeIn);
}
if (testModeOut != null)
{
step.setModeOUT_AsString(testModeOut);
}
step.setTranslationRequired(true);
importStepMessages(step);
testCase.appendSteps(step);
}
}
}
else
{
Log.Error("Cannot find sub sequence table in database");
}
}
private void verifyInputForGamma(TestCase aTestCase, Workbook workbook)
{
Step aStep = new Step();
aStep.Name = "Step1 - Verify input";
aTestCase.AddModelElement(aStep);
/*********************************** TRAIN DATA ***********************************/
SubStep aSubStep = new SubStep();
aSubStep.Name = "SubStep1 - Train data";
aStep.AddModelElement(aSubStep);
addAction(aSubStep, "Kernel.SpeedAndDistanceMonitoring.ReleaseSpeedMonitoring.UpdateReleaseSpeed()");
addExpectation(aSubStep,
"Kernel.TrainData.BrakingParameters.ConversionModel.ConversionModelIsUsed() == False");
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="step"></param>
public StepActivation(Step step)
: base(step.Name, step, null)
{
Step = step;
}
/// <summary>
/// Creates a section for a given step
/// </summary>
/// <param name="aStep">The step to be displayed</param>
/// <param name="activatedRules">The list of rules activated by this step</param>
/// <param name="aReportConfig">The report config</param>
private void CreateStepSection(Step aStep, List<RuleCondition> activatedRules,
TestsCoverageReportHandler aReportConfig)
{
string title = "Step " + aStep.Name;
AddSubParagraph(title);
CreateActivatedRulesSection("",
new HashSet<RuleCondition>(activatedRules),
aReportConfig.Dictionary.ImplementedRules,
aReportConfig.AddActivatedRulesInTestCases);
CloseSubParagraph();
}
private void initializeInputForLambda(TestCase aTestCase, Workbook workbook)
{
Step aStep = new Step();
aStep.Name = "Step1 - Initialize input";
aTestCase.AddModelElement(aStep);
/*********************************** TRAIN DATA ***********************************/
SubStep aSubStep = new SubStep();
aSubStep.Name = "SubStep1 - Train data";
aSubStep.setSkipEngine(true);
aStep.AddModelElement(aSubStep);
/* This is a lambda train => no brake models defined in the train data */
addAction(aSubStep, String.Format("Kernel.TrainData.TrainData.Value.EBModels <- EMPTY"));
addAction(aSubStep, String.Format("Kernel.TrainData.TrainData.Value.SBModels <- EMPTY"));
addAction(aSubStep, String.Format("Kernel.TrainData.TrainData.Value.NormalServiceBrakeModels <- EMPTY"));
addAction(aSubStep, String.Format("Kernel.TrainData.TrainData.Value.T_brake_emergency <- EMPTY"));
addAction(aSubStep, String.Format("Kernel.TrainData.TrainData.Value.T_brake_service <- EMPTY"));
/* Initializing the maximum train speed */
/* This value must be in the range {0km/h; 200km/h}, otherwise the conversion model will not be applicable */
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture, "Kernel.TrainData.TrainData.Value.MaximumSpeed <- {0:0.0}",
180.0));
Worksheet aWorksheet = workbook.Sheets[1] as Worksheet;
bool isPassengerTrain;
importCommonTrainDataInformation(aSubStep, aWorksheet, out isPassengerTrain);
/*********************************** TRACK DATA ***********************************/
aSubStep = new SubStep();
aSubStep.Name = "SubStep2 - Track data";
aSubStep.setSkipEngine(true);
aStep.AddModelElement(aSubStep);
/* This is a lambda train => track condition brake inhibition profile is not applicable */
addAction(aSubStep, String.Format("Kernel.TrackDescription.TrackConditions.General.TCProfile <- []"));
aWorksheet = workbook.Sheets[2] as Worksheet;
importCommonTrackDataInformation(aSubStep, aWorksheet);
/*********************************** NATIONAL VALUES ***********************************/
aSubStep = new SubStep();
aSubStep.Name = "SubStep3 - National values";
aSubStep.setSkipEngine(true);
aStep.AddModelElement(aSubStep);
aWorksheet = workbook.Sheets[3] as Worksheet;
importCommonNationalValuesInformation(aSubStep, aWorksheet);
/*********************************** FIXED VALUES ***********************************/
aSubStep = new SubStep();
aSubStep.Name = "SubStep4 - Fixed values";
aSubStep.setSkipEngine(true);
aStep.AddModelElement(aSubStep);
aWorksheet = workbook.Sheets[4] as Worksheet;
importCommonFixedValuesInformation(aSubStep, aWorksheet);
/****************************** BRAKE PARAMETERS (lambda) ******************************/
aSubStep = new SubStep();
aSubStep.Name = "SubStep5 - Brake parameters";
aSubStep.setSkipEngine(true);
aStep.AddModelElement(aSubStep);
aWorksheet = workbook.Sheets[5] as Worksheet;
Range aRange = aWorksheet.UsedRange;
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.TrainData.TrainData.Value.BrakePercentage <- {0:0.0#}",
(double)(aRange.Cells[3, 6] as Range).Value2));
/*************************** INTERGRATED CORRECTION FACTORS ***************************/
aSubStep = new SubStep();
aSubStep.Name = "SubStep6 - Integrated correction factors";
aSubStep.setSkipEngine(true);
aStep.AddModelElement(aSubStep);
aWorksheet = workbook.Sheets[8] as Worksheet;
aRange = aWorksheet.UsedRange;
/* Initializing Kr_int */
int index = 0;
double doubleValue = -1;
double temp;
for (int i = 0; i < 9; i++)
{
temp = (double)(aRange.Cells[i + 32, 2] as Range).Value2;
if (doubleValue != temp)
{
double location = (double)(aRange.Cells[i + 32, 1] as Range).Value2;
doubleValue = temp;
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.NationalValues.ApplicableNationalValues.Value.IntegratedCorrectionFactorKrInt.Val{0} <- Kernel.NationalValues.KrIntValueStruct\n{{\n LengthStep => {1:0.0},\n Value => {2:0.0####}\n}}",
index, location, doubleValue));
index++;
}
}
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.NationalValues.ApplicableNationalValues.Value.IntegratedCorrectionFactorKrInt.Val{0} <- Kernel.NationalValues.KrIntValueStruct\n{{\n LengthStep => Default.BaseTypes.Length.Infinity,\n Value => {1:0.0####}\n}}",
index, doubleValue));
/* Case of a passenger train */
if (isPassengerTrain)
{
/* Initializing Kv_int */
double a = -1;
double b = -1;
double tempA, tempB;
index = 0;
for (int i = 0; i <= 9; i++)
{
tempA = (double)(aRange.Cells[i + 5, 5] as Range).Value2;
tempB = (double)(aRange.Cells[i + 31, 5] as Range).Value2;
if (a != tempA || b != tempB)
{
double speed = (double)(aRange.Cells[i + 5, 4] as Range).Value2;
a = tempA;
b = tempB;
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.NationalValues.ApplicableNationalValues.Value.IntegratedCorrectionFactorKvInt_PassengerTrain.Val{0} <- Kernel.NationalValues.KvIntValue_PassengerTrainStruct\n{{\n SpeedStep => {1:0.0},\n ValueA => {2:0.0#},\n ValueB => {3:0.0#}\n}}",
index, speed, a, b));
index++;
}
}
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.NationalValues.ApplicableNationalValues.Value.IntegratedCorrectionFactorKvInt_PassengerTrain.Val{0} <- Kernel.NationalValues.KvIntValue_PassengerTrainStruct\n{{\n SpeedStep => Default.BaseTypes.Speed.Infinity,\n ValueA => {1:0.0#},\n ValueB => {2:0.0#}\n}}",
index, a, b));
}
else /* Case of freight trains */
{
/* Initializing Kv_int */
doubleValue = -1;
index = 0;
for (int i = 0; i <= 9; i++)
{
temp = (double)(aRange.Cells[i + 5, 2] as Range).Value2;
if (doubleValue != temp)
{
double speed = (double)(aRange.Cells[i + 5, 1] as Range).Value2;
doubleValue = temp;
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.NationalValues.ApplicableNationalValues.Value.IntegratedCorrectionFactorKvInt_FreightTrain.Val{0} <- Kernel.NationalValues.KvIntValue_FreightTrainStruct\n{{\n SpeedStep => {1:0.0},\n Value => {2:0.0#}\n}}",
index, speed, doubleValue));
index++;
}
}
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.NationalValues.ApplicableNationalValues.Value.IntegratedCorrectionFactorKvInt_FreightTrain.Val{0} <- Kernel.NationalValues.KvIntValue_FreightTrainStruct\n{{\n SpeedStep => Default.BaseTypes.Speed.Infinity,\n Value => {1:0.0#}\n}}",
index, doubleValue));
}
/* Initializing A_NVP12 */
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.NationalValues.ApplicableNationalValues.Value.IntegratedCorrectionFactorKvInt_PassengerTrain.A_NVP12 <- {0:0.0}",
(double)(aRange.Cells[44, 4] as Range).Value2));
/* Initializing A_NVP23 */
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.NationalValues.ApplicableNationalValues.Value.IntegratedCorrectionFactorKvInt_PassengerTrain.A_NVP23 <- {0:0.0}",
(double)(aRange.Cells[44, 6] as Range).Value2));
/* Initializing Kt_int */
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.NationalValues.ApplicableNationalValues.Value.IntegratedCorrectionFactorForBrakeBuildUpTime <- {0:0.0}",
(double)(aRange.Cells[47, 4] as Range).Value2));
}
private void initializeInputForGamma(TestCase aTestCase, Workbook workbook)
{
Step aStep = new Step();
aStep.Name = "Step1 - Initialize input";
aTestCase.AddModelElement(aStep);
/*********************************** TRAIN DATA ***********************************/
SubStep aSubStep = new SubStep();
aSubStep.Name = "SubStep1 - Train data";
aSubStep.setSkipEngine(true);
aStep.AddModelElement(aSubStep);
/* This is a gamma train => we have to initialize brake models in the train data */
addAction(aSubStep,
String.Format(
"Kernel.TrainData.TrainData.Value.EBModels <- Kernel.TrainData.BrakingParameters.EBModelSet\n{{\n ModelSet => Kernel.TrainData.BrakingParameters.BrakingModelSet{{}},\n Kdry_rstValuesSet => Kernel.TrainData.BrakingParameters.Kdry_rstValuesSet{{}},\n Kwet_rstValuesSet => Kernel.TrainData.BrakingParameters.Kwet_rstValuesSet{{}}\n}}"));
addAction(aSubStep,
String.Format(
"Kernel.TrainData.TrainData.Value.SBModels <- Kernel.TrainData.BrakingParameters.SBModelSet{{}}"));
/* Initializing the maximum train speed */
/* I didn't find this value in ERA sheets, but I observed than their P function can exceed 160 km/h => the maximum speed should be greater than 160 km/h */
addAction(aSubStep,
String.Format(CultureInfo.InvariantCulture, "Kernel.TrainData.TrainData.Value.MaximumSpeed <- {0:0.0}",
180.0));
Worksheet aWorksheet = workbook.Sheets[1] as Worksheet;
bool isPassengerTrain;
importCommonTrainDataInformation(aSubStep, aWorksheet, out isPassengerTrain);
/*********************************** TRACK DATA ***********************************/
aSubStep = new SubStep();
aSubStep.Name = "SubStep2 - Track data";
aSubStep.setSkipEngine(true);
aStep.AddModelElement(aSubStep);
aWorksheet = workbook.Sheets[2] as Worksheet;
importCommonTrackDataInformation(aSubStep, aWorksheet);
/*********************************** NATIONAL VALUES ***********************************/
aSubStep = new SubStep();
aSubStep.Name = "SubStep3 - National values";
aSubStep.setSkipEngine(true);
aStep.AddModelElement(aSubStep);
aWorksheet = workbook.Sheets[3] as Worksheet;
importCommonNationalValuesInformation(aSubStep, aWorksheet);
/*********************************** FIXED VALUES ***********************************/
aSubStep = new SubStep();
aSubStep.Name = "SubStep4 - Fixed values";
aSubStep.setSkipEngine(true);
aStep.AddModelElement(aSubStep);
aWorksheet = workbook.Sheets[4] as Worksheet;
importCommonFixedValuesInformation(aSubStep, aWorksheet);
/****************************** BRAKE PARAMETERS (gamma) ******************************/
aSubStep = new SubStep();
aSubStep.Name = "SubStep5 - Brake parameters";
aSubStep.setSkipEngine(true);
aStep.AddModelElement(aSubStep);
aWorksheet = workbook.Sheets[6] as Worksheet;
importGammaBrakeParameters(aSubStep, aWorksheet, 2, 8, true); // first combination
importGammaBrakeParameters(aSubStep, aWorksheet, 3, 20, false); // second combination
/**************************** Initialize time intervals ******************************/
aSubStep = new SubStep();
aSubStep.Name = "Initialize time intervals";
aSubStep.setSkipEngine(true);
aStep.AddModelElement(aSubStep);
addAction(aSubStep, "Kernel.SpeedAndDistanceMonitoring.TargetSpeedMonitoring.InitializeTimeIntervals()");
/**************************** CORRECTION FACTOR KDRY_RST ****************************/
aSubStep = new SubStep();
aSubStep.Name = "SubStep6 - Correction factor kdry_rst";
aSubStep.setSkipEngine(true);
aStep.AddModelElement(aSubStep);
aWorksheet = workbook.Sheets[7] as Worksheet;
}
/// <summary>
/// Imports all the messages used by this step
/// </summary>
/// <param name="aStep"></param>
private void importStepMessages(Step aStep)
{
string sql =
"SELECT TCSOrder, MessageOrder, MessageType, Var_Name, Var_Value FROM TSW_MessageHeader ORDER BY MessageOrder, Var_Row";
OleDbDataAdapter adapter = new OleDbDataAdapter(sql, Connection);
DataSet dataSet = new DataSet();
adapter.Fill(dataSet);
if (dataSet.Tables.Count > 0)
{
int messageNumber = 0;
DBMessage message = null;
int order = -1;
foreach (DataRow dataRow in dataSet.Tables[0].Rows)
{
object[] items = dataRow.ItemArray;
order = (int) items[0];
if (order == aStep.getTCS_Order())
{
short messageOrder = (short) items[1];
if (messageNumber != messageOrder) // we create a new Message
{
if (messageNumber != 0)
{
aStep.AddMessage(message);
importPackets(message, order);
}
short messageTypeNumber = (short) items[2];
acceptor.DBMessageType messageType = acceptor.DBMessageType.defaultDBMessageType;
switch (messageTypeNumber)
{
case 0:
messageType = acceptor.DBMessageType.aEUROBALISE;
break;
case 1:
messageType = acceptor.DBMessageType.aEUROLOOP;
break;
case 2:
messageType = acceptor.DBMessageType.aEURORADIO;
break;
}
message = (DBMessage) acceptor.getFactory().createDBMessage();
message.MessageOrder = messageOrder;
message.MessageType = messageType;
messageNumber = messageOrder;
}
DBField field = (DBField) acceptor.getFactory().createDBField();
string variable = items[3] as string;
if (variable != null)
{
field.Variable = variable;
}
string value = items[4] as string;
if (value != null)
{
field.Value = VariableConverter.INSTANCE.Convert(variable, value).ToString();
}
message.AddField(field);
}
}
if (message != null)
{
aStep.AddMessage(message);
importPackets(message, aStep.getTCS_Order());
}
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="window"></param>
/// <param name="step"></param>
/// <param name="runForBlockingExpectations"></param>
public ExecuteTestsHandler(Window window, Step step, bool runForBlockingExpectations)
{
Window = window;
Step = step;
RunForExpectations = runForBlockingExpectations;
}
/// <summary>
/// Imports the subsequence stored in the database
/// </summary>
/// <param name="frame"></param>
private void importInitialValues(DataDictionary.Tests.SubSequence subSequence, int subSequenceID)
{
// Level is a reserved word...
string sql = "SELECT D_LRBG, TSW_TestSeqSCItl.Level, Mode, NID_LRBG, Q_DIRLRBG, Q_DIRTRAIN, Q_DLRBG, RBC_ID, RBCPhone FROM TSW_TestSeqSCItl WHERE TestSequenceID = " + subSequenceID;
OleDbDataAdapter adapter = new OleDbDataAdapter(sql, Connection);
DataSet dataSet = new DataSet();
adapter.Fill(dataSet);
if (dataSet.Tables.Count > 0)
{
foreach (DataRow dataRow in dataSet.Tables[0].Rows)
{
int i = 0;
string D_LRBG = dataRow.ItemArray.GetValue(i++) as string;
string Level = dataRow.ItemArray.GetValue(i++) as string;
string Mode = dataRow.ItemArray.GetValue(i++) as string;
string NID_LRBG = dataRow.ItemArray.GetValue(i++) as string;
string Q_DIRLRBG = dataRow.ItemArray.GetValue(i++) as string;
string Q_DIRTRAIN = dataRow.ItemArray.GetValue(i++) as string;
string Q_DLRBG = dataRow.ItemArray.GetValue(i++) as string;
string RBC_ID = dataRow.ItemArray.GetValue(i++) as string;
string RBCPhone = dataRow.ItemArray.GetValue(i++) as string;
subSequence.setD_LRBG(D_LRBG);
subSequence.setLevel(Level);
subSequence.setMode(Mode);
subSequence.setNID_LRBG(NID_LRBG);
subSequence.setQ_DIRLRBG(Q_DIRLRBG);
subSequence.setQ_DIRTRAIN(Q_DIRTRAIN);
subSequence.setQ_DLRBG(Q_DLRBG);
subSequence.setRBC_ID(RBC_ID);
subSequence.setRBCPhone(RBCPhone);
DataDictionary.Tests.TestCase testCase = (DataDictionary.Tests.TestCase)DataDictionary.Generated.acceptor.getFactory().createTestCase();
testCase.Name = "Setup";
subSequence.appendTestCases(testCase);
DataDictionary.Tests.Step initializeTrainDataStep = (DataDictionary.Tests.Step)DataDictionary.Generated.acceptor.getFactory().createStep();;
initializeTrainDataStep.setTCS_Order(0);
initializeTrainDataStep.setDistance(0);
initializeTrainDataStep.setDescription("Initialize train data");
initializeTrainDataStep.setTranslationRequired(true);
testCase.appendSteps(initializeTrainDataStep);
DataDictionary.Tests.Step setupStep = (DataDictionary.Tests.Step)DataDictionary.Generated.acceptor.getFactory().createStep();;
setupStep.setTCS_Order(0);
setupStep.setDistance(0);
setupStep.setDescription("Setup test sequence");
setupStep.setTranslationRequired(true);
testCase.appendSteps(setupStep);
DataDictionary.Tests.Step manualSetupStep = (DataDictionary.Tests.Step)DataDictionary.Generated.acceptor.getFactory().createStep();;
manualSetupStep.setTCS_Order(0);
manualSetupStep.setDistance(0);
manualSetupStep.setDescription("Manual setup test sequence");
manualSetupStep.setTranslationRequired(true);
testCase.appendSteps(manualSetupStep);
}
}
else
{
Log.Error("Cannot find entry in table TSW_TestSeqSCItl WHERE TestSequenceID = " + subSequenceID);
}
}
private void intializeEFS(TestCase aTestCase, Workbook workbook)
{
Step aStep = new Step();
aStep.Name = "Step1 - Setup";
aTestCase.AddModelElement(aStep);
SubStep aSubStep = new SubStep();
aSubStep.Name = "SubStep1 - Setup";
aSubStep.setSkipEngine(true);
aStep.AddModelElement(aSubStep);
TestAction powerOn = new TestAction();
powerOn.ExpressionText = "Kernel.PowerOn <- True";
aSubStep.AddModelElement(powerOn);
TestAction modeInitialization = new TestAction();
modeInitialization.ExpressionText = "Kernel.Mode <- Mode.FS";
aSubStep.AddModelElement(modeInitialization);
TestAction levelInitialization = new TestAction();
levelInitialization.ExpressionText =
"Kernel.Level <- Kernel.LevelData\n{\n Value => LevelDataStruct { Value => Level.L1 },\n DataState => DataState.Valid\n}";
aSubStep.AddModelElement(levelInitialization);
TestAction odometryInitialization = new TestAction();
odometryInitialization.ExpressionText = "Odometry.NominalDistance <- 0.0";
aSubStep.AddModelElement(odometryInitialization);
TestAction LRBGInitialization = new TestAction();
LRBGInitialization.ExpressionText = "BTM.LRBG <- BTM.BaliseGroupStruct{\n" +
" NID => 0,\n" +
" Orientation => Default.Orientation.Nominal,\n" +
" Position => BTM.Position{\n" +
" Position => 0.0,\n" +
" UnderReadingAmountOdo => 0.0,\n" +
" OverReadingAmountOdo => 0.0\n" +
" },\n" +
" Timestamp => Default.DateAndTime{\n" +
" Year => 2012,\n" +
" Month => 12,\n" +
" Day => 20,\n" +
" Hour => 20,\n" +
" Minute => 12,\n" +
" Second => 20,\n" +
" TTS => 600\n" +
" }\n" +
"}";
aSubStep.AddModelElement(LRBGInitialization);
}
/// <summary>
/// Imports all the messages used by this step
/// </summary>
/// <param name="aStep"></param>
private void importStepMessages(DataDictionary.Tests.Step aStep)
{
string sql = "SELECT TCSOrder, MessageOrder, MessageType, Var_Name, Var_Value FROM TSW_MessageHeader ORDER BY MessageOrder, Var_Row";
OleDbDataAdapter adapter = new OleDbDataAdapter(sql, Connection);
DataSet dataSet = new DataSet();
adapter.Fill(dataSet);
if (dataSet.Tables.Count > 0)
{
int messageNumber = 0;
DataDictionary.Tests.DBElements.DBMessage message = null;
int order = -1;
foreach (DataRow dataRow in dataSet.Tables[0].Rows)
{
object[] items = dataRow.ItemArray;
order = (int)items[0];
if (order == aStep.getTCS_Order())
{
short messageOrder = (short)items[1];
if (messageNumber != messageOrder) // we create a new Message
{
if (messageNumber != 0)
{
aStep.AddMessage(message);
importPackets(message, order);
}
short messageTypeNumber = (short)items[2];
DataDictionary.Generated.acceptor.DBMessageType messageType = DataDictionary.Generated.acceptor.DBMessageType.defaultDBMessageType;
switch (messageTypeNumber)
{
case 0:
messageType = DataDictionary.Generated.acceptor.DBMessageType.aEUROBALISE;
break;
case 1:
messageType = DataDictionary.Generated.acceptor.DBMessageType.aEUROLOOP;
break;
case 2:
messageType = DataDictionary.Generated.acceptor.DBMessageType.aEURORADIO;
break;
}
message = (DataDictionary.Tests.DBElements.DBMessage)DataDictionary.Generated.acceptor.getFactory().createDBMessage();
message.MessageOrder = messageOrder;
message.MessageType = messageType;
messageNumber = messageOrder;
}
DataDictionary.Tests.DBElements.DBField field = (DataDictionary.Tests.DBElements.DBField)DataDictionary.Generated.acceptor.getFactory().createDBField();
string variable = items[3] as string;
if (variable != null)
{
field.Variable = variable;
}
string value = items[4] as string;
if (value != null)
{
field.Value = DataDictionary.Tests.Translations.Translation.format_decimal(value);
}
message.AddField(field);
}
}
if (message != null)
{
aStep.AddMessage(message);
importPackets(message, aStep.getTCS_Order());
}
}
}
private void verifyInputForLambda(TestCase aTestCase, Workbook workbook)
{
Step aStep = new Step();
aStep.Name = "Step1 - Verify input";
aTestCase.AddModelElement(aStep);
/*********************************** TRAIN DATA ***********************************/
SubStep aSubStep = new SubStep();
aSubStep.Name = "SubStep1 - Train data";
aStep.AddModelElement(aSubStep);
addAction(aSubStep, "Kernel.TrainData.BrakingParameters.ConversionModel.Initialize()");
addAction(aSubStep, "Kernel.SpeedAndDistanceMonitoring.ReleaseSpeedMonitoring.UpdateReleaseSpeed()");
addExpectation(aSubStep,
"Kernel.TrainData.BrakingParameters.ConversionModel.ConversionModelIsUsed() == True");
/********************************* BRAKE PARAMETERS *********************************/
aSubStep = new SubStep();
aSubStep.Name = "SubStep2 - Brake parameters";
aStep.AddModelElement(aSubStep);
Worksheet aWorksheet = workbook.Sheets[5] as Worksheet;
Range aRange = aWorksheet.UsedRange;
addAction(aSubStep, "Kernel.SpeedAndDistanceMonitoring.TargetSpeedMonitoring.InitializeTimeIntervals()");
/* Verifying kto */
addExpectation(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.TrainData.BrakingParameters.ConversionModel.kto() == {0:0.0#}",
(double)(aRange.Cells[7, 6] as Range).Value2));
if (TargetSpeed == 0)
/* In this case, the values of T_brake_emergency_cmt and T_brake_service_cmt do not make sense (3.13.3.4.4.1) */
{
/* Verifying T_brake_emergency_cm0 */
addExpectation(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.TrainData.BrakingParameters.ConversionModel.T_brake_emergency_cm0 == {0:0.0#}",
(double)(aRange.Cells[8, 6] as Range).Value2));
/* Verifying T_brake_service_cm0 */
addExpectation(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.TrainData.BrakingParameters.ConversionModel.T_brake_service_cm0 == {0:0.0#}",
(double)(aRange.Cells[10, 6] as Range).Value2));
}
else
/* In this case, the values of T_brake_emergency_cm0 and T_brake_service_cm0 do not make sense (3.13.3.4.4.1) */
{
/* Verifying T_brake_emergency_cmt */
addExpectation(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.TrainData.BrakingParameters.ConversionModel.T_brake_emergency_cmt == {0:0.0#}",
(double)(aRange.Cells[9, 6] as Range).Value2));
/* Verifying T_brake_service_cmt */
addExpectation(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"Kernel.TrainData.BrakingParameters.ConversionModel.T_brake_service_cmt == {0:0.0#}",
(double)(aRange.Cells[11, 6] as Range).Value2));
}
/* Verifying T_be */
addExpectation(aSubStep,
String.Format(CultureInfo.InvariantCulture, "Kernel.TrainData.BrakingParameters.T_be() == {0:0.0#}",
(double)(aRange.Cells[12, 6] as Range).Value2));
/* Verifying T_bs */
addExpectation(aSubStep,
String.Format(CultureInfo.InvariantCulture, "Kernel.TrainData.BrakingParameters.T_bs() == {0:0.0#}",
(double)(aRange.Cells[13, 6] as Range).Value2));
/********************* BRAKE PARAMETERS (A_brake_emergency) *********************/
aSubStep = new SubStep();
aSubStep.Name = "SubStep3 - Brake parameters (A_brake_emergency)";
aStep.AddModelElement(aSubStep);
/* Verifying A_brake_emergency */
double doubleValue = -1;
double temp;
for (int i = 16; i <= 27; i++)
{
temp = (double)(aRange.Cells[i, 10] as Range).Value2;
if (doubleValue != temp)
{
if (doubleValue != -1)
{
addExpectation(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"ERA_BrakingCurvesVerification.Compare\n(\n Val1 => Kernel.TrainData.BrakingParameters.ConversionModel.A_brake_emergency(V => {0:0.0########}),\n Val2 => {1:0.0########}\n)",
(double)(aRange.Cells[i, 9] as Range).Value2 - 0.000000001, doubleValue));
}
doubleValue = temp;
double speedValue = (double)(aRange.Cells[i, 9] as Range).Value2;
if (Math.Abs(speedValue - Math.Round(speedValue, 8)) > 0)
{
speedValue += 0.000000001;
}
addExpectation(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"ERA_BrakingCurvesVerification.Compare\n(\n Val1 => Kernel.TrainData.BrakingParameters.ConversionModel.A_brake_emergency(V => {0:0.0########}),\n Val2 => {1:0.0########}\n)",
speedValue, doubleValue));
}
}
/* Verifying V_lim EBI */
addExpectation(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"ERA_BrakingCurvesVerification.Compare\n(\n Val1 => Kernel.TrainData.BrakingParameters.ConversionModel.A_brake_emergency.Val1.SpeedStep,\n Val2 => {0:0.0########}\n)",
(double)(aRange.Cells[17, 9] as Range).Value2));
/*********************** BRAKE PARAMETERS (A_brake_service) ***********************/
aSubStep = new SubStep();
aSubStep.Name = "SubStep4 - Brake parameters (A_brake_service)";
aStep.AddModelElement(aSubStep);
/* Verifying A_brake_service */
doubleValue = -1;
for (int i = 16; i <= 27; i++)
{
temp = (double)(aRange.Cells[i, 14] as Range).Value2;
if (doubleValue != temp)
{
if (doubleValue != -1)
{
addExpectation(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"ERA_BrakingCurvesVerification.Compare\n(\n Val1 => Kernel.TrainData.BrakingParameters.ConversionModel.A_brake_service(V => {0:0.0########}),\n Val2 => {1:0.0########}\n)",
(double)(aRange.Cells[i, 13] as Range).Value2 - 0.000000001, doubleValue));
}
doubleValue = temp;
double speedValue = (double)(aRange.Cells[i, 13] as Range).Value2;
if (Math.Abs(speedValue - Math.Round(speedValue, 8)) > 0)
{
speedValue += 0.000000001;
}
addExpectation(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"ERA_BrakingCurvesVerification.Compare\n(\n Val1 => Kernel.TrainData.BrakingParameters.ConversionModel.A_brake_service(V => {0:0.0########}),\n Val2 => {1:0.0########}\n)",
speedValue, doubleValue));
}
}
/* Verifying V_lim BS */
addExpectation(aSubStep,
String.Format(CultureInfo.InvariantCulture,
"ERA_BrakingCurvesVerification.Compare\n(\n Val1 => Kernel.TrainData.BrakingParameters.ConversionModel.A_brake_service.Val1.SpeedStep,\n Val2 => {0:0.0########}\n)",
(double)(aRange.Cells[17, 13] as Range).Value2));
}
