示例#1
0
        /// <summary>
        /// Counts the issues and the blocking issues
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="visitSubNodes"></param>
        public override void visit(Generated.ReferencesParagraph obj, bool visitSubNodes)
        {
            ReferencesParagraph referencesParagraph = obj as ReferencesParagraph;

            if (referencesParagraph != null)
            {
                foreach (ReqRef reqRef in referencesParagraph.Requirements)
                {
                    IssueKind?kind = IssueKindUtil.GetKind(reqRef.Paragraph);
                    if (kind != null)
                    {
                        Issues[(IssueKind)kind] += 1;
                        if (kind == IssueKind.Blocking)
                        {
                            SubSequence enclosingSubSequence = EnclosingFinder <SubSequence> .find(referencesParagraph,
                                                                                                   true);

                            if (enclosingSubSequence != null)
                            {
                                BlockingSubSequences.Add(enclosingSubSequence);
                            }
                        }
                    }
                }
            }

            base.visit(obj, visitSubNodes);
        }
示例#2
0
            /// <summary>
            ///     Executes the tests in the background thread
            /// </summary>
            public override void ExecuteWork()
            {
                if (Window != null)
                {
                    SynchronizerList.SuspendSynchronization();
                    MarkingHistory.PerformMark(() =>
                    {
                        SubSequence subSequence = TestCase.Enclosing as SubSequence;
                        if (subSequence != null && TestCase.Steps.Count > 0)
                        {
                            Step step  = null;
                            bool found = false;
                            foreach (TestCase current in subSequence.TestCases)
                            {
                                if (found && current.Steps.Count > 0)
                                {
                                    step = (Step)current.Steps[0];
                                    break;
                                }

                                found = (current == TestCase);
                            }

                            Runner runner = Window.GetRunner(subSequence);
                            runner.RunUntilStep(step);
                        }
                    });
                    SynchronizerList.ResumeSynchronization();
                }
            }
示例#3
0
        /// <summary>
        ///     Creates a section for a given sub-sequence
        /// </summary>
        /// <param name="aSubSequence">A sub-sequence to be displayed</param>
        /// <param name="aReportConfig">The report configuration containing display details</param>
        /// <param name="activatedRules">The list that will contain the rules activated by this sub-sequence</param>
        /// <param name="createPdf">Indicates if the information about this sub-sequence has to be added to the pdf</param>
        public void CreateSubSequenceSection(SubSequence aSubSequence, TestsCoverageReportHandler aReportConfig,
                                             HashSet <RuleCondition> activatedRules, bool createPdf)
        {
            string title = "Sub sequence " + aSubSequence.Name;

            if (createPdf)
            {
                AddSubParagraph(title);
            }

            HashSet <RuleCondition> rules = new HashSet <RuleCondition>();

            aSubSequence.EFSSystem.Runner = new Runner(aSubSequence, false, true);
            foreach (TestCase testCase in aSubSequence.TestCases)
            {
                // SIDE EFFECT:
                // each test case will calculate the list of rules it activates
                // and add them to activatedRules list
                CreateTestCaseSection(aSubSequence.EFSSystem.Runner, testCase, aReportConfig, rules,
                                      createPdf && aReportConfig.AddTestCases);
            }
            activatedRules.UnionWith(rules);

            // now we  can create the table with the current sub sequence statistics
            if (createPdf)
            {
                CreateActivatedRulesSection(title,
                                            rules,
                                            aReportConfig.Dictionary.ImplementedRules,
                                            aReportConfig.AddActivatedRulesInSubSequences);

                CloseSubParagraph();
            }
        }
示例#4
0
        /// <summary>
        ///     Allows to refresh the view, when the selected model changed
        /// </summary>
        /// <param name="context"></param>
        /// <returns>true if refresh should be performed</returns>
        public override bool HandleSelectionChange(Context.SelectionContext context)
        {
            bool retVal = base.HandleSelectionChange(context);

            if (retVal)
            {
                SubSequence subSequence = DisplayedModel as SubSequence;
                if (subSequence != null)
                {
                    testDescriptionTimeLineControl.SubSequence = subSequence;
                    testDescriptionTimeLineControl.Refresh();
                    tabControl1.SelectedTab = testDescriptionTabPage;
                }

                TestCase testCase = DisplayedModel as TestCase;
                if (testCase != null)
                {
                    testDescriptionTimeLineControl.TestCase = testCase;
                    testDescriptionTimeLineControl.Refresh();
                    tabControl1.SelectedTab = testDescriptionTabPage;
                }
            }

            return(retVal);
        }
示例#5
0
        /// <summary>
        /// Updates an expression according to translation rules
        /// </summary>
        /// <param name="step">the step in which the expression occurs</param>
        /// <param name="expression"></param>
        /// <returns>the updated string</returns>
        private string ReviewExpression(Step step, string expression)
        {
            string retVal = expression;

            if (expression.IndexOf('%') >= 0)
            {
                SubSequence subSequence = step.TestCase.SubSequence;

                retVal = retVal.Replace("%D_LRBG", format_decimal_as_str(subSequence.getD_LRBG()));
                retVal = retVal.Replace("%Level", format_level(subSequence.getLevel()));
                retVal = retVal.Replace("%Mode", format_mode(subSequence.getMode()));
                retVal = retVal.Replace("%NID_LRBG", format_decimal_as_str(subSequence.getNID_LRBG()));
                retVal = retVal.Replace("%Q_DIRLRBG", format_decimal_as_str(subSequence.getQ_DIRLRBG()));
                retVal = retVal.Replace("%Q_DIRTRAIN", format_decimal_as_str(subSequence.getQ_DIRTRAIN()));
                retVal = retVal.Replace("%Q_DLRBG", format_decimal_as_str(subSequence.getQ_DLRBG()));
                retVal = retVal.Replace("%RBC_ID", format_decimal_as_str(subSequence.getRBC_ID()));
                retVal = retVal.Replace("%RBCPhone", format_str(subSequence.getRBCPhone()));

                retVal = retVal.Replace("%Step_Distance", step.getDistance() + "");
                retVal = retVal.Replace("%Step_LevelIN", format_level(step.getLevelIN()));
                retVal = retVal.Replace("%Step_LevelOUT", format_level(step.getLevelOUT()));
                retVal = retVal.Replace("%Step_ModeIN", format_mode(step.getModeOUT()));
                retVal = retVal.Replace("%Step_ModeOUT", format_mode(step.getModeOUT()));
                for (int i = 0; i < step.StepMessages.Count; i++)
                {
                    DBElements.DBMessage message = step.StepMessages[i] as DBElements.DBMessage;
                    if (message != null)
                    {
                        retVal = retVal.Replace("%Step_Messages_" + i, format_message(message));
                    }
                }
            }

            return(retVal);
        }
示例#6
0
        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="subSequence"></param>
        /// <param name="explain"></param>
        /// <param name="ensureCompilation">Indicates that the runner should make sure that the system is compiled</param>
        /// <param name="checkForCompatibleChanges">Indicates that the runner should check that no variables are accessed twice during the same cycle</param>
        public Runner(SubSequence subSequence, bool explain, bool ensureCompilation, bool checkForCompatibleChanges = false)
        {
            EventTimeLine             = new EventTimeLine(this);
            SubSequence               = subSequence;
            CompletedSubStep          = new HashSet <SubStep>();
            EfsSystem.Instance.Runner = this;
            Explain = explain;
            CheckForCompatibleChanges = checkForCompatibleChanges;

            if (ensureCompilation)
            {
                // Compile everything
                EfsSystem.Instance.Compiler.Compile_Synchronous(EfsSystem.Instance.ShouldRebuild);
                EfsSystem.Instance.ShouldRebuild = false;
            }

            Setup();
            PleaseWait = true;

            Expression expression = new Parser().Expression(subSequence.Dictionary, "Kernel.DateAndTime.CurrentTime");

            TimeInModel = expression.GetVariable(new InterpretationContext());
            Range range = TimeInModel.Type as Range;

            if (range == null || range.getPrecision() != acceptor.PrecisionEnum.aDoublePrecision)
            {
                TimeInModel = null;
            }
        }
 /// <summary>
 ///     Constructor: creates a report for the selected sub sequence
 /// </summary>
 /// <param name="aSubSequence"></param>
 public TestReport(SubSequence aSubSequence)
 {
     InitializeComponent();
     _reportHandler = new TestsCoverageReportHandler(aSubSequence.Dictionary) {SubSequence = aSubSequence};
     InitializeCheckBoxes(2);
     TxtB_Path.Text = _reportHandler.FileName;
 }
示例#8
0
 /// <summary>
 ///     Sets the current sub sequence window parameters
 /// </summary>
 /// <param name="subSequence"></param>
 public void SetSubSequence(SubSequence subSequence)
 {
     Invoke((MethodInvoker) delegate
     {
         subSequenceSelectorComboBox.Text = subSequence.Name;
         SetFrame(subSequence.Frame);
         Refresh();
     });
 }
示例#9
0
 /// <summary>
 ///     Constructor: creates a report for the selected sub sequence
 /// </summary>
 /// <param name="aSubSequence"></param>
 public TestReport(SubSequence aSubSequence)
 {
     InitializeComponent();
     _reportHandler = new TestsCoverageReportHandler(aSubSequence.Dictionary)
     {
         SubSequence = aSubSequence
     };
     InitializeCheckBoxes(2);
     TxtB_Path.Text = _reportHandler.FileName;
 }
示例#10
0
        private static string LcsUnConsecutiveUsingTable(string s1, int s1End, string s2, int s2End,
                                                         ref Dictionary <SubSequence, string> calculated)
        {
            if (s1End < 0 || s2End < 0)
            {
                return(string.Empty);
            }

            if (s1[s1End] == s2[s2End])
            {
                SubSequence sub = new SubSequence(s1End - 1, s2End - 1);

                if (calculated.ContainsKey(sub))
                {
                    //the sub problem is calculated
                    string result = calculated[sub] + s1[s1End];
                    // add current problem to table
                    calculated[new SubSequence(s1End, s2End)] = result;
                    return(result);
                }
                else
                {
                    //the sub problem is not calculated
                    string result = LcsUnConsecutiveUsingTable(s1, s1End - 1, s2, s2End - 1, ref calculated);
                    //add sub problem to the table
                    calculated[sub] = result;
                    result         += s1[s1End];
                    //add current problem to the table
                    calculated[new SubSequence(s1End, s2End)] = result;
                    return(result);
                }
            }
            else
            {
                SubSequence sub1 = new SubSequence(s1End - 1, s2End);
                SubSequence sub2 = new SubSequence(s1End, s2End - 1);

                string t1 = calculated.ContainsKey(sub1) ? calculated[sub1] : LcsUnConsecutiveUsingTable(s1, s1End - 1, s2, s2End, ref calculated);
                string t2 = calculated.ContainsKey(sub2) ? calculated[sub2] : LcsUnConsecutiveUsingTable(s1, s1End, s2, s2End - 1, ref calculated);

                if (t1.Length > t2.Length)
                {
                    calculated[sub1] = t1;
                    calculated[new SubSequence(s1End, s2End)] = t1;
                    return(t1);
                }
                else
                {
                    calculated[sub2] = t2;
                    calculated[new SubSequence(s1End, s2End)] = t2;
                    return(t2);
                }
            }
        }
示例#11
0
 /// <summary>
 ///     Selects the current test sequence by clicking on the label
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 private void toolStripLabel2_Click(object sender, EventArgs e)
 {
     if (EfsSystem.Runner != null)
     {
         SubSequence subSequence = EfsSystem.Runner.SubSequence;
         if (subSequence != null)
         {
             EfsSystem.Instance.Context.SelectElement(subSequence, this, Context.SelectionCriteria.DoubleClick);
         }
     }
 }
示例#12
0
        /// <summary>
        ///     Updates an expression according to translation rules
        /// </summary>
        /// <param name="step">the step in which the expression occurs</param>
        /// <param name="expression"></param>
        /// <returns>the updated string</returns>
        private string ReviewExpression(Step step, string expression)
        {
            string retVal = expression;

            if (expression.IndexOf('%') >= 0)
            {
                SubSequence subSequence = step.TestCase.SubSequence;

                retVal = retVal.Replace("%D_LRBG", format_decimal_as_str(subSequence.getD_LRBG()));
                retVal = retVal.Replace("%Level", format_level(subSequence.getLevel()));
                retVal = retVal.Replace("%Mode", format_mode(subSequence.getMode()));
                retVal = retVal.Replace("%NID_LRBG", format_decimal_as_str(subSequence.getNID_LRBG()));
                retVal = retVal.Replace("%Q_DIRLRBG", format_decimal_as_str(subSequence.getQ_DIRLRBG()));
                retVal = retVal.Replace("%Q_DIRTRAIN", format_decimal_as_str(subSequence.getQ_DIRTRAIN()));
                retVal = retVal.Replace("%Q_DLRBG", format_decimal_as_str(subSequence.getQ_DLRBG()));
                retVal = retVal.Replace("%RBC_ID", format_decimal_as_str(subSequence.getRBC_ID()));
                retVal = retVal.Replace("%RBCPhone", format_str(subSequence.getRBCPhone()));

                retVal = retVal.Replace("%Step_Distance", step.getDistance() + "");
                retVal = retVal.Replace("%Step_LevelIN", format_level(step.getLevelIN()));
                retVal = retVal.Replace("%Step_LevelOUT", format_level(step.getLevelOUT()));
                retVal = retVal.Replace("%Step_ModeIN", format_mode(step.getModeOUT()));
                retVal = retVal.Replace("%Step_ModeOUT", format_mode(step.getModeOUT()));

                int max_step_messages = 8;
                for (int i = 0; i < max_step_messages; i++)
                {
                    if (retVal.IndexOf("%Step_Messages_" + i) >= 0)
                    {
                        if (step.StepMessages.Count > i)
                        {
                            DBMessage message = step.StepMessages[i] as DBMessage;
                            if (message != null)
                            {
                                retVal = retVal.Replace("%Step_Messages_" + i, format_message(message));
                            }
                        }
                        else
                        {
                            retVal = retVal.Replace("%Step_Messages_" + i, format_default_message(expression));
                        }
                    }
                }

                if (retVal.IndexOf("%") > 0)
                {
                    step.AddError("Cannot completely translate this step");
                }
            }

            return(retVal);
        }
示例#13
0
        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="subSequence"></param>
        public Runner(SubSequence subSequence)
        {
            EventTimeLine    = new Events.EventTimeLine();
            SubSequence      = subSequence;
            EFSSystem.Runner = this;

            // Compile everything
            Interpreter.Compiler compiler = new Interpreter.Compiler(EFSSystem, EFSSystem.ShouldRebuild);
            compiler.Compile();
            EFSSystem.ShouldRebuild = false;

            Setup();
        }
示例#14
0
        /// <summary>
        ///     The runner
        /// </summary>
        public Runner GetRunner(SubSequence subSequence)
        {
            Runner runner = EfsSystem.Runner;

            if (runner == null || runner.SubSequence != subSequence)
            {
                if (subSequence != null)
                {
                    EfsSystem.Runner = new Runner(subSequence, true, true, Settings.Default.CheckForCompatibleChanges);
                }
            }

            return(EfsSystem.Runner);
        }
示例#15
0
        public override void visit(SubSequence obj, bool visitSubNodes)
        {
            obj.setD_LRBG("");
            obj.setLevel("");
            obj.setMode("");
            obj.setNID_LRBG("");
            obj.setQ_DIRLRBG("");
            obj.setQ_DIRTRAIN("");
            obj.setQ_DLRBG("");
            obj.setRBC_ID("");
            obj.setRBCPhone("");
            obj.setCompleted(true);

            base.visit(obj, visitSubNodes);
        }
示例#16
0
 /// <summary>
 ///     Ensures that the runner is not empty
 /// </summary>
 private void CheckRunner()
 {
     if (EfsSystem.Runner == null)
     {
         if (Frame != null)
         {
             SubSequence subSequence = Frame.findSubSequence(subSequenceSelectorComboBox.Text);
             if (subSequence != null)
             {
                 EfsSystem.Runner = new Runner(subSequence, true, true, Settings.Default.CheckForCompatibleChanges);
             }
         }
         else
         {
             EfsSystem.Runner = EFSService.Instance.Runner;
         }
     }
 }
        public static void Main()
        {
            var logger = new ConsoleLogger();
            var reader = new ConsoleReader();

            // ============================================================================
            // Task 1. Sum of subsequences.
            var pr = new SubSequence(logger);

            pr.Calculate(reader);

            /*
             * Test 1.
             *  4 2
             *  numbers => 1 2 3 4
             *  result = 30
             *
             *  Test 2.
             *  5 3
             *  numbers => 1 –5 7 10 –3
             *  result 40
             */

            // ============================================================================
            // Task 2. (firstNumber + secondNumber) ^ n
            var binominal = new Binominal();

            binominal.Start(reader, logger);

            /*
             * Test 1.
             *  (a+z)
             *  1
             *  result => (a^1)+(z^1)
             *
             *  Test 2.
             *  (c+y)
             *  3
             *  result => (c^3)+3(c^2)(y^1)+3(c^1)(y^2)+(y^3)
             *
             */
        }
示例#18
0
        static void Main()
        {
            // Get Sum
            int inputSum = int.Parse(Console.ReadLine());

            // standard input format = size + fill array
            int sizeN = int.Parse(Console.ReadLine());

            //Get Array
            int[] inputArray = new int[sizeN];

            for (int i = 0; i < sizeN; i++)
            {
                inputArray[i] = int.Parse(Console.ReadLine());
            }

            // Get sub sequences
            var findTheSum =

                // Divide into subsequences !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
                from startAt in Enumerable.Range(0, inputArray.Length)
                from length in Enumerable.Range(1, inputArray.Length - startAt)

                let SubSequence = inputArray.Skip(startAt).Take(length)
                                  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

                                  orderby SubSequence.Count() descending
                                  //filter
                                      where SubSequence.Sum() == inputSum
                                  //return subsequences
                                  select SubSequence;

            var ResultSubseq = findTheSum.First();


            foreach (var value in ResultSubseq)
            {
                Console.Write(value.ToString() + " ");
            }

            Console.Write(ResultSubseq.Sum());
        }
示例#19
0
        /// <summary>
        /// Counts the number of sub sequences
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="visitSubNodes"></param>
        public override void visit(Generated.SubSequence obj, bool visitSubNodes)
        {
            SubSequences += 1;

            SubSequence subSequence = obj as SubSequence;

            if (subSequence != null)
            {
                if (subSequence.getCompleted())
                {
                    CompletedSubSequences.Add(subSequence);
                }
                else
                {
                    OngoingSubSequences.Add(subSequence);
                }
            }

            base.visit(obj, visitSubNodes);
        }
示例#20
0
        public void TestMoveBugReport568()
        {
            Dictionary test       = CreateDictionary("Test");
            NameSpace  namespace1 = CreateNameSpace(test, "Kernel");
            NameSpace  nameSpace2 = CreateNameSpace(namespace1, "MA");
            Function   function1  = CreateFunction(nameSpace2, "SpeedRestriction", "Boolean");
            NameSpace  nameSpace3 = CreateNameSpace(namespace1, "MRSP");
            Function   function2  = CreateFunction(nameSpace3, "SpeedRestriction", "Boolean");

            Frame       frame        = CreateTestFrame(test, "frame");
            SubSequence subSequence  = CreateSubSequence(frame, "subsequence");
            TestCase    testCase     = CreateTestCase(subSequence, "TestCase");
            Step        step         = CreateStep(testCase, "Step");
            SubStep     subStep      = CreateSubStep(step, "SubStep");
            Expectation expectation  = CreateExpectation(subStep, "Kernel.MA.SpeedRestriction()");
            Expectation expectation2 = CreateExpectation(subStep,
                                                         "MIN(Kernel.MA.SpeedRestriction, Kernel.MRSP.SpeedRestriction)");

            Refactor(function1, "SpeedRestriction");

            Assert.AreEqual("Kernel.MA.SpeedRestriction()", expectation.ExpressionText);
            Assert.AreEqual("MIN(Kernel.MA.SpeedRestriction, Kernel.MRSP.SpeedRestriction)", expectation2.ExpressionText);
        }
        /// <summary>
        /// Creates a section for a given sub sequence
        /// </summary>
        /// <param name="aFrame">Frame to be displayed</param>
        /// <param name="aReportConfig">The report configuration containing display details</param>
        /// <param name="activatedRules">The list that will contain the rules activated by this sub sequence</param>
        /// <returns></returns>
        public void CreateSubSequenceSection(SubSequence aSubSequence, TestsCoverageReportHandler aReportConfig, HashSet <RuleCondition> activatedRules, bool createPdf)
        {
            AddSubParagraph("Sub sequence " + aSubSequence.Name);

            HashSet <RuleCondition> rules = new HashSet <RuleCondition>();

            aSubSequence.EFSSystem.Runner = new DataDictionary.Tests.Runner.Runner(aSubSequence);
            foreach (TestCase testCase in aSubSequence.TestCases)
            {
                // each test case will calculate the list of rules it activate
                // and add them to activatedRules list
                CreateTestCaseSection(aSubSequence.EFSSystem.Runner, testCase, aReportConfig, rules, createPdf && aReportConfig.AddTestCases);
            }

            // now we  can create the table with the current sub sequence statistics
            CreateTable(aSubSequence.Name,
                        rules,
                        aReportConfig.Dictionary.ImplementedRules,
                        aReportConfig.AddActivatedRulesInSubSequences,
                        aReportConfig.AddNonCoveredRulesInSubSequences);

            activatedRules.UnionWith(rules);
            CloseSubParagraph();
        }
示例#22
0
        /// <summary>
        ///     The runner
        /// </summary>
        public Runner GetRunner(SubSequence subSequence)
        {
            Runner runner = EfsSystem.Runner;

            if (runner == null || runner.SubSequence != subSequence)
            {
                if (subSequence != null)
                {
                    EfsSystem.Runner = new Runner(subSequence, false, true);
                }
            }

            return EfsSystem.Runner;
        }
示例#23
0
        /// <summary>
        ///     Build the model of this tree view
        /// </summary>
        /// <returns>the root nodes of the tree</returns>
        protected override List <BaseTreeNode> BuildModel()
        {
            List <BaseTreeNode> retVal = new List <BaseTreeNode>();

            ModelElement model = Root as ModelElement;

            if (model != null && model != _previousModel)
            {
                _previousModel = model;

                UsageTreeNode models = new UsageTreeNode("Model", true);
                models.SetImageIndex(false);
                models.SubNodesBuilt = true;
                retVal.Add(models);

                UsageTreeNode tests = new UsageTreeNode("Test", true);
                tests.SetImageIndex(false);
                tests.SubNodesBuilt = true;
                retVal.Add(tests);

                foreach (Usage usage in model.EFSSystem.FindReferences(model))
                {
                    UsageTreeNode current = new UsageTreeNode(usage, true);
                    current.SetImageIndex(false);

                    NameSpace nameSpace = EnclosingFinder <NameSpace> .find(usage.User, true);

                    Frame frame = EnclosingFinder <Frame> .find(usage.User, true);

                    if (nameSpace != null)
                    {
                        List <NameSpace> nameSpaces = new List <NameSpace>();
                        while (nameSpace != null)
                        {
                            nameSpaces.Insert(0, nameSpace);
                            nameSpace = EnclosingFinder <NameSpace> .find(nameSpace);
                        }

                        UsageTreeNode currentTreeNode = models;
                        foreach (NameSpace currentNameSpace in nameSpaces)
                        {
                            currentTreeNode = FindOrCreateFolderNode(currentTreeNode, currentNameSpace);
                        }
                        currentTreeNode.Nodes.Add(current);
                    }
                    else if (frame != null)
                    {
                        UsageTreeNode currentNode = FindOrCreateFolderNode(tests, frame);
                        SubSequence   subSequence = EnclosingFinder <SubSequence> .find(usage.User, true);

                        if (subSequence != null)
                        {
                            currentNode = FindOrCreateFolderNode(currentNode, subSequence);
                        }
                        currentNode.Nodes.Add(current);
                    }
                    else
                    {
                        retVal.Add(current);
                    }
                }

                Sort();
                models.ExpandAll();
                tests.ExpandAll();
            }
            else
            {
                foreach (BaseTreeNode node in Nodes)
                {
                    retVal.Add(node);
                }
            }

            return(retVal);
        }
示例#24
0
        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="subSequence"></param>
        public Runner(SubSequence subSequence)
        {
            EventTimeLine = new Events.EventTimeLine();
            SubSequence = subSequence;
            EFSSystem.Runner = this;

            // Compile everything
            Interpreter.Compiler compiler = new Interpreter.Compiler(EFSSystem, EFSSystem.ShouldRebuild);
            compiler.Compile();
            EFSSystem.ShouldRebuild = false;

            Setup();
        }
示例#25
0
        /// <summary>
        /// Activates the rules in the dictionary until stabilisation
        /// </summary>
        public void Cycle()
        {
            try
            {
                DataDictionary.Generated.ControllersManager.NamableController.DesactivateNotification();

                LastActivationTime = Time;

                Utils.ModelElement.ErrorCount = 0;

                foreach (Generated.acceptor.RulePriority priority in PRIORITIES_ORDER)
                {
                    // Clears the cache of functions
                    FunctionCacheCleaner.ClearCaches();

                    // Activates the processing engine
                    HashSet <Activation> activations = new HashSet <Activation>();
                    foreach (DataDictionary.Dictionary dictionary in EFSSystem.Dictionaries)
                    {
                        foreach (DataDictionary.Types.NameSpace nameSpace in dictionary.NameSpaces)
                        {
                            SetupNameSpaceActivations(priority, activations, nameSpace);
                        }
                    }

                    ApplyActivations(activations);
                }
                // Clears the cache of functions
                FunctionCacheCleaner.ClearCaches();

                if (Utils.ModelElement.ErrorCount > 0)
                {
                    SubStep subStep = CurrentSubStep();
                    if (subStep != null)
                    {
                        subStep.AddError("Errors were raised while evaluating this sub step. See model view for more informations");
                    }
                    else
                    {
                        Step step = CurrentStep();
                        if (step != null)
                        {
                            step.AddError("Errors were raised while evaluating this step. See model view for more informations");
                        }
                        else
                        {
                            TestCase testCase = CurrentTestCase();
                            if (testCase != null)
                            {
                                testCase.AddError("Errors were raised while evaluating this test case. See model view for more informations");
                            }
                            else
                            {
                                SubSequence.AddError("Errors were raised while evaluating this sub sequence. See model view for more informations");
                            }
                        }
                    }
                }
            }
            finally
            {
                DataDictionary.Generated.ControllersManager.NamableController.ActivateNotification();
            }

            EventTimeLine.CurrentTime += Step;
        }
示例#26
0
 /// <summary>
 ///     Sets the current sub sequence window parameters
 /// </summary>
 /// <param name="subSequence"></param>
 public void SetSubSequence(SubSequence subSequence)
 {
     Invoke((MethodInvoker) delegate
     {
         subSequenceSelectorComboBox.Text = subSequence.Name;
         SetFrame(subSequence.Frame);
         Refresh();
     });
 }
        // The sheets of the workbook are:                       \\
        //                                                       \\
        // Sheet number 1,  name: Train (main)                   \\
        // Sheet number 2,  name: Track                          \\
        // Sheet number 3,  name: National values                \\
        // Sheet number 4,  name: Fixed values                   \\
        // Sheet number 5,  name: Brake parameters (lambda)      \\  L
        // Sheet number 6,  name: Brake parameters (gamma)       \\  G
        // Sheet number 7,  name: Correction factor Kdry_rst     \\  G
        // Sheet number 8,  name: Integrated correction factors  \\  L
        // Sheet number 9,  name: Lambda train deceleration      \\  L
        // Sheet number 10, name: Gamma train deceleration       \\  G
        // Sheet number 11, name: Curves Gamma train             \\  G
        // Sheet number 12, name: Calc Gamma                     \\  G (hidden)
        // Sheet number 13, name: Curves Lambda train            \\  L
        // Sheet number 14, name: Calc Lambda                    \\  L (hidden)
        /// <summary>
        /// Launches import of the excel file in the background task
        /// </summary>
        /// <param name="arg"></param>
        public override void ExecuteWork()
        {
            if (TheDictionary != null)
            {
                Microsoft.Office.Interop.Excel.Application application = new Microsoft.Office.Interop.Excel.Application();
                if (application != null)
                {
                    Workbook workbook = application.Workbooks.Open(FileName);
                    Worksheet trainData = workbook.Sheets[1] as Worksheet;
                    Range aRange = trainData.UsedRange;
                    string trainTypeName = (string)(aRange.Cells[14, 4] as Range).Value2;
                    bool trainIsGamma = false;
                    if (trainTypeName.Equals("Gamma"))
                    {
                        trainIsGamma = true;
                    }
                    else if (!trainTypeName.Equals("Lambda"))
                    {
                        new Exception("Unknown train type");
                    }

                    Frame newFrame = new Frame();
                    newFrame.Name = FrameName;
                    newFrame.setCycleDuration("Kernel.CycleDuration");
                    TheDictionary.AddModelElement(newFrame);

                    SubSequence newSubSequence = new SubSequence();
                    newSubSequence.Name = FrameName;
                    newFrame.AddModelElement(newSubSequence);

                    TestCase aTestCase = new TestCase();
                    aTestCase.Name = "Setup";
                    aTestCase.NeedsRequirement = false;
                    newSubSequence.AddModelElement(aTestCase);

                    intializeEFS(aTestCase, workbook);

                    aTestCase = new TestCase();
                    aTestCase.Name = "Initialize input";
                    aTestCase.NeedsRequirement = false;
                    newSubSequence.AddModelElement(aTestCase);
                    if (trainIsGamma)
                    {
                        initializeInputForGamma(aTestCase, workbook);
                    }
                    else
                    {
                        initializeInputForLambda(aTestCase, workbook);
                    }

                    aTestCase = new TestCase();
                    aTestCase.Name = "Verify input";
                    aTestCase.NeedsRequirement = false;
                    newSubSequence.AddModelElement(aTestCase);
                    if (trainIsGamma)
                    {
                        verifyInputForGamma(aTestCase, workbook);
                    }
                    else
                    {
                        verifyInputForLambda(aTestCase, workbook);
                    }

                    aTestCase = new TestCase();
                    aTestCase.Name = "Verify output";
                    aTestCase.NeedsRequirement = false;
                    newSubSequence.AddModelElement(aTestCase);
                    verifyOutputForTrains(trainIsGamma, aTestCase, workbook);
                }
                else
                {
                    Log.ErrorFormat("Error while opening the excel file");
                }
                application.Quit();
            }
            else
            {
                if (TheStep != null)
                {
                    //importExpectations(workbook);
                }
                else
                {
                    Log.ErrorFormat("The import config is not properly initialized");
                }
            }
        }
 /// <summary>
 ///     Constructor: creates a report for the selected sub sequence
 /// </summary>
 /// <param name="aSubSequence"></param>
 public TestReport(SubSequence aSubSequence)
 {
     InitializeComponent();
     EFSSystem = aSubSequence.EFSSystem;
     reportHandler = new TestsCoverageReportHandler(aSubSequence.Dictionary);
     reportHandler.SubSequence = aSubSequence;
     InitializeCheckBoxes(2);
     TxtB_Path.Text = reportHandler.FileName;
 }
        /// <summary>
        /// Creates a section for a given sub sequence
        /// </summary>
        /// <param name="aFrame">Frame to be displayed</param>
        /// <param name="aReportConfig">The report configuration containing display details</param>
        /// <param name="activatedRules">The list that will contain the rules activated by this sub sequence</param>
        /// <returns></returns>
        public void CreateSubSequenceSection(SubSequence aSubSequence, TestsCoverageReportHandler aReportConfig, HashSet<RuleCondition> activatedRules, bool createPdf)
        {
            AddSubParagraph("Sub sequence " + aSubSequence.Name);

            HashSet<RuleCondition> rules = new HashSet<RuleCondition>();
            aSubSequence.EFSSystem.Runner = new DataDictionary.Tests.Runner.Runner(aSubSequence);
            foreach (TestCase testCase in aSubSequence.TestCases)
            {
                // each test case will calculate the list of rules it activate
                // and add them to activatedRules list
                CreateTestCaseSection(aSubSequence.EFSSystem.Runner, testCase, aReportConfig, rules, createPdf && aReportConfig.AddTestCases);
            }

            // now we  can create the table with the current sub sequence statistics
            CreateTable(aSubSequence.Name,
                        rules,
                        aReportConfig.Dictionary.ImplementedRules,
                        aReportConfig.AddActivatedRulesInSubSequences,
                        aReportConfig.AddNonCoveredRulesInSubSequences);

            activatedRules.UnionWith(rules);
            CloseSubParagraph();
        }
示例#30
0
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="subSequence"></param>
 public ApplyTranslationRulesHandler(SubSequence subSequence)
 {
     SubSequence = subSequence;
 }
示例#31
0
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="window"></param>
 /// <param name="subSequence"></param>
 public ExecuteTestsHandler(Window window, SubSequence subSequence)
 {
     Window      = window;
     SubSequence = subSequence;
 }
示例#32
0
        /// <summary>
        ///     The runner
        /// </summary>
        public Runner GetRunner(SubSequence subSequence)
        {
            Runner runner = EfsSystem.Runner;

            if (runner == null || runner.SubSequence != subSequence)
            {
                if (subSequence != null)
                {
                    EfsSystem.Runner = new Runner(subSequence, false, true, Settings.Default.CheckForCompatibleChanges);
                }
            }

            return EfsSystem.Runner;
        }
        /// <summary>
        ///     Creates a section for a given sub-sequence
        /// </summary>
        /// <param name="aSubSequence">A sub-sequence to be displayed</param>
        /// <param name="aReportConfig">The report configuration containing display details</param>
        /// <param name="activatedRules">The list that will contain the rules activated by this sub-sequence</param>
        /// <param name="createPdf">Indicates if the information about this sub-sequence has to be added to the pdf</param>
        public void CreateSubSequenceSection(SubSequence aSubSequence, TestsCoverageReportHandler aReportConfig,
            HashSet<RuleCondition> activatedRules, bool createPdf)
        {
            string title = "Sub sequence " + aSubSequence.Name;
            if (createPdf)
            {
                AddSubParagraph(title);
            }

            HashSet<RuleCondition> rules = new HashSet<RuleCondition>();
            aSubSequence.EFSSystem.Runner = new Runner(aSubSequence, false, true);
            foreach (TestCase testCase in aSubSequence.TestCases)
            {
                // SIDE EFFECT:
                // each test case will calculate the list of rules it activates
                // and add them to activatedRules list
                CreateTestCaseSection(aSubSequence.EFSSystem.Runner, testCase, aReportConfig, rules,
                    createPdf && aReportConfig.AddTestCases);
            }
            activatedRules.UnionWith(rules);

            // now we  can create the table with the current sub sequence statistics
            if (createPdf)
            {
                CreateActivatedRulesSection(title,
                    rules,
                    aReportConfig.Dictionary.ImplementedRules,
                    aReportConfig.AddActivatedRulesInSubSequences);

                CloseSubParagraph();
            }
        }