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(); }
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); }
/// <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#.## ##......### ##.....#### ########### " ))); }
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.......... ............. ............." ))); }
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); }
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); }
/// <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"); }
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; } }
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)); }
}//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
/// <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); } }
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); }
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"); }
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")); }
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); }
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)); }
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)); }
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"); }
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))); }
public bool bInsertUpdateTestReport(TestReport o) { return(oD.dInsertUpdateTestReport(o)); }
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)) ); }
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.. ............. " ))); }
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. ...... " ))); }
public static void Close() { Driver.Instance.Quit(); TestReport.Log(LogStatus.Pass, "Browser closed"); }
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. ........... ........... ........... ........... " ))); }
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))); }
public void CreateTestReportAsync(TestReport testReport) { _testReportRepository.AddTestReport(testReport); }
public static void GoBack() { Driver.Instance.Navigate().Back(); TestReport.Log(LogStatus.Pass, "Navigated back"); }
public static TestReportCollection ToTestReportCollection(this TestReport testReport) { return(new TestReportCollection { testReport }); }
public static void RefreshPage() { Driver.Instance.Navigate().Refresh(); TestReport.Log(LogStatus.Pass, "Page refreshed"); }
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) { }
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) { }
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. ........... ........... ........... ..........." ))); }