/// <summary>
        /// Creates the section which describes the translated test and the result of application of those tests on the model
        /// </summary>
        private void CreateTestSequenceReport()
        {
            Report.AddSubParagraph("Sub sequence report");
            Report.AddParagraph(
                "This section presents the sub sequences that have been translated and applied on the Subset-026 model, along with their execution result and the issues found in the test sequence definition.");

            Counter counter = new Counter();

            counter.visit(Dictionary, true);

            Report.AddParagraph("The following table presents summarises the test sequences that have been analysed.");

            Report.AddTable(new[] { "", "Description", "Count", "Ratio" }, new[] { 35, 105, 15, 15 });
            Report.AddRow(
                "Imported sequences",
                "The number of test sequences imported from the Subset-076 Access databases.",
                counter.SubSequences.ToString(CultureInfo.InvariantCulture),
                Percent(counter.SubSequences, 700));

            Report.AddRow(
                "Sequence analysis completed",
                "The number of imported test sequences for which the analysis has been completely executed.",
                counter.CompletedSubSequences.Count.ToString(CultureInfo.InvariantCulture),
                Percent(counter.CompletedSubSequences.Count, counter.SubSequences));
            Report.lastRow.Cells[0].MergeDown = 2;

            Report.AddRow(
                "",
                "The full test has been executed and is successful. We may have fixed several test steps to achieve this objective.",
                counter.CompleteAndValid.Count.ToString(CultureInfo.InvariantCulture),
                Percent(counter.CompleteAndValid.Count, counter.CompletedSubSequences.Count));

            Report.AddRow(
                "",
                "A blocking issue has been found while analyzing the sub sequence, however, all steps before that issue have been successfully executed.",
                counter.CompleteAndBlocking.Count.ToString(CultureInfo.InvariantCulture),
                Percent(counter.CompleteAndBlocking.Count, counter.CompletedSubSequences.Count));

            Report.AddRow(
                "Ongoing sequences",
                "The number of imported test sequences for which analysis is ongoing. No definitive result is provided yet for such test sequences",
                counter.OngoingSubSequences.Count.ToString(CultureInfo.InvariantCulture),
                Percent(counter.OngoingSubSequences.Count, counter.SubSequences));
            Report.lastRow.Cells[0].MergeDown = 1;

            Report.AddRow(
                "",
                "A blocking issue has been found while analyzing the sub sequence, but analysis is still ongoing.",
                counter.OngoingAndBlocking.Count.ToString(CultureInfo.InvariantCulture),
                Percent(counter.OngoingAndBlocking.Count, counter.OngoingSubSequences.Count));


            Report.AddParagraph(
                "The following table categorises the issues found during analysis of the test sequences. ");

            Report.AddTable(new[] { "Issue kind", "Definition", "Count" }, new[] { 35, 105, 30 });
            Report.AddRow(
                "Blocking issues",
                "Blocking issues are issues found in the text sequences that forbid execution of the sequence, for instance a missing message in the sequence definition. " + (IncludeDetails ? "These issues are reported in red." : ""),
                counter.Issues[IssueKind.Blocking].ToString(CultureInfo.InvariantCulture));
            if (IncludeDetails)
            {
                Report.SetLastRowColor(IssueColor(IssueKind.Blocking));
            }

            Report.AddRow(
                "Issues",
                "Issues are errors detected in the test sequences. The corresponding test has been manually updated to avoid the error and continue execution. " + (IncludeDetails ? "These issues are reported in red." : ""),
                counter.Issues[IssueKind.Issue].ToString(CultureInfo.InvariantCulture));
            if (IncludeDetails)
            {
                Report.SetLastRowColor(IssueColor(IssueKind.Issue));
            }

            Report.AddRow(
                "Questions",
                "Question raised during the test sequence analysis. " + (IncludeDetails ? "These issues are reported in yellow." : ""),
                counter.Issues[IssueKind.Question].ToString(CultureInfo.InvariantCulture));
            if (IncludeDetails)
            {
                Report.SetLastRowColor(IssueColor(IssueKind.Question));
            }

            Report.AddRow(
                "Comments",
                "Comments issued during the test sequence analysis. " + (IncludeDetails ? "These issues are reported in green." : ""),
                counter.Issues[IssueKind.Comment].ToString(CultureInfo.InvariantCulture));
            if (IncludeDetails)
            {
                Report.SetLastRowColor(IssueColor(IssueKind.Comment));
            }

            Report.AddSubParagraph("Summary");
            Report.AddParagraph("This section summarises the results for each sub sequence. The 'Actions' are the number of inputs required to execute the test sequence, and 'Checks' identifies the check points that are verified on the sub sequence. The column issues counts the number of issues (either blocking or non blocking) found during the analysis of the test sequence. The status can take several values");
            Report.AddListItem("Completed : the analysis of the test sequence is complete and the execution satisfies the constaints defined in the test sequence. ");
            Report.AddListItem("Ongoing : the analysis of the test sequence is ongoing, no definitive result can be provided yet.");
            Report.AddTable(new[] { "Subsequence", "Blocking issues", "Issues", "Questions", "Comments", "Status" }, new[] { 72, 20, 20, 20, 20, 28 });
            foreach (Frame frame in Dictionary.Tests)
            {
                foreach (SubSequence subSequence in frame.SubSequences)
                {
                    counter = new Counter();
                    counter.visit(subSequence, true);

                    string status = "Ongoing";
                    Color  color  = Colors.Orange;
                    if (subSequence.getCompleted())
                    {
                        status = "Completed";
                        color  = Colors.Green;
                    }

                    Report.AddRow(
                        subSequence.Name,
                        counter.Issues[IssueKind.Blocking].ToString(CultureInfo.InvariantCulture),
                        counter.Issues[IssueKind.Issue].ToString(CultureInfo.InvariantCulture),
                        counter.Issues[IssueKind.Question].ToString(CultureInfo.InvariantCulture),
                        counter.Issues[IssueKind.Comment].ToString(CultureInfo.InvariantCulture),
                        status);
                    Row sequenceRow = Report.lastRow;
                    sequenceRow.Cells[5].Shading.Color = color;

                    // Provide the comment, if any
                    if (!string.IsNullOrEmpty(subSequence.Comment))
                    {
                        Report.AddRow(subSequence.Comment, "", "", "", "", "");
                        Report.SetLastRowColor(color);
                        Report.lastRow.Cells[0].MergeRight = 4;
                        sequenceRow.Cells[5].MergeDown    += 1;
                    }

                    if (IncludeDetails)
                    {
                        // Provide the test cases and the steps related to this test sequence
                        foreach (TestCase testCase in subSequence.TestCases)
                        {
                            foreach (ReqRef reqRef in testCase.Requirements)
                            {
                                Report.AddRow(
                                    testCase.Name,
                                    reqRef.Paragraph.Text, "", "", "", "");
                                Report.SetLastRowColor(IssueColor(reqRef.Paragraph));
                                Report.lastRow.Cells[1].MergeRight = 3;
                                sequenceRow.Cells[5].MergeDown    += 1;
                            }

                            foreach (Step step in testCase.Steps)
                            {
                                foreach (ReqRef reqRef in step.Requirements)
                                {
                                    string name = testCase.Name;

                                    if (step.getTCS_Order() != 0)
                                    {
                                        name += " Step  " + step.getTCS_Order().ToString(CultureInfo.InvariantCulture);
                                    }

                                    Report.AddRow(
                                        name,
                                        reqRef.Paragraph.Text, "", "", "", "");
                                    Report.SetLastRowColor(IssueColor(reqRef.Paragraph));
                                    Report.lastRow.Cells[1].MergeRight = 3;
                                    sequenceRow.Cells[5].MergeDown    += 1;
                                }
                            }
                        }
                    }
                }
            }
            Report.CloseSubParagraph();

            if (IncludeDetails && IncludeTestSequencesDetails)
            {
                Report.AddSubParagraph("Detailed sub sequence report");
                foreach (Frame frame in Dictionary.Tests)
                {
                    foreach (SubSequence subSequence in frame.SubSequences)
                    {
                        CreateSubSequenceDescription(subSequence);
                    }
                }
                Report.CloseSubParagraph();
            }

            Report.CloseSubParagraph();
        }