public void WhenSourceIsNonEmptyNode_ResultHasSameNumberOfChildren()
{
var source = CreateListTreeItem(CreatePrimitiveTreeItem(1), CreatePrimitiveTreeItem(2));
var actual = (DifferenceItemContainer)TreeComparer.FromBranchAdded(source);
Assert.That(actual.Children.Length, Is.EqualTo(2));
}
public void WhenSourceIsEmptyNode_ResultHasNoChildren()
{
var source = CreateListTreeItem();
var actual = (DifferenceItemContainer)TreeComparer.FromBranchAdded(source);
Assert.That(actual.Children.Length, Is.Zero);
}
public void WhenCurrentAndNextAreDifferentTypes_ReturnsModified()
{
var current = CreateListTreeItem();
var next = CreatePrimitiveTreeItem(1);
var actual = TreeComparer.CreateDifferenceTree(current, next);
Assert.That(actual.DiffType, Is.EqualTo(DiffType.Modified));
}
/// <summary>
/// Compares two object trees.
/// </summary>
private void _CompareObjectTree(object firstTree, object secondTree)
{
TreeCompareResult result = TreeComparer.CompareLogical(firstTree, secondTree);
if (CompareResult.Different == result.Result)
{
throw new Exception("Failure occurred while comparing object trees.");
}
}
public void WhenBothHaveNoChildren_ReturnsNull()
{
var current = CreateListTreeItem();
var next = CreateListTreeItem();
var actual = TreeComparer.FromList(current, next);
Assert.That(actual, Is.Null);
}
public void WhenSourceIsNode_ReturnsDifferenceItemContainerWithAdded()
{
var source = CreateListTreeItem();
var actual = TreeComparer.FromBranchAdded(source);
Assert.That(actual, Is.InstanceOf <DifferenceItemContainer>());
Assert.That(actual.DiffType, Is.EqualTo(DiffType.Added));
}
public void WhenSourceIsEmptyNode_ResultHasNoChildren()
{
var current = CreateListTreeItem();
var next = CreateListTreeItem();
var actual = (DifferenceItemContainer)TreeComparer.FromBranchModified(current, next);
Assert.That(actual.Children.Length, Is.Zero);
}
public void WhenSourceIsNode_DifferenceItemContainsCorrectSources()
{
var source = CreateListTreeItem();
var actual = TreeComparer.FromBranchAdded(source);
Assert.That(actual.Current, Is.Null);
Assert.That(actual.Next, Is.SameAs(source));
}
public void WhenSourceIsNonEmptyNode_ResultHasSameNumberOfChildren()
{
var current = CreateListTreeItem();
var next = CreateListTreeItem(CreatePrimitiveTreeItem(5), CreatePrimitiveTreeItem("alfa"));
var actual = (DifferenceItemContainer)TreeComparer.FromBranchModified(current, next);
Assert.That(actual.Children.Length, Is.EqualTo(2));
}
public void WhenBothHaveNoChildren_ReturnsNull()
{
var current = CreateStateObjectTreeItem();
var next = CreateStateObjectTreeItem();
var actual = TreeComparer.FromNamedProperties(current, next);
Assert.That(actual, Is.Null);
}
public void WhenSameSourceSamePropertySameValue_ReturnsNull()
{
var source = new PrimitiveData("tn", 1);
var current = new PrimitiveObjectTreeItem(source.Value, null, "pn", source);
var next = new PrimitiveObjectTreeItem(source.Value, null, "pn", source);
var actual = TreeComparer.FromPrimitive(current, next);
Assert.That(actual, Is.Null);
}
public void WhenSourceIsPrimitive_ReturnsDifferenceItemWithAdded()
{
var source = CreatePrimitiveTreeItem(1);
var actual = TreeComparer.FromBranchAdded(source);
Assert.That(actual, Is.Not.Null);
Assert.That(actual, Is.Not.InstanceOf <DifferenceItemContainer>());
Assert.That(actual.DiffType, Is.EqualTo(DiffType.Added));
}
public void WhenSourceIsNode_ReturnsDifferenceItemContainerWithNone()
{
var current = CreateListTreeItem();
var next = CreateListTreeItem();
var actual = TreeComparer.FromBranchModified(current, next);
Assert.That(actual, Is.InstanceOf <DifferenceItemContainer>());
Assert.That(actual.DiffType, Is.EqualTo(DiffType.None));
}
public void WhenSimpleState_IsEqual_ReturnsNull()
{
var objectData = new StateObjectData("tn", ImmutableDictionary <string, ObjectData> .Empty, hasKey: false, key: null);
var current = new StateObjectTreeItem(null, "pn", objectData, depth: 0);
var next = new StateObjectTreeItem(null, "pn", objectData, depth: 0);
var actual = TreeComparer.CreateDifferenceTree(current, next);
Assert.That(actual, Is.Null);
}
public void WhenSourceIsNode_DifferenceItemContainsCorrectSources()
{
var current = CreateListTreeItem();
var next = CreateListTreeItem(CreatePrimitiveTreeItem(5), CreatePrimitiveTreeItem("alfa"));
var actual = TreeComparer.FromBranchModified(current, next);
Assert.That(actual.Current, Is.SameAs(current));
Assert.That(actual.Next, Is.SameAs(next));
}
public void WhenSourceIsPrimitive_ReturnsDifferenceItemWithNone()
{
var current = CreatePrimitiveTreeItem(1);
var next = CreatePrimitiveTreeItem(2);
var actual = TreeComparer.FromBranchModified(current, next);
Assert.That(actual, Is.Not.Null);
Assert.That(actual, Is.Not.InstanceOf <DifferenceItemContainer>());
Assert.That(actual.DiffType, Is.EqualTo(DiffType.None));
}
public void WhenDifferentSourceSamePropertyDifferentValue_ReturnsDifferenceItem()
{
var currentSource = new PrimitiveData("tn", 1);
var nextSource = new PrimitiveData("tn", 2);
var current = new PrimitiveObjectTreeItem(currentSource.Value, null, "pn", currentSource);
var next = new PrimitiveObjectTreeItem(nextSource.Value, null, "pn", nextSource);
var actual = TreeComparer.FromPrimitive(current, next);
Assert.That(actual, Is.Not.Null);
}
private static CallSiteRule <T> FindCompatibleRuleForTemplate <T>(CallSiteRule <T> from, CallSiteRule <T> to, out List <ConstantExpression> newConstants, out bool tooSpecific) where T : class
{
// no templates exist for this rule, just compare the raw trees...
if (TreeComparer.Compare(to.Binding, from.Binding, out newConstants, out tooSpecific))
{
// the rules are not compatbile, don't add template values...
return(from);
}
return(null);
}
public void WhenCurrentIsNullButNextIsValid_ReturnsAddedDifferenceItem()
{
var next = CreatePrimitiveTreeItem(1);
var actual = TreeComparer.CreateDifferenceTree(null, next);
Assert.That(actual, Is.Not.Null);
Assert.That(actual.DiffType, Is.EqualTo(DiffType.Added));
Assert.That(actual.Current, Is.Null);
Assert.That(actual.Next, Is.SameAs(next));
}
public void WhenDifferentSourceSamePropertyDifferentValue_DifferenceItemIsMarkedAsModified()
{
var currentSource = new PrimitiveData("tn", 1);
var nextSource = new PrimitiveData("tn", 2);
var current = new PrimitiveObjectTreeItem(currentSource.Value, null, "pn", currentSource);
var next = new PrimitiveObjectTreeItem(nextSource.Value, null, "pn", nextSource);
var actual = TreeComparer.FromPrimitive(current, next);
Assert.That(actual.DiffType, Is.EqualTo(DiffType.Modified));
}
public void WhenCurrentIsPresentButNextIsNull_ReturnsRemovedDifferenceItem()
{
var current = CreatePrimitiveTreeItem(1);
var actual = TreeComparer.CreateDifferenceTree(current, null);
Assert.That(actual, Is.Not.Null);
Assert.That(actual.DiffType, Is.EqualTo(DiffType.Removed));
Assert.That(actual.Current, Is.SameAs(current));
Assert.That(actual.Next, Is.Null);
}
public void WhenCurrentHasChildAndNextHasNone_ContainsProperChildren()
{
var current = CreateListTreeItem(CreatePrimitiveTreeItem(5));
var next = CreateListTreeItem();
var actual = TreeComparer.FromList(current, next);
Assert.That(actual.Children.Length, Is.EqualTo(1));
Assert.That(actual.Children[0].Current, Is.SameAs(current.Children[0]));
Assert.That(actual.Children[0].Next, Is.Null);
Assert.That(actual.Children[0].DiffType, Is.EqualTo(DiffType.Removed));
}
public void WhenCurrentHasChildAndNextHasNone_ReturnsModified()
{
var current = CreateListTreeItem(CreatePrimitiveTreeItem(5));
var next = CreateListTreeItem();
var actual = TreeComparer.FromList(current, next);
Assert.That(actual, Is.InstanceOf <DifferenceItemContainer>());
Assert.That(actual.DiffType, Is.EqualTo(DiffType.Modified));
Assert.That(actual.Current, Is.SameAs(current));
Assert.That(actual.Next, Is.SameAs(next));
}
public void WhenDifferentSourceSamePropertyDifferentValue_DifferenceItemContainsBothItems()
{
var currentSource = new PrimitiveData("tn", 1);
var nextSource = new PrimitiveData("tn", 2);
var current = new PrimitiveObjectTreeItem(currentSource.Value, null, "pn", currentSource);
var next = new PrimitiveObjectTreeItem(nextSource.Value, null, "pn", nextSource);
var actual = TreeComparer.FromPrimitive(current, next);
Assert.That(actual.Current, Is.SameAs(current));
Assert.That(actual.Next, Is.SameAs(next));
}
public void WhenKeyItemChanges_MarkItAsModified()
{
var first = CreateStateObjectTreeItem(CreateNamedPrimitiveTreeItem("Text", "a"));
var modified = CreateStateObjectTreeItem(CreateNamedPrimitiveTreeItem("Text", "b"));
var current = CreateListTreeItem(first);
var next = CreateListTreeItem(modified);
var actual = TreeComparer.FromList(current, next);
Assert.That(actual.Children.Length, Is.EqualTo(1));
Assert.That(actual.DiffType, Is.EqualTo(DiffType.Modified));
}
// Start is called before the first frame update
void Start()
{
tC = new TreeComparer();
int counter = 0;
if (treeParent == null)
{
Debug.LogError("treeParent is not selected in Editor.");
}
else
{
Trees[] temp = treeParent.GetComponentsInChildren <Trees>();
foreach (Trees t in temp)
{
t.TreeNumber = counter++;
t.Controller = this;
aliveTrees.Add(t);
}
float pNatVal = Trees.startingNatureValue;
foreach (Trees t in aliveTrees)
{
t.personalNatureValue = pNatVal;
}
//Debug.LogWarning(pNatVal + "||" + counter);
LevelBalancing.ResetBalanceValue(pNatVal * counter);
}
counter = 0;
if (PoIParent == null)
{
//Debug.LogError("POIParent is not selected in Editor.");
}
else
{
PoI[] temp2 = PoIParent.GetComponentsInChildren <PoI>();
if (temp2 == null)
{
Debug.LogError($"No POI selected");
}
else
{
foreach (PoI p in temp2)
{
p.Setup(this, counter++);
PoIList.Add(p);
}
}
}
}
/// <summary>
/// 1. Take existing xaml test data
/// 2. Generate WPF object using XamlReader.Load
/// 3. Use XamlWriter.Save to serialize the Object into Xaml
/// 4. Verify this generated Xaml matched the expected xaml provided to the test
/// 5. Use XamlReader.Load to generate a WPF Object using the serialized XAML
/// 6. Verify that this new object is identical to object created with the original XAML
/// </summary>
/// <param name="userCreatedXaml">string containing XAML that has to be RoundTripped</param>
/// <param name="preSerializedXaml">string containing XAML that we should get if the RoundTrip was successful</param>
/// <returns>True if RoundTrip is successful otherwise False</returns>
public static bool Verify(string userCreatedXaml, string preSerializedXaml)
{
object wpfObject = null;
using (Stream userCreatedXamlStream = CreateMemoryStream(userCreatedXaml))
{
wpfObject = XamlReader.Load(CreateMemoryStream(userCreatedXaml));
if (wpfObject == null)
{
Variation.Current.LogMessage("UNEXPECTED: Unable to create wpfObject using XamlReader.Load");
return(false);
}
Variation.Current.LogMessage("Created wpfObject");
}
string newSerializedXaml = XamlWriter.Save(wpfObject);
Variation.Current.LogMessage("Serialized wpfObject -> newSerializedXaml");
if (!newSerializedXaml.Equals(preSerializedXaml))
{
Variation.Current.LogMessage("UNEXPECTED: newSerializedXaml and test data(preSerializedXaml)do not match");
SaveFileToLogFolder("Serialized.xaml", newSerializedXaml);
return(false);
}
Variation.Current.LogMessage("newSerializedXaml and test data(preSerializedXaml) match");
object roundTrippedWpfObject = XamlReader.Load(CreateMemoryStream(newSerializedXaml));
if (roundTrippedWpfObject == null)
{
Variation.Current.LogMessage("UNEXPECTED: Unable to create Round Tripped wpfObject XamlReader.Load(newSerializedXaml)");
return(false);
}
Variation.Current.LogMessage("Created Round Tripped wpfObject");
TreeCompareResult objectComparisonResult = TreeComparer.CompareLogical(wpfObject, roundTrippedWpfObject);
if (objectComparisonResult.Result == CompareResult.Different)
{
Variation.Current.LogMessage("UNEXPECTED: RoundTripped WPF Object and Original WPF object no not match");
return(false);
}
Variation.Current.LogMessage("RoundTripped WPF Object and Original WPF object match");
return(true);
}
public void WhenReferencesChangeButContentIsSame_NullIsReturned()
{
var current = new Root {
First = new FirstBranch {
Alpha = "a", Omega = 1
}
};
var next = new Root {
First = new FirstBranch {
Alpha = "a", Omega = 1
}
};
var actual = (DifferenceItemContainer)TreeComparer.CreateDifferenceTree(ToTreeItem(current), ToTreeItem(next));
Assert.That(actual, Is.Null);
}
public void WhenCurrentIsNull_ButNextIsNot_ReturnsWholeNextBranchAsAdded()
{
var next = new Root {
First = new FirstBranch {
Alpha = "a", Omega = 1
}
};
var actual = (DifferenceItemContainer)TreeComparer.CreateDifferenceTree(null, ToTreeItem(next));
Assert.That(actual.DiffType, Is.EqualTo(DiffType.Added));
Assert.That(actual.Children.Length, Is.EqualTo(2));
var first = actual.Children[0];
Assert.That(first.DiffType, Is.EqualTo(DiffType.Added));
var second = actual.Children[1];
Assert.That(second.DiffType, Is.EqualTo(DiffType.Added));
}
public static object RoundTripAndCompareObjects(object obj, params string[] propertyNamesToBeIgnored)
{
if (obj == null)
{
throw new ArgumentNullException("obj");
}
MemoryStream xamlStream = null;
object roundTrippedObject = XamlTestDriver.RoundTrip(obj, out xamlStream);
using (xamlStream)
{
Dictionary <string, PropertyToIgnore> ignore = new Dictionary <string, PropertyToIgnore>();
foreach (string propertyName in propertyNamesToBeIgnored)
{
ignore.Add(propertyName, new PropertyToIgnore()
{
WhatToIgnore = IgnoreProperty.IgnoreValueOnly
});
}
TreeComparerResult result;
if (ignore.Count == 0)
{
result = TreeComparer.CompareLogical(obj, roundTrippedObject);
}
else
{
result = TreeComparer.CompareLogical(obj, roundTrippedObject, ignore);
}
if (result.Result == CompareResult.Different)
{
string source = new ObjectDumper().DumpToString(null, obj);
string target = new ObjectDumper().DumpToString(null, roundTrippedObject);
XamlTestDriver.TraceXamlFile(xamlStream);
throw new Exception("Two objects are different.");
}
return(roundTrippedObject);
}
}
