public void TestDetermineHierarchy01()
{
DetermineHierarchyTest test = new DetermineHierarchyTest();
TemplateInSet templateInSet = test.CreateTemplateInSet("SubTemplate");
TemplateInSet baseTemplateInSet = test.CreateTemplateInSet("BaseTemplate");
test.Run(new Dictionary<TemplateInSetBase, IEnumerable<TemplateInSetBase>>()
{
{templateInSet, new TemplateInSet[] { baseTemplateInSet }},
{baseTemplateInSet, null}
});
Assert.AreSame(baseTemplateInSet, templateInSet.BaseTemplateInSet);
Assert.IsNull(baseTemplateInSet.BaseTemplateInSet);
}
public void TestDetermineHierarchy05()
{
DetermineHierarchyTest test = new DetermineHierarchyTest();
// hierarchy mappings:
// A > B > C
// > D > E > F
// G > H
TemplateInSet templateA = test.CreateTemplateInSet("A");
TemplateInSet templateB = test.CreateTemplateInSet("B");
TemplateInSet templateC = test.CreateTemplateInSet("C");
TemplateInSet templateD = test.CreateTemplateInSet("D");
TemplateInSet templateE = test.CreateTemplateInSet("E");
TemplateInSet templateF = test.CreateTemplateInSet("F");
TemplateInSet templateG = test.CreateTemplateInSet("G");
TemplateInSet templateH = test.CreateTemplateInSet("H");
Dictionary<TemplateInSetBase, IEnumerable<TemplateInSetBase>> mappings = new Dictionary<TemplateInSetBase, IEnumerable<TemplateInSetBase>>()
{
{templateA, null},
{templateB, new TemplateInSet[] { templateA }},
{templateC, new TemplateInSet[] { templateB }},
{templateD, new TemplateInSet[] { templateA }},
{templateE, new TemplateInSet[] { templateD }},
{templateF, new TemplateInSet[] { templateE }},
{templateG, null},
{templateH, new TemplateInSet[] { templateG }}
};
mappings.Reverse();
test.Run(mappings);
Assert.IsNull(templateA.BaseTemplateInSet);
Assert.IsNull(templateG.BaseTemplateInSet);
Assert.AreSame(templateA, templateB.BaseTemplateInSet);
Assert.AreSame(templateB, templateC.BaseTemplateInSet);
Assert.AreSame(templateA, templateD.BaseTemplateInSet);
Assert.AreSame(templateD, templateE.BaseTemplateInSet);
Assert.AreSame(templateE, templateF.BaseTemplateInSet);
Assert.AreSame(templateG, templateH.BaseTemplateInSet);
}
public void TestDetermineHierarchyForContributingTemplates01()
{
DetermineHierarchyTest test = new DetermineHierarchyTest();
// hierarchy mappings:
// A > B > C
// > D > E > F
// G >
// H > J
// I >
ContributingTemplateInSet templateA = test.CreateContributingTemplateInSet("A");
ContributingTemplateInSet templateB = test.CreateContributingTemplateInSet("B");
ContributingTemplateInSet templateC = test.CreateContributingTemplateInSet("C");
ContributingTemplateInSet templateD = test.CreateContributingTemplateInSet("D");
ContributingTemplateInSet templateE = test.CreateContributingTemplateInSet("E");
ContributingTemplateInSet templateF = test.CreateContributingTemplateInSet("F");
ContributingTemplateInSet templateG = test.CreateContributingTemplateInSet("G");
ContributingTemplateInSet templateH = test.CreateContributingTemplateInSet("H");
ContributingTemplateInSet templateI = test.CreateContributingTemplateInSet("I");
ContributingTemplateInSet templateJ = test.CreateContributingTemplateInSet("J");
Dictionary<TemplateInSetBase, IEnumerable<TemplateInSetBase>> mappings = new Dictionary<TemplateInSetBase, IEnumerable<TemplateInSetBase>>()
{
{templateA, null},
{templateB, new ContributingTemplateInSet[] { templateA }},
{templateC, new ContributingTemplateInSet[] { templateB }},
{templateD, new ContributingTemplateInSet[] { templateA }},
{templateE, new ContributingTemplateInSet[] { templateD }},
{templateF, new ContributingTemplateInSet[] { templateE }},
{templateG, null},
{templateH, new ContributingTemplateInSet[] { templateG, templateI }},
{templateI, null},
{templateJ, new ContributingTemplateInSet[] { templateH }}
};
mappings.Reverse();
test.Run(mappings);
Assert.IsNull(templateA.BaseContributingTemplatesInSet);
Assert.IsNull(templateG.BaseContributingTemplatesInSet);
Assert.IsNull(templateI.BaseContributingTemplatesInSet);
Assert.AreSame(templateA, templateB.BaseContributingTemplatesInSet.First());
Assert.AreSame(templateB, templateC.BaseContributingTemplatesInSet.First());
Assert.AreSame(templateA, templateD.BaseContributingTemplatesInSet.First());
Assert.AreSame(templateD, templateE.BaseContributingTemplatesInSet.First());
Assert.AreSame(templateE, templateF.BaseContributingTemplatesInSet.First());
Assert.AreSame(templateH, templateJ.BaseContributingTemplatesInSet.First());
Assert.IsTrue(templateH.BaseContributingTemplatesInSet.Contains(templateG));
Assert.IsTrue(templateH.BaseContributingTemplatesInSet.Contains(templateI));
Assert.IsFalse(templateC.BaseContributingTemplatesInSet.Contains(templateA));
Assert.IsFalse(templateF.BaseContributingTemplatesInSet.Contains(templateD));
Assert.IsFalse(templateF.BaseContributingTemplatesInSet.Contains(templateA));
Assert.IsFalse(templateE.BaseContributingTemplatesInSet.Contains(templateA));
Assert.IsFalse(templateJ.BaseContributingTemplatesInSet.Contains(templateG));
Assert.IsFalse(templateJ.BaseContributingTemplatesInSet.Contains(templateI));
}
public void TestDetermineHierarchy03()
{
DetermineHierarchyTest test = new DetermineHierarchyTest();
TemplateInSet templateInSet = test.CreateTemplateInSet("SubTemplate");
TemplateInSet baseTemplateInSet = test.CreateTemplateInSet("BaseTemplate");
TemplateInSet baseTemplateInSet2 = test.CreateTemplateInSet("BaseTemplate2");
try
{
test.Run(new Dictionary<TemplateInSetBase, IEnumerable<TemplateInSetBase>>()
{
{templateInSet, new TemplateInSet[] { baseTemplateInSet, baseTemplateInSet2 }},
{baseTemplateInSet, null},
{baseTemplateInSet2, null}
});
Assert.Fail("Exception should have been thrown");
}
catch (MultipleInheritanceException exc)
{
Assert.IsTrue(exc.TemplateNames.Count() == 1);
Assert.AreEqual(templateInSet.TemplateName, exc.TemplateNames.First());
}
}