Summary description for TestReport
Inheritance: DevExpress.XtraReports.UI.XtraReport
Example #1
0
        public void PathToRoot()
        {
            var tree = new TestNode("A")
            {
                new TestNode("A.A")
                {
                    new TestNode("A.A.A"),
                    new TestNode("A.A.B")
                },
            };

            var report = new TestReport();

            foreach (var node in tree.Last().PathToRoot())
            {
                report.WriteLine(node);
            }

            var expected =
            @"A
            A.A
            A.A.B
            ";
            Assert.That(report, Is.EqualTo(new TestReport(expected)));
        }
        public void Box()
        {
            // Init
            var report = new TestReport();

            var puz = new Puzzle(new String[]
            {
                "#####",
                "#...#",
                "#...#",
                "#...#",
                "#####",
            });

            var stat = StaticAnalysis.Generate(puz);

            var dead = DeadMapAnalysis.FindDeadMap(stat);
            Assert.That(dead, Is.Not.Null);
            report.WriteLine(dead);

            Assert.That(report, Is.EqualTo(new TestReport(
            @".....
            .XXX.
            .X.X.
            .XXX.
            ....."
            )));
        }
        public static void WriteOutCompletionStatement(TestReport completeState, DateTime startOfRunTime)
        {
            if (completeState == null) throw new ArgumentNullException("completeState");
            writer.Write("{1}{1}-- Completed Test Run at: {0}. Total Run Time: {2}{1}{1}"
                .FormatWith(DateTime.Now, Environment.NewLine, DateTime.Now.Subtract(startOfRunTime)));

            writer.Write("Test run results: Total {0}, ", completeState.TotalResults);

            var successfulMessage = "Successful {0}, ".FormatWith(completeState.TotalPassed);
            if (completeState.TotalPassed > 0)
                successfulMessage.WrapConsoleMessageWithColor(Settings.Default.ConsoleColorSuccess, false);
            else
                writer.Write(successfulMessage);

            var failedMessage = "Failed {0}, ".FormatWith(completeState.TotalFailed);
            if (completeState.TotalFailed > 0)
                failedMessage.WrapConsoleMessageWithColor(Settings.Default.ConsoleColorError, false);
            else
                writer.Write(failedMessage);

            var ignoredMessage = "Ignored {0}".FormatWith(completeState.TotalIgnored);
            if (completeState.TotalIgnored > 0)
                ignoredMessage.WrapConsoleMessageWithColor(Settings.Default.ConsoleColorWarning, false);

            writer.WriteLine("");
        }
        public void DeadMap()
        {
            // Init
            var report = new TestReport();

            var stat = StaticAnalysis.Generate(TestLibrary.Default);

            var dead = DeadMapAnalysis.FindDeadMap(stat);

            Assert.That(dead, Is.Not.Null);
            report.WriteLine(dead);

            //            Assert.That(report, Is.EqualTo(new TestReport(
            //@"...........
            //...........
            //...........
            //.......X...
            //...........
            //...........
            //.......X...
            //...X..X....
            //...........
            //...........
            //..........."
            //            )));
            Assert.Inconclusive();
        }
Example #5
0
        public void OnTestsRun(TestReport report)
        {
            uxTestTree.Nodes.Clear();
            var root = uxTestTree.Nodes.Add("Tests");

            var overallSuccess = true;
            var overallIgnored = false;

            var testCounts = EnumExtensions.GetMembers<TestResult>().ToDictionary(key => key, key => 0);

            foreach (var collection in report.Collections)
            {
                var collectionNode = root.Nodes.Add(collection.Name);
                collectionNode.Tag = collection;

                var ignored = false;
                var failed = false;

                foreach (var test in collection.Results)
                {
                    testCounts[test.Result]++;

                    if (test.Result == TestResult.Failure)
                    {
                        overallSuccess = false;
                        failed = true;
                    }
                    else if (test.Result == TestResult.Ignored && !failed)
                    {
                        if (overallSuccess)
                            overallIgnored = true;

                        ignored = true;
                    }

                    var image = GetImageIndex(test.Result);
                    var node = new TreeNode(test.Name, image, image) { Tag = test };

                    collectionNode.Nodes.Add(node);
                }

                var collectionImage = GetImageIndex(failed, ignored);
                collectionNode.ImageIndex = collectionImage;
                collectionNode.SelectedImageIndex = collectionImage;
            }

            var rootImage = GetImageIndex(!overallSuccess, overallIgnored);
            root.ImageIndex = rootImage;
            root.SelectedImageIndex = rootImage;

            var totalTestCount = testCounts.Sum(pair => pair.Value);

            uxTimeMessage.Text = string.Format("Test run with {0} tests took {1}s to execute.", totalTestCount, report.TimeTaken.TotalSeconds);

            uxSuccessCount.Text = CreateCountMessage(testCounts[TestResult.Success], "passed");
            uxFailureCount.Text = CreateCountMessage(testCounts[TestResult.Failure], "failed");
            uxIgnoredCount.Text = CreateCountMessage(testCounts[TestResult.Ignored], "ignored", true);
        }
        public void CalculateWeightings()
        {
            var report = new TestReport();
            var stat = StaticAnalysis.Generate(new Puzzle());
            var w = StaticAnalysis.CalculateWeightings(stat);
            Assert.That(w, Is.Not.Null);

            report.WriteLine(w);
        }
Example #7
0
        /// <summary>
        /// Called when a report is received.
        /// </summary>
        /// <param name="report">The report, containing all test information.</param>
        public void OnTestsRun(TestReport report)
        {
            Debug.LogAlways("Console unit test log. Tests took {0}s overall to execute.", report.TimeTaken.TotalSeconds);

            var testCounts = EnumExtas.Values<TestResult>().ToDictionary(key => key, key => 0);

            foreach (var collection in report.Collections)
            {
                Debug.LogAlways("        Test collection: {0}", collection.Name);

                foreach (var test in collection.Results)
                {
                    testCounts[test.Result]++;
                    var log = test.Name;

                    if (!string.IsNullOrEmpty(test.Description))
                        log += string.Format(" ({0})", test.Description);

                    Debug.LogAlways("            {0}", log);

                    switch (test.Result)
                    {
                        case TestResult.Success:
                            Debug.LogAlways("                Test successful.");
                            break;

                        case TestResult.Failure:
                            Debug.LogAlways("                Test failed: {0} ({1} thrown at line {2} of {3})", test.Exception.Message,
                                test.Exception.GetType().Name, test.FirstFrame.GetFileLineNumber(), test.FirstFrame.GetFileName());
                            break;

                        case TestResult.Ignored:
                            Debug.LogAlways("                Test ignored.");
                            break;
                    }
                }
            }

            var failCount = testCounts[TestResult.Failure];
            var ignoredCount = testCounts[TestResult.Ignored];
            var collectionFailCount = report.Collections.Count(col => col.Results.Any(test => test.Result == TestResult.Failure));

            Debug.LogAlways("Test run overview:");

            if (failCount == 0)
                Debug.LogAlways("        No errors found!");
            else
                Debug.LogAlways("        {0} total error{1} across {2} failing test collection{3}.",
                    failCount, failCount > 1 ? "s" : string.Empty,
                    collectionFailCount, collectionFailCount > 1 ? "s" : string.Empty);

            if (ignoredCount == 0)
                Debug.LogAlways("        No tests ignored.");
            else
                Debug.LogAlways("        {0} test{1} ignored.", ignoredCount, ignoredCount > 1 ? "s" : string.Empty);
        }
        public void Normalise()
        {
            var report = new TestReport();
            var norm = StaticAnalysis.Normalise(new Puzzle());

            report.WriteLine(norm.ToString());
            Assert.That(report, Is.EqualTo(new TestReport(
                @"###########
            ####.######
            ###..###..#
            ##.X......#
            #...PX.#..#
            ###.X###..#
            ###..#OO..#
            ###.##O#.##
            ##......###
            ##.....####
            ###########
            "
                )));
        }
Example #9
0
        public void CaseA()
        {
            var report = new TestReport();

            var sample = new Puzzle(new string[]
            {
                "#############",
                "#a ###    b##",
                "# A######  ##",
                "#  ######B ##",
                "#########  ##",
                "#############",
            });

            var boundry = sample.ToMap('#', 'A', 'B' );

            var staticMaps = new StaticMaps()
            {
                FloorMap = sample.ToMap(' ', 'a', 'b'),
                WallMap = sample.ToMap('#')
            };
            var stateMaps = new StateMaps()
            {
                CrateMap = sample.ToMap('A', 'B'),
                MoveMap = FloodFill.Fill(staticMaps.WallMap, sample.First(x => x.State == 'a').Position)
            };

            var pushMap = PushMap.Find(staticMaps, stateMaps, sample.First(x => x.State == 'A').Position, sample.First(x => x.State == 'a').Position);

            report.WriteLine(pushMap);

            Assert.That(report, Is.EqualTo(new TestReport(
            @".............
            ..X..........
            .............
            ..X..........
            .............
            ............."
                )));
        }
Example #10
0
        private static AssemblyReport CreateAssemblyReport(IGrouping <string, Info> groupByAssembly)
        {
            var reports = new List <TestReport>();

            foreach (var info in groupByAssembly)
            {
                var report = new TestReport
                {
                    ClassName = info.ClassName,
                    Name      = info.MethodName
                };
                if (info is TestResultInfo)
                {
                    var result = info as TestResultInfo;
                    report.Status  = result.IsPassed ? TestStatus.Passed : TestStatus.Failed;
                    report.Time    = result.Time;
                    report.Message = result.FailedMessage;
                }
                else
                {
                    var result = info as IgnoredTestInfo;
                    report.Status  = TestStatus.Ignored;
                    report.Message = result.Message;
                }
                reports.Add(report);
            }

            var assemblyReport = new AssemblyReport
            {
                Name            = groupByAssembly.Key,
                TestReports     = reports,
                NumberOfPassed  = reports.Where(r => r.Status == TestStatus.Passed).Count(),
                NumberOfFailed  = reports.Where(r => r.Status == TestStatus.Failed).Count(),
                NumberOfIgnored = reports.Where(r => r.Status == TestStatus.Ignored).Count(),
            };

            return(assemblyReport);
        }
Example #11
0
        public static StringBuilder ToCsv(
            this TestReport testReport,
            INameFormatter nameFormatter,
            string separator = ";")
        {
            if (nameFormatter == null)
            {
                throw new ArgumentNullException(nameof(nameFormatter));
            }

            var sb = new StringBuilder();

            if (testReport != null)
            {
                sb.AppendHeaderRow(separator);
                foreach (var projectInfo in testReport.Projects)
                {
                    foreach (var unitUnderTest in projectInfo.UnitsUnderTest)
                    {
                        foreach (var operationUnderTest in unitUnderTest.OperationsUnderTest)
                        {
                            foreach (var testScenario in operationUnderTest.TestScenarios)
                            {
                                sb.AppendContentRow(
                                    projectInfo,
                                    unitUnderTest,
                                    operationUnderTest,
                                    testScenario,
                                    separator,
                                    nameFormatter);
                            }
                        }
                    }
                }
            }

            return(sb);
        }
Example #12
0
        /// <summary>
        /// 设置
        /// </summary>
        public override void EntitySet()
        {
            TestReport entity = new TestReport();

            entity.ID = HTDataID;
            bool findFlag = entity.SelectByID();

            txtFormNo.Text        = entity.FormNo.ToString();
            txtFormDate.DateTime  = entity.FormDate;
            txtOrderFormNo.Text   = entity.OrderFormNo.ToString();
            txtItemCode.Text      = entity.ItemCode.ToString();
            txtItemName.Text      = entity.ItemName.ToString();
            txtItemStd.Text       = entity.ItemStd.ToString();
            txtItemModel.Text     = entity.ItemModel.ToString();
            txtColorNum.Text      = entity.ColorNum.ToString();
            txtColorName.Text     = entity.ColorName.ToString();
            drpSaleOPID.Text      = entity.SaleOPID.ToString();
            drpTestOPID.Text      = entity.TestOPID.ToString();
            txtItemSource.Text    = entity.ItemSource.ToString();
            txtSXShrinkageJX.Text = entity.SXShrinkageJX.ToString();
            txtSXShrinkageWX.Text = entity.SXShrinkageWX.ToString();
            txtYTShrinkageJX.Text = entity.YTShrinkageJX.ToString();
            txtYTShrinkageWX.Text = entity.YTShrinkageWX.ToString();
            txtMakeOPID.Text      = entity.MakeOPID.ToString();
            txtMakeOPName.Text    = entity.MakeOPName.ToString();
            txtMakeDate.DateTime  = entity.MakeDate;
            txtCheckOPID.Text     = entity.CheckOPID.ToString();
            txtCheckDate.DateTime = entity.CheckDate;


            HTDataSubmitFlag = entity.SubmitFlag;
            HTDataDelFlag    = entity.DelFlag;
            if (!findFlag)
            {
            }

            BindGridDts();
        }
        public void TestExpandSimplePanel_ChildAcrossWidth_ChildCenter_RowShift()
        {
            var          report      = new TestReport();
            IXLWorksheet ws          = report.Workbook.AddWorksheet("Test");
            IXLRange     parentRange = ws.Range(2, 2, 4, 5);

            parentRange.AddToNamed("ParentRange", XLScope.Worksheet);

            parentRange.Style.Border.OutsideBorder      = XLBorderStyleValues.Thin;
            parentRange.Style.Border.OutsideBorderColor = XLColor.Black;

            IXLRange childRange = ws.Range(3, 2, 3, 5);

            childRange.AddToNamed("ChildRange", XLScope.Worksheet);

            childRange.Style.Border.OutsideBorder      = XLBorderStyleValues.Dashed;
            childRange.Style.Border.OutsideBorderColor = XLColor.Blue;

            ws.Cell(2, 2).Value = "{p:StrParam}";

            ws.Cell(3, 3).Value = "{di:Name}";
            ws.Cell(3, 4).Value = "{di:Date}";
            ws.Cell(3, 5).Value = "{di:Sum}";

            var parentPanel = new ExcelPanel(parentRange, report, report.TemplateProcessor);
            var childPanel  = new ExcelDataSourcePanel("m:DataProvider:GetIEnumerable()", ws.NamedRange("ChildRange"), report, report.TemplateProcessor)
            {
                Parent    = parentPanel,
                ShiftType = ShiftType.Row,
            };

            parentPanel.Children = new[] { childPanel };
            parentPanel.Render();

            Assert.AreEqual(ws.Range(2, 2, 6, 5), parentPanel.ResultRange);

            //report.Workbook.SaveAs("test.xlsx");
        }
Example #14
0
        private void GenerateReport_Click(object sender, RoutedEventArgs e)
        {
            var caselist = Pages.util.SelectTestCases(
                Passed.IsChecked == true,
                Failed.IsChecked == true,
                Inconclusive.IsChecked == true,
                false);

            if (caselist.Count == 0)
            {
                UserPromptWindow.Show(StringResources.Error, StringResources.NoTestResults, UserPromptWindow.IconType.Error);
                return;
            }

            var selectedRadioButton = ReportFormatGroup.Children.OfType <RadioButton>().FirstOrDefault(rb => rb.IsChecked == true);

            if (selectedRadioButton == null)
            {
                UserPromptWindow.Show(StringResources.Error, StringResources.NoReportFormatSelected, UserPromptWindow.IconType.Error);
                return;
            }
            TestReport report = TestReport.GetInstance(selectedRadioButton.Name, caselist);

            if (report == null)
            {
                UserPromptWindow.Show(StringResources.Error, StringResources.UnknownReportFormat, UserPromptWindow.IconType.Error);
                return;
            }

            Microsoft.Win32.SaveFileDialog saveFileDialog = new Win32.SaveFileDialog();
            saveFileDialog.Filter     = report.FileDialogFilter;
            saveFileDialog.DefaultExt = report.FileExtension;
            if (saveFileDialog.ShowDialog() == true)
            {
                report.ExportReport(saveFileDialog.FileName);
                DialogResult = true;
            }
        }
Example #15
0
        public frmTestReport(TestReport o, StabilityMonthlyPlanner o1)
        {
            oB = new BAL();
            InitializeComponent();
            BindDD();
            ClealAll();
            Id = o.Id;
            txtInitial.Text       = o.Initial;
            StabilityCheckId      = o.StabilityCheckId;
            ddlTest.SelectedValue = o.TestId;
            txtInitial.Text       = o.Initial;
            txt1M.Text            = o.M1;
            txt2M.Text            = o.M2;
            txt3M.Text            = o.M3;
            txt6M.Text            = o.M6;
            txt9M.Text            = o.M9;
            txt12M.Text           = o.M12;
            txt18M.Text           = o.M18;
            txt24M.Text           = o.M24;
            txt30M.Text           = o.M30;
            txt36M.Text           = o.M36;
            txt42M.Text           = o.M42;
            txt48M.Text           = o.M48;
            txt60M.Text           = o.M60;
            txt72M.Text           = o.M72;

            lblProductName.Text       = o1.ProductName;
            lblBatchNo.Text           = o1.BatchNo;
            lblMfgDate.Text           = o1.MfgDate;
            lblExpDate.Text           = o1.ExpDate;
            lblBatchSize.Text         = o1.BatchSize;
            lblPack.Text              = o1.Pack;
            lblShelfLife.Text         = o1.ShelfLife;
            lblConditionInterval.Text = o1.ConditionInterval;
            lblItemCode.Text          = o1.ItemCode;
            lblCountry.Text           = o1.Country;
            lblDueDate.Text           = o1.DueDate + "-" + o1.MONTH;
        }
        public ActionResult TestSummary(Int32 TestId)
        {
            if (Session["UserType"] == null)
            {
                return(RedirectToAction("Index", "ELFWeb"));
            }
            TestReport _TestReport = new TestReport();

            String _GetTestReportOverviewDetails = StudentWeb.GetTestOverview(Convert.ToInt32(Session["UserId"].ToString()), TestId);
            String _GetTestReportDetailsDetails  = StudentWeb.GetDetailedTestReport(Convert.ToInt32(Session["UserId"].ToString()), TestId);

            JObject StudentTestReportOverviewparsing = JObject.Parse(_GetTestReportOverviewDetails);
            JObject StudentTestReportDetailsparsing  = JObject.Parse(_GetTestReportDetailsDetails);

            TestOverview _TestSummary = new TestOverview();

            _TestSummary.SubjectId   = (Int32)StudentTestReportOverviewparsing["Table"][0]["SubjectId"];
            _TestSummary.SubjectName = (String)StudentTestReportOverviewparsing["Table"][0]["SubjectName"];
            // _TestSummary.CorrectAnswers = (string)StudentTestReportOverviewparsing["Table"][0]["CorrectAnswers"];
            _TestSummary.Percentage = (Int32)StudentTestReportOverviewparsing["Table"][0]["Percentage"];
            //_TestSummary.Description = (String)StudentTestReportOverviewparsing["Table"][0]["Description"];
            _TestSummary.TestId = (Int32)StudentTestReportOverviewparsing["Table"][0]["TestId"];

            List <TestDetails> _TestDetailsList = new List <TestDetails>();

            for (int i = 0; i < 20; i++)
            {
                TestDetails _TestDetails = new TestDetails();
                _TestDetails.Question     = (String)StudentTestReportDetailsparsing["Table"][i]["Question"];
                _TestDetails.Answer       = (String)StudentTestReportDetailsparsing["Table"][i]["Answer"];
                _TestDetails.AnswerStatus = (String)StudentTestReportDetailsparsing["Table"][i]["AnswerStatus"];
                _TestDetails.QNumber      = i + 1;
                _TestDetailsList.Add(_TestDetails);
            }
            _TestReport.TestDetailList = _TestDetailsList;
            _TestReport.TestOverviews  = _TestSummary;
            return(View(_TestReport));
        }
Example #17
0
        }//end method ReadConfigs

        /// <summary>
        /// Initialize the test configurations
        /// </summary>
        public static void Init(string automationConf)
        {
            if (!IsTestConfigsInitialized)
            {
                //Read the automated app configs
                ReadConfigs(automationConf);

                AutomatedLogger.Init(LogFile);
                AutomatedLogger.Log("Test that logging is working!");

                AutomatedLogger.Log("WebPath: " + automationConf);

                //Initialize your configs: messages, test data, logger, ...
                ExcelDataParser.Init(TestConfigs.TestDataFile);
                //TODO: this should be json data object
                //data = JsonDataParser.ParseJsonData(TestConfigs.TestDataFile);

                //Initialize the report here
                TestReport.Report_init(TestConfigs.ReportingDirectory);

                IsTestConfigsInitialized = true;
            } //endif
        }     //end method
Example #18
0
        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="p_BE">要删除的实体</param>
        /// <param name="sqlTrans">事务类</param>
        public void RDelete(BaseEntity p_BE, IDBTransAccess sqlTrans)
        {
            try
            {
                this.CheckCorrect(p_BE);
                TestReport    entity  = (TestReport)p_BE;
                TestReportCtl control = new TestReportCtl(sqlTrans);


                string sql = "DELETE FROM WO_TestReportDts WHERE MainID=" + entity.ID.ToString();
                sqlTrans.ExecuteNonQuery(sql);//删除原单据明细数据

                control.Delete(entity);
            }
            catch (BaseException)
            {
                throw;
            }
            catch (Exception E)
            {
                throw new BaseException(E.Message);
            }
        }
Example #19
0
        public static int Main(string[] args)
        {
            // Uncomment the following 2 lines if you want to automate Windows apps
            // by starting the test executable directly
            //if (Util.IsRestartRequiredForWinAppAccess)
            //    return Util.RestartWithUiAccess();

            Keyboard.AbortKey = System.Windows.Forms.Keys.Pause;

            // General speed settings, will not affect replay of individual modules
            Mouse.DefaultMoveTime        = 0;
            Keyboard.DefaultKeyPressTime = 20;
            Delay.SpeedFactor            = 0;

            TestReport.BeginTestSuite("SingleARDconfigTest");

            var flowExecutor = new FlowExecuter();

            flowExecutor.Run(new Flow1());
            flowExecutor.Run(new Flow2());

            return((flowExecutor.overallResult == TestResult.Passed) ? 1 : 0);
        }
Example #20
0
        public void SideMap()
        {
            // Init
            var report = new TestReport();


            var stat = new StaticAnalysisMaps(Puzzle.Builder.DefaultTestPuzzle());

            Assert.NotNull(stat.SideMap);
            report.WriteLine(stat.SideMap);

            Assert.Equal(new TestReport(@"...........
...........
...........
......X..X.
.........X.
.........X.
...X.......
...........
...........
...XXX.....
..........."), report);
        }
        public void TestRenderEmptyEnumerable()
        {
            var          report = new TestReport();
            IXLWorksheet ws     = report.Workbook.AddWorksheet("Test");
            IXLRange     range1 = ws.Range(2, 2, 4, 2);

            range1.AddToNamed("TestRange", XLScope.Worksheet);

            ws.Cell(2, 2).Value = "{Headers}";
            ws.Cell(3, 2).Value = "{Data}";
            ws.Cell(4, 2).Value = "{Totals}";

            var panel = new ExcelDataSourceDynamicPanel("m:DataProvider:GetEmptyIEnumerable()", ws.NamedRange("TestRange"), report, report.TemplateProcessor);

            panel.Render();

            Assert.AreEqual(ws.Range(2, 2, 3, 5), panel.ResultRange);

            ExcelAssert.AreWorkbooksContentEquals(TestHelper.GetExpectedWorkbook(nameof(DataSourceDynamicPanelEnumerableRenderTest),
                                                                                 nameof(TestRenderEmptyEnumerable)), ws.Workbook);

            //report.Workbook.SaveAs("test.xlsx");
        }
Example #22
0
        public void ToHtml_ReturnsTestDetail_WhenDoesNotContainFailedTests()
        {
            // Arrange
            var testResultData = new TestRun
            {
                IsValid      = true,
                FileName     = "success.xml",
                Result       = "Passed",
                Total        = 10,
                Failed       = 0,
                Inconclusive = 1,
                Passed       = 7,
                Skipped      = 2,
                Duration     = 2.45
            };

            // Act
            var result = new TestReport().ToHtml(testResultData);

            // Assert
            Assert.That(result, Contains.Substring("success.xml"));
            Assert.That(result, Contains.Substring("Passed"));
        }
Example #23
0
        public void ResursiveEnumeration()
        {
            var tree = new TestNode("A")
            {
                new TestNode("A.A")
                {
                    new TestNode("A.A.A"),
                    new TestNode("A.A.B")
                    {
                        new TestNode("A.A.B.A"),
                        new TestNode("A.A.B.B")
                    }
                },
                new TestNode("A.B")
            };


            var report = new TestReport();

            foreach (var n in tree)
            {
                report.WriteLine(n);
            }


            var expected =
                @"A
A.A
A.A.A
A.A.B
A.A.B.A
A.A.B.B
A.B
";

            Assert.Equal(new TestReport(expected), report);
        }
Example #24
0
        private static async Task HandleEagleRequest(HttpContext context, string nodeSecret, params TestableAssembly[] testableAssemblies)
        {
            var bodyAsText = await GetBody(context);

            TestTrigger testTrigger = JsonConvert.DeserializeObject <TestTrigger>(bodyAsText);
            var         response    = context.Response;

            response.ContentType = "application/json";

            if (!string.IsNullOrWhiteSpace(nodeSecret))
            {
                if (nodeSecret != testTrigger.NodeSecret)
                {
                    response.StatusCode = (int)HttpStatusCode.Forbidden;
                    await response.WriteAsync(JsonConvert.SerializeObject("the node secret is wrong"));

                    return;
                }
            }
            response.StatusCode = (int)HttpStatusCode.OK;
            var            eagleEngine = new EagleEngine(testableAssemblies);
            var            testSuites  = eagleEngine.GetDiscoveredTestSuites();
            IResultHandler handler     = new HttpRequestResultHandler(testSuites, testTrigger.NodeName, testTrigger.RequestId,
                                                                      testTrigger.CallBackUrl);
            var result = await eagleEngine.ExecuteTest(handler, testTrigger.Id);


            var report = new TestReport()
            {
                TestResults = result,
                TestSuites  = testSuites,
                NodeName    = testTrigger.NodeName,
                RequestId   = testTrigger.RequestId,
            };
            await response.WriteAsync(JsonConvert.SerializeObject(report));
        }
Example #25
0
        public void TestRenderNullItemVerticalCellsShift()
        {
            var          report = new TestReport();
            IXLWorksheet ws     = report.Workbook.AddWorksheet("Test");
            IXLRange     range  = ws.Range(2, 2, 3, 5);

            range.AddToNamed("TestRange", XLScope.Worksheet);

            ws.Cell(2, 2).Value = "{di:Name}";
            ws.Cell(2, 3).Value = "{di:Date}";
            ws.Cell(2, 4).Value = "{m:Multiply(di:Sum, 5)}";
            ws.Cell(2, 5).Value = "{di:Contacts}";
            ws.Cell(3, 2).Value = "{di:Contacts.Phone}";
            ws.Cell(3, 3).Value = "{di:Contacts.Fax}";
            ws.Cell(3, 4).Value = "{p:StrParam}";

            ws.Cell(1, 1).Value = "{di:Name}";
            ws.Cell(4, 1).Value = "{di:Name}";
            ws.Cell(1, 6).Value = "{di:Name}";
            ws.Cell(4, 6).Value = "{di:Name}";
            ws.Cell(3, 1).Value = "{di:Name}";
            ws.Cell(3, 6).Value = "{di:Name}";
            ws.Cell(1, 4).Value = "{di:Name}";
            ws.Cell(4, 4).Value = "{di:Name}";

            var panel = new ExcelDataSourcePanel("m:DataProvider:GetNullItem()", ws.NamedRange("TestRange"), report, report.TemplateProcessor);

            panel.Render();

            Assert.IsNull(panel.ResultRange);

            ExcelAssert.AreWorkbooksContentEquals(TestHelper.GetExpectedWorkbook(nameof(DataSourcePanelNullItemRenderTest),
                                                                                 nameof(TestRenderNullItemVerticalCellsShift)), ws.Workbook);

            //report.Workbook.SaveAs("test.xlsx");
        }
        public void DoorMap()
        {
            // Init
            var report = new TestReport();

            var stat = StaticAnalysis.Generate(TestLibrary.Default);

            Assert.That(stat.DoorMap, Is.Not.Null);
            report.WriteLine(stat.DoorMap);

            Assert.That(report, Is.EqualTo(new TestReport(
                @"...........
            ...........
            ...........
            .......X...
            ...........
            ...........
            .......X...
            ...X..X....
            ...........
            ...........
            ..........."
                )));
        }
        public ActionResult SaveReportInDB(string name)
        {
            byte[]     file;
            var        path       = HttpRuntime.AppDomainAppPath + @"resources\";
            string     files      = System.IO.Directory.GetFiles(path, name).FirstOrDefault();
            TestReport testReport = new TestReport();

            var stream = new FileStream(files, FileMode.Open, FileAccess.Read);

            using (var reader = new BinaryReader(stream))
            {
                file = reader.ReadBytes((int)stream.Length);
            }
            var abc = testEntities.TestReports.Where(x => x.ReportName == name).FirstOrDefault();

            if (abc == null)
            {
                testReport.ReportName = name;
                testReport.ReportData = file;
                testEntities.TestReports.Add(testReport);
                testEntities.SaveChanges();
            }
            else
            {
                abc.ReportData = file;

                testEntities.SaveChanges();
            }


            var dataSetsService = HttpContext.GetServiceFromContext <IDataSetsService>();

            var dataSetsList = dataSetsService.GetDataSetsList();

            return(Json(dataSetsList, JsonRequestBehavior.AllowGet));
        }
Example #28
0
        public void TestVerticalInHorizontalPanelsGrouping()
        {
            var          report      = new TestReport();
            IXLWorksheet ws          = report.Workbook.AddWorksheet("Test");
            IXLRange     parentRange = ws.Range(2, 2, 3, 4);

            parentRange.AddToNamed("ParentRange", XLScope.Worksheet);

            IXLRange child = ws.Range(3, 3, 3, 4);

            child.AddToNamed("ChildRange", XLScope.Worksheet);

            ws.Cell(2, 2).Value = "{di:Name}";

            ws.Cell(3, 3).Value = "{di:Field1}";
            ws.Cell(3, 4).Value = "{di:Field2}";

            var parentPanel = new ExcelDataSourcePanel("m:DataProvider:GetIEnumerable()", ws.NamedRange("ParentRange"), report, report.TemplateProcessor)
            {
                Type = PanelType.Horizontal,
            };
            var childPanel = new ExcelDataSourcePanel("m:DataProvider:GetChildIEnumerable(di:Name)", ws.NamedRange("ChildRange"), report, report.TemplateProcessor)
            {
                Parent = parentPanel,
            };

            parentPanel.Children = new[] { childPanel };
            parentPanel.Render();

            Assert.AreEqual(ws.Range(2, 2, 5, 10), parentPanel.ResultRange);

            ExcelAssert.AreWorkbooksContentEquals(TestHelper.GetExpectedWorkbook(nameof(DataSourcePanelRender_WithGrouping_MixedPanels_Test),
                                                                                 nameof(TestVerticalInHorizontalPanelsGrouping)), ws.Workbook);

            //report.Workbook.SaveAs("test.xlsx");
        }
        public void TestCancelPanelRender()
        {
            var          report = new TestReport();
            IXLWorksheet ws     = report.Workbook.AddWorksheet("Test");
            IXLRange     range  = ws.Range(2, 2, 2, 2);

            range.AddToNamed("TestRange", XLScope.Worksheet);

            ws.Cell(2, 2).Value = "{di:di}";

            var panel = new ExcelDataSourcePanel(new[] { 1, 2, 3, 4 }, ws.NamedRange("TestRange"), report, report.TemplateProcessor)
            {
                BeforeRenderMethodName = "CancelPanelRender",
            };

            panel.Render();

            Assert.AreEqual(range, panel.ResultRange);

            Assert.AreEqual(1, ws.CellsUsed(XLCellsUsedOptions.Contents).Count());
            Assert.AreEqual("{di:di}", ws.Cell(2, 2).Value);

            //report.Workbook.SaveAs("test.xlsx");
        }
Example #30
0
        public void ResursiveWhere()
        {
            var tree = new TestNode("A")
            {
                new TestNode("A.A")
                {
                    new TestNode("A.A.A"),
                    new TestNode("A.A.B")
                },
                new TestNode("A.B")
            };

            var report = new TestReport();

            foreach (var node in tree.Where(x=>x.Id.StartsWith("A.A")))
            {
                report.WriteLine("{0} Depth: {1}, Count: {2}",  node, node.GetDepth(), node.Count(x=>true));
            }

            var expected =
            @"A.A Depth: 1, Count: 3
            A.A.A Depth: 2, Count: 1
            A.A.B Depth: 2, Count: 1
            ";
            Assert.That(report, Is.EqualTo(new TestReport(expected)));
        }
Example #31
0
 public bool bInsertUpdateTestReport(TestReport o)
 {
     return(oD.dInsertUpdateTestReport(o));
 }
Example #32
0
 private static XElement GetReport(TestReport report)
 {
     return new XElement("test-suite",
                         new XAttribute("type", "TestFixture"),
                         new XAttribute("name", Path.GetFileName(report.XapPath)),
                         new XAttribute("executed", "True"),
                         new XAttribute("result", report.TotalFailed > 0 ? "Failure" : "Success"),
                         new XAttribute("success", report.TotalFailed > 0 ? "False" : "True"),
                         new XElement("results",
                                         from r in report.TestResults
                                         select CreateTestCaseElement(r))
         );
 }
Example #33
0
        public void MultipleCrates()
        {
            var report = new TestReport();

            var sample = new Puzzle(new string[]
            {
                "#############",
                "#   x     p##",
                "#x         ##",
                "#  ######X ##",
                "#########  ##",
                "#############",
            });

            var staticMaps = new StaticMaps()
            {
                FloorMap = sample.ToMap(' ', 'x', 'X', 'p'),
                WallMap = sample.ToMap('#')
            };

            var crate = sample.ToMap('X', 'x');
            var stateMaps = new StateMaps()
            {
                CrateMap = crate,
                MoveMap = FloodFill.Fill(staticMaps.WallMap.BitwiseOR(crate), sample.First(x => x.State == 'p').Position)
            };

            var pushMap = PushMap.Find(staticMaps, stateMaps, sample.First(x => x.State == 'X').Position, sample.First(x => x.State == 'p').Position);

            report.WriteLine(pushMap);

            Assert.That(report, Is.EqualTo(new TestReport(
            @".............
            .....XXXXXX..
            ..XXXXXXXXX..
            ..X......XX..
            .........XX..
            .............
            "
                )));
        }
Example #34
0
 public static void Maximize()
 {
     Driver.Instance.Manage().Window.Maximize();
     TestReport.Log(LogStatus.Pass, "Browser maximized");
 }
        public void Walls_Box_4v4()
        {
            // Init
            var report = new TestReport();

            var puz = new Puzzle(new String[]
            {
                "######",
                "#....#",
                "#....#",
                "#....#",
                "#....#",
                "######",
            });

            var stat = StaticAnalysis.Generate(puz);

            Assert.That(stat.IndividualWalls, Is.Not.Null);

            foreach (var wall in stat.IndividualWalls)
            {

                report.WriteLine(wall);
            }

            Assert.That(report, Is.EqualTo(new TestReport(
                @"(1,1) => (4,1)
            ......
            .XXXX.
            ......
            ......
            ......
            ......

            (1,4) => (4,4)
            ......
            ......
            ......
            ......
            .XXXX.
            ......

            (1,1) => (1,4)
            ......
            .X....
            .X....
            .X....
            .X....
            ......

            (4,1) => (4,4)
            ......
            ....X.
            ....X.
            ....X.
            ....X.
            ......
            "
                )));
        }
Example #36
0
 public static void Close()
 {
     Driver.Instance.Quit();
     TestReport.Log(LogStatus.Pass, "Browser closed");
 }
Example #37
0
 public TestReportMessage(string id, string name, uint processId, TestReport testReport)
     : base(id, name)
 {
     this.ProcessId  = processId;
     this.TestReport = testReport;
 }
        public void Walls()
        {
            // Init
            var report = new TestReport();

            var stat = StaticAnalysis.Generate(TestLibrary.Default);

            Assert.That(stat.IndividualWalls, Is.Not.Null);
            foreach (var wall in stat.IndividualWalls)
            {

                report.WriteLine(wall);
            }

            Assert.That(report, Is.EqualTo(new TestReport(
                @"(8,2) => (9,2)
            ...........
            ...........
            ........XX.
            ...........
            ...........
            ...........
            ...........
            ...........
            ...........
            ...........
            ...........

            (3,6) => (4,6)
            ...........
            ...........
            ...........
            ...........
            ...........
            ...........
            ...XX......
            ...........
            ...........
            ...........
            ...........

            (2,9) => (6,9)
            ...........
            ...........
            ...........
            ...........
            ...........
            ...........
            ...........
            ...........
            ...........
            ..XXXXX....
            ...........

            (2,8) => (2,9)
            ...........
            ...........
            ...........
            ...........
            ...........
            ...........
            ...........
            ...........
            ..X........
            ..X........
            ...........

            (6,3) => (6,4)
            ...........
            ...........
            ...........
            ......X....
            ......X....
            ...........
            ...........
            ...........
            ...........
            ...........
            ...........

            (9,2) => (9,6)
            ...........
            ...........
            .........X.
            .........X.
            .........X.
            .........X.
            .........X.
            ...........
            ...........
            ...........
            ...........
            "
                )));
        }
Example #39
0
        public void ResursiveEnumeration()
        {
            var tree = new TestNode("A")
            {
                new TestNode("A.A")
                {
                    new TestNode("A.A.A"),
                    new TestNode("A.A.B")
                    {
                        new TestNode("A.A.B.A"),
                        new TestNode("A.A.B.B")
                    }
                },
                new TestNode("A.B")
            };

            var report = new TestReport();

            foreach (var n in tree)
            {
                report.WriteLine(n);
            }

            var expected =
            @"A
            A.A
            A.A.A
            A.A.B
            A.A.B.A
            A.A.B.B
            A.B
            ";
            Assert.That(report, Is.EqualTo(new TestReport(expected)));
        }
Example #40
0
 public void CreateTestReportAsync(TestReport testReport)
 {
     _testReportRepository.AddTestReport(testReport);
 }
Example #41
0
 public static void GoBack()
 {
     Driver.Instance.Navigate().Back();
     TestReport.Log(LogStatus.Pass, "Navigated back");
 }
Example #42
0
 public static TestReportCollection ToTestReportCollection(this TestReport testReport)
 {
     return(new TestReportCollection {
         testReport
     });
 }
Example #43
0
 public static void RefreshPage()
 {
     Driver.Instance.Navigate().Refresh();
     TestReport.Log(LogStatus.Pass, "Page refreshed");
 }
Example #44
0
        public void CaseB_WithPath()
        {
            var report = new TestReport();

            var sample = new Puzzle(new string[]
            {
                "#############",
                "#a ###    b##",
                "# A######  ##",
                "#  ######B ##",
                "#########  ##",
                "#############",
            });

            var staticMaps = new StaticMaps()
            {
                FloorMap = sample.ToMap(' ', 'a', 'b'),
                WallMap = sample.ToMap('#')
            };
            var stateMaps = new StateMaps()
            {
                CrateMap = sample.ToMap('A', 'B'),
                MoveMap = FloodFill.Fill(staticMaps.WallMap, sample.First(x => x.State == 'b').Position)
            };

            var pushMap = PushMap.Find(staticMaps, stateMaps, sample.First(x => x.State == 'B').Position, sample.First(x => x.State == 'b').Position);

            report.WriteLine(pushMap);

            var path = pushMap.FindPlayerWalkRoute(new VectorInt2(6, 1));
            report.WriteLine(path);

            Assert.That(report, Is.EqualTo(new TestReport(
            @".............
            ......XXXX...
            .........X...
            .............
            .........X...
            .............

            DDDLUURULLL
            ")));
        }
 public ReportReaderService(TestReport tItem)
     : base(tItem)
 {
 }
Example #46
0
        public void OverAndBackAgain()
        {
            var report = new TestReport();

            var sample = new Puzzle(new string[]
            {
                "#############",
                "#...........#",
                "#...........#",
                "#...........#",
                "######.######",
                "#......x....#",
                "#o.........p#",
                "#############",
            });

            var staticMaps = new StaticMaps()
            {
                FloorMap = sample.ToMap('.', 'x','o', 'p'),
                WallMap = sample.ToMap('#')
            };

            var crate = sample.ToMap('X', 'x');
            var stateMaps = new StateMaps()
            {
                CrateMap = crate,
                MoveMap = FloodFill.Fill(staticMaps.WallMap.BitwiseOR(crate), sample.First(x => x.State == 'p').Position)
            };

            var from = sample.First(x => x.State == 'x').Position;
            var to = sample.First(x => x.State == 'p').Position;
            var pushMap = PushMap.Find(staticMaps, stateMaps, from, to);
            report.WriteLine(pushMap);

            Assert.That(report, Is.EqualTo(new TestReport(
            @".............
            .XXXXXXXXXXX.
            .XXXXXXXXXXX.
            .XXXXXXXXXXX.
            ......X......
            .XXXXXXXXXXX.
            .XXXXXXXXXXX.
            .............
            "
                )));

            var playerRoute = pushMap.FindPlayerWalkRoute(to);
            report.WriteLine("pushMap.FindPlayerWalkRoute(to)");
            report.WriteLine(playerRoute);

            var crateRoute = pushMap.FindCrateRoute(to);
            report.WriteLine("pushMap.FindCrateRoute(to)");
            report.WriteLine(crateRoute);
        }
 public ReportReaderService(TestReport tItem, Int32 SafeTimeOutSetting)
     : base(tItem, SafeTimeOutSetting)
 {
 }
Example #48
0
        public void Regression1()
        {
            var report = new TestReport();
            var defaultPuzzle = new Puzzle(); // default puzzle
            var analysis = new PuzzleAnalysis(defaultPuzzle);
            var state = analysis.Evalute(defaultPuzzle);

            var pushMap = PushMap.Find(state, new VectorInt2(3,3), defaultPuzzle.Player.Position);

            report.WriteLine("===================");
            report.WriteLine(defaultPuzzle);
            report.WriteLine(pushMap);
            report.WriteLine("===================");

            var r = pushMap.FindPlayerWalkRoute(new VectorInt2(7, 3));
            report.WriteLine(r);

            Assert.That(report, Is.EqualTo(new TestReport(
            @"===================
            #~~###~~~~#
            ~~##.#~####
            ~##..###..#
            ##.X......#
            #...PX.#..#
            ###.X###..#
            ~~#..#OO..#
            ~##.##O#.##
            ~#......##~
            ~#.....##~~
            ########~~~

            ...........
            ....X......
            ...XX...XX.
            ..XXXXXXXX.
            .XXXX...XX.
            ...X....XX.
            ...X..XXXX.
            ...X..X.X..
            ..XXXXXX...
            ..XXXXX....
            ...........

            ===================
            LLURRRR
            "
                )));
        }
 protected abstract void DataSeeker(StreamReader tReadStream, TestReport tReport);
        public void DynamicDeadMap()
        {
            // Init
            var report = new TestReport();

            var p = new Puzzle(
                new string[]
                {
                    "##########",
                    "#...XX...#",
                    "#...X#...#",
                    "#.P......#",
                    "##########",
                });
            var stat = StaticAnalysis.Generate(p);

            Assert.That(DeadMapAnalysis.DynamicCheck(stat, StateMaps.Create(p)), Is.True);

             p = new Puzzle(
               new string[]
                {
                    "##########",
                    "#...#X...#",
                    "#...X#...#",
                    "#.P......#",
                    "##########",
                });
            stat = StaticAnalysis.Generate(p);
            Assert.That(DeadMapAnalysis.DynamicCheck(stat, StateMaps.Create(p)), Is.True);

            p = new Puzzle(
             new string[]
                {
                    "##########",
                    "#...##...#",
                    "#...XX...#",
                    "#.P......#",
                    "##########",
                });
            stat = StaticAnalysis.Generate(p);
            Assert.That(DeadMapAnalysis.DynamicCheck(stat, StateMaps.Create(p)), Is.True);

            p = new Puzzle(
             new string[]
                {
                    "##########",
                    "#........#",
                    "#...XX...#",
                    "#...##...#",
                    "#.P......#",
                    "##########",
                });
            stat = StaticAnalysis.Generate(p);
            Assert.That(DeadMapAnalysis.DynamicCheck(stat, StateMaps.Create(p)), Is.True);

            p = new Puzzle(
               new string[]
                {
                    "##########",
                    "#........#",
                    "#...XX...#",
                    "#...X#...#",
                    "#.P......#",
                    "##########",
                });
            stat = StaticAnalysis.Generate(p);
            Assert.That(DeadMapAnalysis.DynamicCheck(stat, StateMaps.Create(p)), Is.True);

            p = new Puzzle(
             new string[]
                {
                    "##########",
                    "#........#",
                    "#...$$...#",
                    "#...$#...#",
                    "#.P......#",
                    "##########",
                });
            stat = StaticAnalysis.Generate(p);
            Assert.That(DeadMapAnalysis.DynamicCheck(stat, StateMaps.Create(p)), Is.False);

            p = new Puzzle(
               new string[]
                {
                    "##########",
                    "#........#",
                    "#...$$...#",
                    "#...X#...#",
                    "#.P......#",
                    "##########",
                });
            stat = StaticAnalysis.Generate(p);
            Assert.That(DeadMapAnalysis.DynamicCheck(stat, StateMaps.Create(p)), Is.True);

            p = new Puzzle(
               new string[]
                {
                    "##########",
                    "#........#",
                    "#...$$...#",
                    "#...#X...#",
                    "#.P......#",
                    "##########",
                });
            stat = StaticAnalysis.Generate(p);
            Assert.That(DeadMapAnalysis.DynamicCheck(stat, StateMaps.Create(p)), Is.True);

            p = new Puzzle(
              new string[]
                {
                    "##########",
                    "#........#",
                    "#...#X...#",
                    "#...$$...#",
                    "#.P......#",
                    "##########",
                });
            stat = StaticAnalysis.Generate(p);
            Assert.That(DeadMapAnalysis.DynamicCheck(stat, StateMaps.Create(p)), Is.True);
        }
        public void Recesses()
        {
            // Init
            var report = new TestReport();

            var stat = StaticAnalysis.Generate(TestLibrary.Default);

            Assert.That(stat.RecessMap, Is.Not.Null);
            foreach (var recess in stat.RecessMap)
            {
                report.WriteLine(recess);
            }

            Assert.That(report, Is.EqualTo(new TestReport(
                @"(8,2) => (9,2)
            ...........
            ...........
            ........XX.
            ...........
            ...........
            ...........
            ...........
            ...........
            ...........
            ...........
            ...........

            (2,9) => (6,9)
            ...........
            ...........
            ...........
            ...........
            ...........
            ...........
            ...........
            ...........
            ...........
            ..XXXXX....
            ...........

            (2,8) => (2,9)
            ...........
            ...........
            ...........
            ...........
            ...........
            ...........
            ...........
            ...........
            ..X........
            ..X........
            ...........

            (9,2) => (9,6)
            ...........
            ...........
            .........X.
            .........X.
            .........X.
            .........X.
            .........X.
            ...........
            ...........
            ...........
            ..........."
                )));
        }