public static void CompareObjects(ObjectComparisonCmdletBase cmdlet, object referenceObject, object[] differenceObjects)
{
// left is null
if (null == referenceObject)
{
cmdlet.WriteObject(cmdlet, false);
return;
}
// right is null
if (null == differenceObjects)
{
cmdlet.WriteObject(cmdlet, false);
return;
}
if (null != differenceObjects && 0 < differenceObjects.Length)
{
ObjectGraphFactory factory = new PublicPropertyObjectGraphFactory();
ObjectGraphFactoryMap map = new ObjectGraphFactoryMap(true);
GraphNode referenceGraph = factory.CreateObjectGraph(referenceObject, map);
foreach (var differenceObject in differenceObjects)
{
cmdlet.WriteVerbose(cmdlet, "comparing " + referenceObject + " and " + differenceObject);
GraphNode differenceGraph = factory.CreateObjectGraph(differenceObject, map);
ObjectGraphComparer comparer = new ObjectGraphComparer();
bool result = comparer.Compare(referenceGraph, differenceGraph);
cmdlet.WriteObject(cmdlet, result);
}
}
}
public void HandlesPropertiesWithNullValues()
{
// There was a bug that PublicPropertyObjectGraphFactory threw
// NullReferenceException when
// 1. factoryMap is not null
// 2. Property value is null
// This test case is to make sure that this bug has been fixed and
// does not come back
var left = typeof(string);
var right = typeof(string);
var fac = new PublicPropertyObjectGraphFactory();
var comparer = new ObjectGraphComparer();
var factoryMap = new ObjectGraphFactoryMap(false);
factoryMap.Add(typeof(MethodBase), new StubGraphFactory());
factoryMap.Add(typeof(Assembly), new StubGraphFactory());
var leftNode = fac.CreateObjectGraph(left, factoryMap); // With StubFactory
var rightNode = fac.CreateObjectGraph(right); // Without StubFactory
bool noDifferences = comparer.Compare(leftNode, rightNode);
Assert.False(noDifferences);
var leftChildrenCount = leftNode.GetNodesInDepthFirstOrder().Count();
var rightChildrenCount = rightNode.GetNodesInDepthFirstOrder().Count();
// Make sure that we reduced size of the object graph by using StubFactory
Assert.True(leftChildrenCount < rightChildrenCount);
}
public void CompareIEnumerable()
{
Element leftObject = new Element()
{
Name = "root",
Content = new List <string>
{
"hello1",
"hello2",
"hello3"
}
};
Element rightObject = new Element()
{
Name = "root",
Content = new List <string>
{
"hello1",
"hello2",
"hello3"
}
};
ObjectGraphFactory factory = new PublicPropertyObjectGraphFactory();
ObjectGraphComparer comparer = new ObjectGraphComparer();
var left = factory.CreateObjectGraph(leftObject);
var right = factory.CreateObjectGraph(rightObject);
bool match = comparer.Compare(left, right);
Assert.True(match, "objects did not match");
}
public void CompareObjectWithLoopInSecondLevel()
{
Element leftObject = new Element()
{
Name = "RootElement",
Content = new Element()
{
Name = "ChildElement"
}
};
// child points to root
((Element)leftObject.Content).Content = leftObject;
Element rightObject = new Element()
{
Name = "RootElement",
Content = new Element()
{
Name = "ChildElement"
}
};
// child points to parent
((Element)rightObject.Content).Content = rightObject;
ObjectGraphFactory factory = new PublicPropertyObjectGraphFactory();
ObjectGraphComparer comparer = new ObjectGraphComparer();
var left = factory.CreateObjectGraph(leftObject);
var right = factory.CreateObjectGraph(rightObject);
bool match = comparer.Compare(left, right);
Assert.True(match, "object with loop did not match");
}
public void CompareTypesDoNotMatch()
{
var leftObject = new Element()
{
Content = 32,
};
var rightObject = new Element()
{
Content = "stringvalue",
};
ObjectGraphFactory factory = new PublicPropertyObjectGraphFactory();
ObjectGraphComparer comparer = new ObjectGraphComparer();
var left = factory.CreateObjectGraph(leftObject);
var right = factory.CreateObjectGraph(rightObject);
IEnumerable <ObjectComparisonMismatch> mismatches;
bool match = comparer.Compare(left, right, out mismatches);
string[] expectedMismatches = new string[]
{
"ObjectTypesDoNotMatch:Left=RootObject.Content(32) Right=RootObject.Content(stringvalue)",
};
string[] actualMismatches = TestHelpers.StringFromMismatches(mismatches);
Assert.False(match);
Assert.True(actualMismatches.Length == expectedMismatches.Length);
for (int index = 0; index < expectedMismatches.Length; index++)
{
Assert.Equal(expectedMismatches[index], actualMismatches[index]);
}
}
public void BasicTypesDiffer()
{
BasicTypes leftObject = new BasicTypes()
{
BoolPrimitive = false,
BytePrimitive = byte.MinValue,
CharValue = char.MinValue,
DoublePrimitive = double.MinValue,
FloatPrimitive = float.MinValue,
IntPrimitive = int.MinValue,
LongPrimitive = long.MinValue,
ShortPrimitive = short.MinValue,
StringPrimitive = "some string",
TimeSpanValue = TimeSpan.MinValue,
};
BasicTypes rightObject = leftObject.Clone();
ObjectGraphFactory factory = new PublicPropertyObjectGraphFactory();
ObjectGraphComparer comparer = new ObjectGraphComparer();
var left = factory.CreateObjectGraph(leftObject);
var right = factory.CreateObjectGraph(rightObject);
bool match = comparer.Compare(left, right);
Assert.True(match, "Basic types did not match");
}
public void CompareObjects()
{
// Create two objects with differing property values
Person leftObject = new Person()
{
Name = "Person1",
Age = 15,
Parent = new Person()
{
Name = "ParentOfPerson1",
}
};
Person rightObject = new Person()
{
Name = "Person2",
Age = 15,
Parent = new Person()
{
Name = "ParentOfPerson2",
}
};
// Create the object graph factory
ObjectGraphFactory factory = new PublicPropertyObjectGraphFactory();
var leftGraph = factory.CreateObjectGraph(leftObject);
var rightGraph = factory.CreateObjectGraph(rightObject);
// Create a comparer using the factory
ObjectGraphComparer comparer = new ObjectGraphComparer();
// Compare the objects
IEnumerable <ObjectComparisonMismatch> mismatches;
bool match = comparer.Compare(leftGraph, rightGraph, out mismatches);
// Validate the mismatches when the objects do not match
string[] expectedMismatches = new string[]
{
"ObjectValuesDoNotMatch:Left=RootObject.Name(Person1) Right=RootObject.Name(Person2)",
"ObjectValuesDoNotMatch:Left=RootObject.Parent.Name(ParentOfPerson1) Right=RootObject.Parent.Name(ParentOfPerson2)",
};
string[] actualMismatches = StringFromMismatches(mismatches);
Assert.False(match);
Assert.True(actualMismatches.Length == expectedMismatches.Length);
for (int index = 0; index < expectedMismatches.Length; index++)
{
Assert.Equal(expectedMismatches[index], actualMismatches[index]);
}
}
public void CallsFactoriesFromTheFactoryMap()
{
var o = new NamedTypeWithAttributedProperty
{
Name = "Ralph",
Value = new TypeWithAttributedProperty
{
PropertyWithTestAttribute = "TestValue",
PropertyWithoutTestAttribute = "ShouldBeIgnored"
}
};
var map = new ObjectGraphFactoryMap(true);
map[typeof(TypeWithAttributedProperty)] = new ExtractAttributeObjectGraphFactory();
var factory = new PublicPropertyObjectGraphFactory();
var graph = factory.CreateObjectGraph(o, map);
var expected =
@"RootObjectValue = 'Microsoft.Test.AcceptanceTests.ObjectComparison.ObjectGraphFactoryTests+NamedTypeWithAttributedProperty' Type=Microsoft.Test.AcceptanceTests.ObjectComparison.ObjectGraphFactoryTests+NamedTypeWithAttributedProperty
ValueValue = 'Microsoft.Test.AcceptanceTests.ObjectComparison.TypeWithAttributedProperty' Type=Microsoft.Test.AcceptanceTests.ObjectComparison.TypeWithAttributedProperty
PropertyWithTestAttributeValue = 'TestValue' Type=System.String
NameValue = 'Ralph' Type=System.String";
var actual = TestHelpers.StringFromGraph(graph);
Assert.Equal(expected, actual.Trim());
}
public void ObjectGraphCodecExampleCodecCommentSample()
{
// Example code begins here //
var p1 = new Person("John");
p1.Children.Add(new Person("Peter"));
p1.Children.Add(new Person("Mary"));
// Create a sample object graph
var factory = new PublicPropertyObjectGraphFactory();
var graph1 = factory.CreateObjectGraph(p1);
// Encode that object graph
var stream = new MemoryStream();
var codec = new SimpleCodec();
codec.EncodeObjectGraph(graph1, stream);
// Print the result
Console.WriteLine(Encoding.UTF8.GetString(stream.GetBuffer()));
// Decode the object graph
var graph2 = codec.DecodeObjectGraph(stream);
// Result should be false, because we encoded only tree top nodes
// from the whole object graph
var result = new ObjectGraphComparer().Compare(graph1, graph2);
Trace.WriteLine("{0}", result ? "Object graphs are equal!" : "Object graphs are NOT equal!");
// Example code ends here //
Assert.False(result);
}
public void CompareIncorrectChildCount()
{
var leftObject = new Element()
{
Content = new string[]
{
"String1",
"String2",
},
};
var rightObject = new Element()
{
Content = new string[]
{
"String1",
},
};
ObjectGraphFactory factory = new PublicPropertyObjectGraphFactory();
ObjectGraphComparer comparer = new ObjectGraphComparer();
var left = factory.CreateObjectGraph(leftObject);
var right = factory.CreateObjectGraph(rightObject);
IEnumerable <ObjectComparisonMismatch> mismatches;
bool match = comparer.Compare(left, right, out mismatches);
string[] expectedMismatches = new string[]
{
"RightNodeHasFewerChildren:Left=RootObject.Content(System.String[]) Right=RootObject.Content(System.String[])",
"MissingRightNode:Left=RootObject.Content.IEnumerable1(String2) Right=Null(Null)",
"ObjectValuesDoNotMatch:Left=RootObject.Content.Length(2) Right=RootObject.Content.Length(1)",
"ObjectValuesDoNotMatch:Left=RootObject.Content.LongLength(2) Right=RootObject.Content.LongLength(1)",
};
string[] actualMismatches = TestHelpers.StringFromMismatches(mismatches);
Assert.False(match);
Assert.True(actualMismatches.Length == expectedMismatches.Length);
for (int index = 0; index < expectedMismatches.Length; index++)
{
Assert.Equal(expectedMismatches[index], actualMismatches[index]);
}
}
public void XmlObjectGraphCodecRoundtripCommentSample()
{
var expectedXml =
"<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
@"<RootObject>
<Name>John</Name>
<Children>
<Count>2</Count>
<IEnumerable0>
<Name>Peter</Name>
<Children>
<Count>0</Count>
</Children>
</IEnumerable0>
<IEnumerable1>
<Name>Mary</Name>
<Children>
<Count>0</Count>
</Children>
</IEnumerable1>
</Children>
</RootObject>";
var stream = new MemoryStream(Encoding.UTF8.GetBytes(expectedXml));
// Example code starts here //
var p1 = new Person("John");
p1.Children.Add(new Person("Peter"));
p1.Children.Add(new Person("Mary"));
// Create an object graph
var factory = new PublicPropertyObjectGraphFactory();
var graph1 = factory.CreateObjectGraph(p1);
// Simulate round-trip data loss
{
var roundtripStream = new MemoryStream();
var xmlCodec = new XmlObjectGraphCodec();
xmlCodec.EncodeObjectGraph(graph1, roundtripStream);
graph1 = xmlCodec.DecodeObjectGraph(stream);
}
// Decode a baseline graph from the earlier prepared stream
var graph2 = new XmlObjectGraphCodec().DecodeObjectGraph(stream);
var result = new ObjectGraphComparer().Compare(graph1, graph2);
Trace.WriteLine("{0}", result ? "Object graphs are equal!" : "Object graphs are NOT equal!");
// Example code ends here //
Assert.True(result);
}
public void CompareDictionary()
{
Dictionary <int, string> leftObject = new Dictionary <int, string>()
{
{ 10, "Hello" },
{ 20, "World" },
};
Dictionary <int, string> rightObject = new Dictionary <int, string>()
{
{ 10, "Hello" },
{ 20, "World" },
};
ObjectGraphFactory factory = new PublicPropertyObjectGraphFactory();
ObjectGraphComparer comparer = new ObjectGraphComparer();
var left = factory.CreateObjectGraph(leftObject);
var right = factory.CreateObjectGraph(rightObject);
bool match = comparer.Compare(left, right);
Assert.True(match, "Dictionary<int, string> did not match");
}
public void CompareList()
{
List <string> leftObject = new List <string>()
{
"Hello",
"World",
};
List <string> rightObject = new List <string>()
{
"Hello",
"World",
};
ObjectGraphFactory factory = new PublicPropertyObjectGraphFactory();
ObjectGraphComparer comparer = new ObjectGraphComparer();
var left = factory.CreateObjectGraph(leftObject);
var right = factory.CreateObjectGraph(rightObject);
bool match = comparer.Compare(left, right);
Assert.True(match, "List<string> did not match");
}
public void ComparePropertyThrows()
{
Element leftObject = new Element()
{
Content = new TypeWithPropertyThatThrows(),
};
Element rightObject = new Element()
{
Content = new TypeWithPropertyThatThrows(),
};
ObjectGraphFactory factory = new PublicPropertyObjectGraphFactory();
ObjectGraphComparer comparer = new ObjectGraphComparer();
var left = factory.CreateObjectGraph(leftObject);
var right = factory.CreateObjectGraph(rightObject);
bool match = comparer.Compare(left, right);
TestHelpers.ObjectToConsole(leftObject, factory);
Assert.True(match, "objects did not match");
}
public void CompareMissingNodes()
{
var leftObject = new Element()
{
Name = "Content1",
Content = new Element()
{
Name = "OnlyOnLeft",
}
};
var rightObject = new Element()
{
Name = "Content1"
};
ObjectGraphFactory factory = new PublicPropertyObjectGraphFactory();
ObjectGraphComparer comparer = new ObjectGraphComparer();
var left = factory.CreateObjectGraph(leftObject);
var right = factory.CreateObjectGraph(rightObject);
IEnumerable <ObjectComparisonMismatch> mismatches;
bool match = comparer.Compare(left, right, out mismatches);
string[] expectedMismatches = new string[]
{
"ObjectValuesDoNotMatch:Left=RootObject.Content(Microsoft.Test.AcceptanceTests.ObjectComparison.Element) Right=RootObject.Content(Null)",
"MissingRightNode:Left=RootObject.Content.Content(Null) Right=Null(Null)",
"MissingRightNode:Left=RootObject.Content.Name(OnlyOnLeft) Right=Null(Null)",
};
string[] actualMismatches = TestHelpers.StringFromMismatches(mismatches);
Assert.False(match);
Assert.True(actualMismatches.Length == expectedMismatches.Length);
for (int index = 0; index < expectedMismatches.Length; index++)
{
Assert.Equal(expectedMismatches[index], actualMismatches[index]);
}
}
public void CompareBasicTypesMinValues()
{
BasicTypes leftObject = new BasicTypes()
{
BoolPrimitive = false,
BytePrimitive = byte.MinValue,
CharValue = char.MinValue,
DoublePrimitive = double.MinValue,
FloatPrimitive = float.MinValue,
IntPrimitive = int.MinValue,
LongPrimitive = long.MinValue,
ShortPrimitive = short.MinValue,
StringPrimitive = "some string",
TimeSpanValue = TimeSpan.MinValue,
};
BasicTypes rightObject = new BasicTypes()
{
BoolPrimitive = true,
BytePrimitive = byte.MaxValue,
CharValue = char.MaxValue,
DoublePrimitive = double.MaxValue,
FloatPrimitive = float.MaxValue,
IntPrimitive = int.MaxValue,
LongPrimitive = long.MaxValue,
ShortPrimitive = short.MaxValue,
StringPrimitive = string.Empty,
TimeSpanValue = TimeSpan.MaxValue,
};
ObjectGraphFactory factory = new PublicPropertyObjectGraphFactory();
ObjectGraphComparer comparer = new ObjectGraphComparer();
var left = factory.CreateObjectGraph(leftObject);
var right = factory.CreateObjectGraph(rightObject);
bool match = comparer.Compare(left, right);
Assert.False(match, "Basic types matched when they should not");
}
public void CompareObjectWithSharedNodes()
{
Element sharedLeftObject = new Element()
{
Name = "shared"
};
Element leftObject = new Element()
{
Name = "RootElement",
Content = new List <Element>()
{
sharedLeftObject,
sharedLeftObject,
},
};
Element sharedRightObject = new Element()
{
Name = "shared"
};
Element rightObject = new Element()
{
Name = "RootElement",
Content = new List <Element>()
{
sharedRightObject,
sharedRightObject,
},
};
ObjectGraphFactory factory = new PublicPropertyObjectGraphFactory();
ObjectGraphComparer comparer = new ObjectGraphComparer();
var left = factory.CreateObjectGraph(leftObject);
var right = factory.CreateObjectGraph(rightObject);
bool match = comparer.Compare(left, right);
Assert.True(match, "object with loop did not match");
}
public void WorksWithFileStream()
{
var p1 = new Person("John");
p1.Children.Add(new Person("Peter"));
p1.Children.Add(new Person("Mary"));
var factory = new PublicPropertyObjectGraphFactory();
var graph1 = factory.CreateObjectGraph(p1);
var actual = TestHelpers.XmlCodecFileRoundtrip(graph1);
var expected = TestHelpers.XmlCodecRoundtrip(graph1);
Assert.True(new ObjectGraphComparer().Compare(expected, actual));
}
public void TestSimpleClassHierarchy()
{
var leftObject = new Element()
{
Name = "root",
Content = new Element()
{
Name = "element1",
Content = new Element()
{
Name = "element2",
}
}
};
var rightObject = new Element()
{
Name = "root",
Content = new Element()
{
Name = "element1",
Content = new Element()
{
Name = "element2",
}
}
};
ObjectGraphFactory factory = new PublicPropertyObjectGraphFactory();
ObjectGraphComparer comparer = new ObjectGraphComparer();
var left = factory.CreateObjectGraph(leftObject);
var right = factory.CreateObjectGraph(rightObject);
bool match = comparer.Compare(left, right);
Assert.True(match, "objects did not match");
}
internal static IEnumerable <object> GetAllObjects(DependencyObject element, Type desiredType)
{
PublicPropertyObjectGraphFactory objectGraphFactory = new PublicPropertyObjectGraphFactory();
GraphNode root = objectGraphFactory.CreateObjectGraph(element);
List <GraphNode> nodes = new List <GraphNode>(root.GetNodesInDepthFirstOrder());
foreach (GraphNode node in nodes)
{
if (node == null || node.ObjectType == null)
{
yield break;
}
if (node.ObjectType.IsSubclassOf(desiredType))
{
yield return(node.ObjectValue);
}
}
}
public void ObjectGraphCodecExampleCodecCommentSampleRoundtrip()
{
var p1 = new Person("John");
p1.Children.Add(new Person("Peter"));
p1.Children.Add(new Person("Mary"));
var factory = new PublicPropertyObjectGraphFactory();
var graph1 = factory.CreateObjectGraph(p1);
var stream = new MemoryStream();
var codec = new SimpleCodec();
codec.EncodeObjectGraph(graph1, stream);
// Round trip original object graph
graph1 = codec.DecodeObjectGraph(stream);
var graph2 = codec.DecodeObjectGraph(stream);
var result = new ObjectGraphComparer().Compare(graph1, graph2);
Assert.True(result);
}
public void WorksWithFileStream()
{
var p1 = new Person("John");
p1.Children.Add(new Person("Peter"));
p1.Children.Add(new Person("Mary"));
var factory = new PublicPropertyObjectGraphFactory();
var graph1 = factory.CreateObjectGraph(p1);
// Save the object graph into a file
var codec = new XmlObjectGraphCodec();
var filePath = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
using (var file = new FileStream(filePath, FileMode.Create, FileAccess.Write))
{
codec.EncodeObjectGraph(graph1, file);
}
// Read the object graph from the file
GraphNode actual;
using (var file = new FileStream(filePath, FileMode.Open, FileAccess.Read))
{
actual = codec.DecodeObjectGraph(file);
}
File.Delete(filePath);
var stream = new MemoryStream();
codec.EncodeObjectGraph(graph1, stream);
var expected = codec.DecodeObjectGraph(stream);
Assert.True(new ObjectGraphComparer().Compare(expected, actual));
}
public void XmlObjectGraphCodecEncodingCommentSample()
{
var actualStream = new MemoryStream();
var listener = new TextWriterTraceListener(actualStream);
Trace.Listeners.Add(listener);
// Example code starts here //
var p1 = new Person("John");
p1.Children.Add(new Person("Peter"));
p1.Children.Add(new Person("Mary"));
// Create an object graph
var factory = new PublicPropertyObjectGraphFactory();
var graph1 = factory.CreateObjectGraph(p1);
// Encode a constructed object graph into XML
var stream = new MemoryStream();
new XmlObjectGraphCodec().EncodeObjectGraph(graph1, stream);
// Output the resulting XML into the Console window
stream.Position = 0;
using (var reader = new StreamReader(stream))
{
Trace.WriteLine(reader.ReadToEnd());
}
// Example code ends here //
var expectedXml =
"<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
@"<RootObject>
<Name>John</Name>
<Children>
<Count>2</Count>
<IEnumerable0>
<Name>Peter</Name>
<Children>
<Count>0</Count>
</Children>
</IEnumerable0>
<IEnumerable1>
<Name>Mary</Name>
<Children>
<Count>0</Count>
</Children>
</IEnumerable1>
</Children>
</RootObject>";
// 'stream' is disposed, that is why we are using TraceListener
Trace.Flush();
Trace.Listeners.Remove(listener);
var actual = new XmlObjectGraphCodec().DecodeObjectGraph(actualStream);
var expected = new XmlObjectGraphCodec().DecodeObjectGraph(
new MemoryStream(Encoding.UTF8.GetBytes(expectedXml)));
var result = new ObjectGraphComparer().Compare(actual, expected);
Assert.True(result);
}
