public void TestPlanTotalsReporting() { TestPlan plan = proxy.getTestPlanByName(testProjectName, theTestPlanName); Assert.IsNotNull(plan, "can't proceed. No plan found"); Console.WriteLine("Getting totals for plan {0}:{1}", plan.id, plan.name); List <TestPlanTotal> list = proxy.GetTotalsForTestPlan(plan.id); Assert.IsNotEmpty(list, "Expected to get results"); foreach (TestPlanTotal tpt in list) { Console.WriteLine("Name='{0}' Type='{1}' Total:{2}", tpt.Name, tpt.Type, tpt.Total_tc); Dictionary <string, int> det = tpt.Details; foreach (string key in det.Keys) { Console.WriteLine(" '{0}': '{1}'", key, det[key]); } } }
public void AutoRemoveParameters() { var plan = new TestPlan(); var step = new DelayStep(); plan.ChildTestSteps.Add(step); var member = TypeData.GetTypeData(step).GetMember(nameof(step.DelaySecs)); var parameter = member.Parameterize(plan, step, "delay"); Assert.IsNotNull(TypeData.GetTypeData(plan).GetMember(parameter.Name)); plan.ChildTestSteps.Remove(step); Assert.IsNull(TypeData.GetTypeData(plan).GetMember(parameter.Name)); var seq = new SequenceStep(); plan.ChildTestSteps.Add(seq); seq.ChildTestSteps.Add(step); parameter = member.Parameterize(seq, step, "delay"); Assert.IsNotNull(TypeData.GetTypeData(seq).GetMember(parameter.Name)); seq.ChildTestSteps.Remove(step); Assert.IsNull(TypeData.GetTypeData(seq).GetMember(parameter.Name)); seq.ChildTestSteps.Add(step); parameter = member.Parameterize(seq, step, "delay"); var member2 = TypeData.GetTypeData(seq).GetMember(parameter.Name); Assert.IsNotNull(member2); Assert.AreEqual(member2, parameter); var parameter2 = member2.Parameterize(plan, seq, "delay"); Assert.IsNotNull(TypeData.GetTypeData(plan).GetMember(parameter2.Name)); plan.ChildTestSteps.Remove(seq); Assert.IsNull(TypeData.GetTypeData(plan).GetMember(parameter2.Name)); Assert.IsNotNull(TypeData.GetTypeData(seq).GetMember(parameter.Name)); plan.ChildTestSteps.Add(seq); parameter2 = member2.Parameterize(plan, seq, "delay"); Assert.IsNotNull(TypeData.GetTypeData(plan).GetMember(parameter2.Name)); Assert.IsNotNull(TypeData.GetTypeData(seq).GetMember(parameter.Name)); seq.ChildTestSteps.Remove(step); Assert.IsNull(TypeData.GetTypeData(plan).GetMember(parameter2.Name)); Assert.IsNull(TypeData.GetTypeData(seq).GetMember(parameter.Name)); }
public void SweepSameNameDifferentGroup() { var loop = new SweepLoop(); var a = new StepTypeA(); var b = new StepTypeB(); loop.ChildTestSteps.Add(a); loop.ChildTestSteps.Add(b); loop.SweepParameters.Add(new SweepParam(new [] { TypeData.GetTypeData(a).GetMember(nameof(StepTypeA.Property)) }, (double)5, (double)5)); loop.SweepParameters.Add(new SweepParam(new [] { TypeData.GetTypeData(b).GetMember(nameof(StepTypeB.Property)) }, (double)15, (double)15)); var plan = new TestPlan(); plan.Steps.Add(loop); var run = plan.Execute(); Assert.AreEqual(Verdict.Pass, run.Verdict); }
public void GeneralPerformanceTest(int count) { void buildSequence(ITestStepParent parent, int levels) { parent.ChildTestSteps.Add(new ManySettingsStep()); parent.ChildTestSteps.Add(new DeferringResultStep()); parent.ChildTestSteps.Add(new VirtualPropertiesStep()); for (int i = 0; i < levels; i++) { var seq = new SequenceStep(); parent.ChildTestSteps.Add(seq); buildSequence(seq, levels / 2); } } var plan = new TestPlan { CacheXml = true }; buildSequence(plan, 6); var total = Utils.FlattenHeirarchy(plan.ChildTestSteps, x => x.ChildTestSteps).Count(); plan.Execute(); // warm up TimeSpan timeSpent = TimeSpan.Zero; for (int i = 0; i < count; i++) { using (TypeData.WithTypeDataCache()) { timeSpent += plan.Execute().Duration; } } var proc = Process.GetCurrentProcess(); var time = proc.TotalProcessorTime; var time2 = DateTime.Now - proc.StartTime; var spentMs = timeSpent.TotalMilliseconds / count; Console.WriteLine("Time spent per plan: {0}ms", spentMs); Console.WriteLine("Time spent per step: {0}ms", spentMs / plan.Steps.Count); }
public void ResourceStepTest() { InstrumentSettings.Current.Clear(); ResultSettings.Current.Clear(); InstrumentSettings.Current.Add(new CircDummyInst()); var tp = new TestPlan(); tp.ChildTestSteps.Add(new ResourceStep() { Inst = InstrumentSettings.Current[0] }); var run = tp.Execute(); Assert.AreEqual(1, run.StepsWithPrePlanRun.Count); Assert.IsFalse(run.FailedToStart); }
public void Configure(HashTree testTree) { // Is testplan serialised? SearchByType <TestPlan> testPlan = new SearchByType <TestPlan>(); testTree.Traverse(testPlan); List <TestPlan> plan = testPlan.GetSearchResults(); if (0 == plan.Count) { throw new Exception("Could not find the TestPlan class!"); } TestPlan tp = (TestPlan)plan[0]; serialized = tp.isSerialized(); tearDownOnShutdown = tp.isTearDownOnShutdown(); active = true; test = testTree; }
public void Draw_PassesCorrectSizeToSource() { Size passedSize = default; TestPlan .For(x => new DynamicImage { Source = size => { passedSize = size; return(GenerateImage(size)); } }) .DrawElement(new Size(400, 300)) .ExpectCanvasDrawImage(Position.Zero, new Size(400, 300)) .CheckDrawResult(); passedSize.Should().BeEquivalentTo(new Size(400, 300)); }
/// <summary> /// Get Test Plan Properties /// </summary> /// <param name="TeamProjectName"></param> /// <param name="TestPlanId"></param> static void TestPlanDetails(string TeamProjectName, int TestPlanId) { TestPlan testPlan = TestPlanClient.GetTestPlanByIdAsync(TeamProjectName, TestPlanId).Result; Console.WriteLine("================================================================"); Console.WriteLine("Test Plan : {0} : {1} : {2}", testPlan.Id, testPlan.State, testPlan.Name); Console.WriteLine("Area Path : {0} : Iteration Path : {1}", testPlan.AreaPath, testPlan.Iteration); Console.WriteLine("Plan Dates : {0} - {1}", (testPlan.StartDate.HasValue) ? testPlan.StartDate.Value.ToShortDateString() : "none", (testPlan.EndDate.HasValue) ? testPlan.EndDate.Value.ToShortDateString() : "none"); //Get test suites by one request List <TestSuite> suitesDetail = TestPlanClient.GetTestSuitesForPlanAsync(TeamProjectName, TestPlanId, asTreeView: true).Result; ExploreTestSuiteTree(TeamProjectName, TestPlanId, suitesDetail, ""); //Query each test suite //TestSuiteDetails(TeamProjectName, testPlan.Id, testPlan.RootSuite.Id, ""); }
public void Measure_ReturnsWrap_WhenNotPageable_AndAnyChildReturnsPartialRender() { TestPlan .For(x => new Stack { Spacing = 50, Pageable = false, Children = new [] { x.CreateChild("a"), x.CreateChild("b"), x.CreateChild("d"), x.CreateChild("e") } }) .MeasureElement(new Size(500, 1000)) .ExpectChildMeasure("a", expectedInput: new Size(500, 1000), returns: new FullRender(400, 200)) .ExpectChildMeasure("b", expectedInput: new Size(500, 750), returns: new PartialRender(300, 500)) .CheckMeasureResult(new Wrap()); }
public void RunCompositeMetaData() { PlanRunCollectorListener listener = new PlanRunCollectorListener(); ResultSettings.Current.Add(listener); TestTraceListener trace = new TestTraceListener(); Log.AddListener(trace); TestPlan target = getTestTestPlan(); TestPlanRun run = target.Execute(); Log.RemoveListener(trace); ResultSettings.Current.Remove(listener); Assert.IsTrue(run.Parameters.Any(par => par.Value.ToString() == "Test Instrument")); Assert.IsFalse(run.Parameters.Any(par => par.Name == "Comment")); }
/// <summary> /// find a testplan within the automated test project sandbox /// </summary> /// <param name="testPlanName"></param> /// <returns></returns> protected TestPlan getTestPlan(string testPlanName) { List <TestPlan> plans = proxy.GetProjectTestPlans(ApiTestProjectId); //Assert.IsNotEmpty(plans, "Setup failed, couldn't find testplans for project {0}", testProjectName); plan = null; foreach (TestPlan candidate in plans) { if (candidate.name == testPlanName) { plan = candidate; break; } } if (plan == null) { Assert.Fail("Setup failed, could not find test plan named '{0}' in project '{1}'", testPlanName, testProjectName); } return(plan); }
public void TestPlanReferenceNameTest() { var step = new DelayStep(); var testPlanReference = new TestPlanReference(); var repeatStep = new RepeatStep(); repeatStep.ChildTestSteps.Add(testPlanReference); var plan = new TestPlan(); plan.ChildTestSteps.Add(step); plan.ChildTestSteps.Add(repeatStep); var mem = AnnotationCollection.Annotate(repeatStep).Get <IMembersAnnotation>().Members .FirstOrDefault(x => x.Get <IMemberAnnotation>().Member.Name == nameof(RepeatStep.TargetStep)); var avail = mem.Get <IAvailableValuesAnnotationProxy>().AvailableValues; var availStrings = avail.Select(x => x.Get <IStringReadOnlyValueAnnotation>().Value).ToArray(); Assert.IsTrue(availStrings.Contains(step.GetFormattedName())); Assert.IsTrue(availStrings.Contains(testPlanReference.GetFormattedName())); }
/// <summary> /// Serializes an object to XML. /// </summary> /// <param name="element"></param> /// <param name="obj"></param> /// <param name="expectedType"></param> /// <returns></returns> public override bool Serialize(XElement element, object obj, ITypeData expectedType) { if (obj is TestPlan == false || currentNode.Contains(element)) { return(false); } var prevPlan = Plan; Plan = (TestPlan)obj; currentNode.Add(element); try { return(Serializer.Serialize(element, obj)); } finally { Plan = prevPlan; currentNode.Remove(element); } }
public void RunCompositeRunTwice() { TestTraceListener trace = new TestTraceListener(); Log.AddListener(trace); TestPlan target = getTestTestPlan(); target.Open(); target.Execute(); target.Execute(); target.Close(); Log.RemoveListener(trace); trace.AssertErrors(); TestTestStep step = target.Steps[0] as TestTestStep; Assert.AreEqual(2, step.PrePlanRunCount, "PrePlanRun was not called the correct number of times."); Assert.AreEqual(2, step.PostPlanRunCount, "PostPlanRun was not called the correct number of times."); }
/// <summary> /// Deserializes a test plan from XML. /// </summary> /// <param name="element"></param> /// <param name="_t"></param> /// <param name="setter"></param> /// <returns></returns> public override bool Deserialize(XElement element, ITypeData _t, Action <object> setter) { if (_t.IsA(typeof(TestPlan)) == false) { return(false); } var prevPlan = Plan; Plan = new TestPlan { Path = Serializer.ReadPath }; try { return(TryDeserializeObject(element, _t, setter, Plan)); } finally { Plan = prevPlan; } }
public void TestStepWaitInfiniteAndAbortTest() { var plan = new TestPlan(); var parallel = new ParallelStep(); var abort = new TestStepAbortPlan() { WaitFor = new TestStepWaitInfinite() }; parallel.ChildTestSteps.Add(abort); parallel.ChildTestSteps.Add(abort.WaitFor); plan.ChildTestSteps.Add(parallel); var run = plan.Execute(); Assert.AreEqual(Verdict.Aborted, run.Verdict); foreach (var step in parallel.ChildTestSteps) { Assert.AreEqual(Verdict.Aborted, step.Verdict); } }
public void SimpleTestDefaultManager() { EngineSettings.Current.ResourceManagerType = new ResourceTaskManager(); IInstrument instr1 = new SomeInstrument() { Name = "INSTR1" }; IInstrument instr2 = new SomeInstrument() { Name = "INSTR2" }; InstrumentSettings.Current.Add(instr1); InstrumentSettings.Current.Add(instr2); TestPlan plan = new TestPlan(); ITestStep step1 = new InstrumentTestStep() { Instrument = instr1 }; plan.Steps.Add(step1); ITestStep step2 = new InstrumentTestStep() { Instrument = instr2 }; plan.Steps.Add(step2); UnitTestingLockManager.Enable(); plan.Execute(); UnitTestingLockManager.Disable(); Assert.AreEqual(1, UnitTestingLockManager.BeforeOpenArgs.Count(), "BeforeOpen hook called an unexpected number of times."); Assert.AreEqual(2, UnitTestingLockManager.BeforeOpenArgs.First().Count(), "Resources list contain an unexpected number of items."); Assert.AreEqual(instr1, UnitTestingLockManager.BeforeOpenArgs.First().First().Resource, "ResourceReference has unexpected Resource."); Assert.AreEqual(1, UnitTestingLockManager.BeforeOpenArgs.First().First().References.Count(), "ResourceReference has unexpected number of references."); Assert.AreEqual(step1, UnitTestingLockManager.BeforeOpenArgs.First().First().References.First().Instance, "ResourceReference references unexpected object."); Assert.AreEqual(step1.GetType().GetProperty("Instrument"), UnitTestingLockManager.BeforeOpenArgs.First().First().References.First().Property, "ResourceReference references unexpected property."); Assert.AreEqual(TypeData.GetTypeData(step1).GetMember("Instrument"), UnitTestingLockManager.BeforeOpenArgs.First().First().References.First().Member, "ResourceReference references unexpected property."); Assert.AreEqual(instr2, UnitTestingLockManager.BeforeOpenArgs.First().Last().Resource, "Resource has unexpected value."); }
public System.Net.Http.HttpResponseMessage GetResponseMethod(string api) { TestPlan testData = new TestPlan(); try { using (var client = new HttpClient()) { client.DefaultRequestHeaders.Accept.Clear(); client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", Org.pat);//Org.pat); HttpResponseMessage response = client.GetAsync(api).Result; return(response); } return(null); } catch { return(null); } }
public void MultipleDraw_WhenNotPageable() { TestPlan .For(x => new Stack { Spacing = 50, Pageable = false, Children = new [] { x.CreateChild("a") } }) .MeasureElement(new Size(500, 1000)) .ExpectChildMeasure("a", expectedInput: new Size(500, 1000), returns: new FullRender(400, 200)) .CheckMeasureResult(new FullRender(500, 200)) // second measure resets element state .MeasureElement(new Size(500, 1000)) .ExpectChildMeasure("a", expectedInput: new Size(500, 1000), returns: new FullRender(400, 200)) .CheckMeasureResult(new FullRender(500, 200)); }
public async Task <bool> CreateTestPlan(TestPlan entity) { try { var result = false; _dataRepositories.TestPlanRepository.Add(entity); _dataRepositories.TestPlanRepository.Save(); if (entity.TestPlanId != Guid.NewGuid()) { result = true; } //entity.BusinessUnit = // Task.Run(async () => await _dataRepositories.BusinessUnitRepository.GetById(entity.BusinessUnitId)) // .Result; return(await Task.FromResult(result)); } catch (Exception e) { throw new Exception(e.Message); } }
private void GenerateTestPlanWithNDelaySteps(int stepsCount, string filePath, double defaultValue, string externalParameterName) { Assert.IsTrue(stepsCount > 0); // Create a test plan with two DelaySteps. // Each of the DelaySteps will expose a it's delay property as an external parameter. TestPlan plan = new TestPlan(); for (int i = 0; i < stepsCount; i++) { var delayStep = new DelayStep { DelaySecs = defaultValue }; plan.ChildTestSteps.Add(delayStep); var delayInfo = TypeData.GetTypeData(delayStep); plan.ExternalParameters.Add(delayStep, delayInfo.GetMember("DelaySecs"), externalParameterName); } // Write the test plan to a file plan.Save(filePath); }
public static void SaveAllLocalSettings(TestPlan testPlan) { string fileName = Environment.CurrentDirectory + "/local files/" + testPlan.DisplayName + ".xml"; if (!Directory.Exists(Path.GetDirectoryName(fileName))) { Directory.CreateDirectory(Path.GetDirectoryName(fileName)); } List <object> localSettings = new List <object>(); localSettings.Add(testPlan.GuidStr); localSettings.Add(DateTime.Now.ToString()); foreach (var step in TestStep.GetAllTestStep(testPlan)) { localSettings.Add(step.GetLocalSetting()); } byte[] localSettingsbytes = SerializerStepData(localSettings); System.IO.File.WriteAllBytes(fileName, localSettingsbytes.ToArray()); }
public void BreakJumpToStepRunNull() { testplanJumpToStep = new TestPlan(); SequenceStep step1 = new SequenceStep(); SequenceStep step2 = new SequenceStep(); SequenceStep step3 = new SequenceStep(); testplanJumpToStep.Steps.Add(step1); testplanJumpToStep.Steps.Add(step2); testplanJumpToStep.Steps.Add(step3); testplanJumpToStep.BreakOffered += Testplan_BreakOffered; firstBreak = true; testplanJumpToStep.Execute(); foreach (var step in testplanJumpToStep.Steps) { Assert.IsNull(step.StepRun); } }
public void TestAutoRemoveInputOutputRelation() { var plan = new TestPlan(); var delay1 = new DelayStep(); var delay2 = new DelayStep(); plan.ChildTestSteps.Add(delay1); plan.ChildTestSteps.Add(delay2); { var member = TypeData.GetTypeData(delay1).GetMember(nameof(DelayStep.DelaySecs)); InputOutputRelation.Assign(delay2, member, delay1, member); Assert.IsTrue(InputOutputRelation.IsInput(delay2, member)); Assert.IsTrue(InputOutputRelation.IsOutput(delay1, member)); } plan.ChildTestSteps.Remove(delay2); { var member = TypeData.GetTypeData(delay1).GetMember(nameof(DelayStep.DelaySecs)); Assert.IsFalse(InputOutputRelation.IsInput(delay2, member)); Assert.IsFalse(InputOutputRelation.IsOutput(delay1, member)); } }
private static void GetTestPlans(ITestManagementTeamProject testproject, int TeamId) { ITestPlanCollection plans = testproject.TestPlans.Query("Select * From TestPlan"); List <TestPlan> testPlans = new List <TestPlan>(); foreach (ITestPlan plan in plans) { TestPlan testPlan = new TestPlan(); testPlan.TeamId = TeamId; testPlan.TestPlanName = plan.Name; testPlan.PlanId = plan.Id; testPlan.TestCaseCount = 0; if (plan.RootSuite != null && plan.RootSuite.Entries.Count > 0) { var Suites = GetPlanSuites(plan.RootSuite.Entries); foreach (var suite in Suites) { suite.TestPlan = testPlan; testPlan.TestSuites.Add(suite); } } testPlans.Add(testPlan); } foreach (var item in testPlans) { item.TestCaseCount = item.TestSuites.Where(s => s.ParentSuite == -1).Sum(col => col.TotalTests); } DeleteTestSuitesFromDB(TeamId); foreach (var testPlan in testPlans) { db.TestPlans.Add(testPlan); db.Entry(testPlan).State = System.Data.Entity.EntityState.Added; } db.SaveChanges(); }
public void SerializeDeserializeWithDutExternalParameter() { var plan = new TestPlan(); var step = new TestPlanTest.DutStep(); var dut1 = new DummyDut { Name = "DUT1" }; var dut2 = new DummyDut { Name = "DUT2" }; DutSettings.Current.AddRange(new [] { dut1, dut2 }); try { step.Dut = dut1; plan.ChildTestSteps.Add(step); plan.ExternalParameters.Add(step, TypeData.GetTypeData(step).GetMember(nameof(TestPlanTest.DutStep.Dut)), "dut"); using (var memstr = new MemoryStream()) { plan.Save(memstr); var serializer = new TapSerializer(); var ext = serializer.GetSerializer <ExternalParameterSerializer>(); ext.PreloadedValues["dut"] = "DUT2"; memstr.Seek(0, SeekOrigin.Begin); plan = (TestPlan)serializer.Deserialize(memstr); } step = (TestPlanTest.DutStep)plan.ChildTestSteps[0]; Assert.AreEqual(step.Dut, dut2); } finally { DutSettings.Current.Remove(dut1); DutSettings.Current.Remove(dut2); } }
public void RunParseTest() { var setVerdict = new OpenTap.Engine.UnitTests.TestTestSteps.VerdictStep(); TestPlan plan = new TestPlan(); plan.Steps.Add(setVerdict); plan.ExternalParameters.Add(setVerdict, TypeData.GetTypeData(setVerdict).GetMember("VerdictOutput"), "verdict"); plan.ExternalParameters.Get("verdict").Value = "Not Set"; plan.Save("verdictPlan.TapPlan"); var fileName = CreateCsvTestFile(new string[] { "verdict" }, new object[] { "pass" }); { string[] passingThings = new[] { "verdict=\"pass\"", "verdict=\"Not Set\"", "verdict=\"not set\"", fileName }; passingThings.AsParallel().ForAll(v => { var args = string.Format("run verdictPlan.TapPlan -e {0}", v); Log.CreateSource("RunParseTest").Debug("Running tap {0}", args); var proc = TapProcessContainer.StartFromArgs(string.Format("run verdictPlan.TapPlan -e {0}", v), TimeSpan.FromMinutes(5)); proc.WaitForEnd(); Assert.AreEqual(0, proc.TapProcess.ExitCode); }); } { string[] passingThings = new[] { "fail", "Error" }; passingThings.AsParallel().ForAll(v => { var args = string.Format("run verdictPlan.TapPlan -e verdict=\"{0}\"", v); Log.CreateSource("RunParseTest").Debug("Running tap {0}", args); var proc = TapProcessContainer.StartFromArgs(args, TimeSpan.FromSeconds(120)); proc.WaitForEnd(); if (v == "Error") { Assert.AreEqual((int)ExitStatus.RuntimeError, proc.TapProcess.ExitCode); } else { Assert.AreEqual((int)ExitStatus.TestPlanFail, proc.TapProcess.ExitCode); } }); } }
public void Draw() { TestPlan .For(x => new ShowOnce() { Child = x.CreateChild() }) // Measure the element and return result .MeasureElement(new Size(300, 200)) .ExpectChildMeasure("child", new Size(300, 200), SpacePlan.PartialRender(new Size(200, 200))) .CheckMeasureResult(SpacePlan.PartialRender(new Size(200, 200))) // Draw element partially .DrawElement(new Size(200, 200)) .ExpectChildMeasure(new Size(200, 200), SpacePlan.PartialRender(new Size(200, 200))) .ExpectChildDraw(new Size(200, 200)) .CheckDrawResult() // Element was not fully drawn // It should be measured again for rendering on next page .MeasureElement(new Size(800, 200)) .ExpectChildMeasure(new Size(800, 200), SpacePlan.FullRender(new Size(400, 200))) .CheckMeasureResult(SpacePlan.FullRender(new Size(400, 200))) // Draw element on next page // Element was fully drawn at this point .DrawElement(new Size(400, 200)) .ExpectChildMeasure(new Size(400, 200), SpacePlan.FullRender(new Size(400, 200))) .ExpectChildDraw(new Size(400, 200)) .CheckDrawResult() // In the next attempt of measuring element, it should behave like empty parent. .MeasureElement(new Size(600, 200)) .CheckMeasureResult(SpacePlan.FullRender(0, 0)) // In the next attempt of measuring element, it should not draw its child .DrawElement(new Size(600, 200)) .CheckDrawResult(); }
private bool GetStatusFile(string id) { IsLoad = false; DataSet ds = null; if (DataUtils.StaticInfo.MesMode.ToLower() == "true") { ds = DataUtils.DB.GetDataSetFromSQL(string.Format("SELECT StateData,Material FROM SYS_TEST_PLAN WHERE FILEID='{0}'", id)); } else { ds = DataUtils.DB.GetDataSetFromSQL(string.Format("SELECT StateData, FileName as Material FROM ATE_TEST_FILE WHERE FILEID='{0}'", id)); } if (ds.Tables[0].Rows.Count > 0) { TestPlanVM MTSM = new ViewModelLocator().CurrentTestPlanVm; if (ds.Tables[0].Rows[0]["StateData"] != System.DBNull.Value) { byte[] data = (byte[])ds.Tables[0].Rows[0]["StateData"]; TestPlan testPlan = new TestPlan(); object obj = Interface.DeSerializerStateModel(data, testPlan); testPlan = obj as TestPlan; if (testPlan != null) { MTSM.TestPlan = testPlan; IsLoad = true; } } else { MTSM.TestPlan = new TestPlan(); } MTSM.ApplyTestPlan(); MTSM.DisplayName = ds.Tables[0].Rows[0]["Material"].ToString(); (new ViewModelLocator()).MainWindow.StatusInfo.OpenProject = ds.Tables[0].Rows[0]["Material"].ToString(); (new ViewModelLocator()).MainWindow.StatusInfo.Material = MTSM.DisplayName; } return(IsLoad); }
private static Layers GetLayers(TestPlan x) { return(new Layers { Children = new List <Layer> { new Layer { Child = x.CreateChild(BackgroundLayer) }, new Layer { Child = x.CreateChild(MainLayer), IsPrimary = true }, new Layer { Child = x.CreateChild(ForegroundLayer) } } }); }