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)
}
}
});
}
