public void When_passing_result_with_no_content_it_is_not_exported()
{
IComparerResult result = new ComparerResult(ResultContext.Assembly, "Assembly");
XElement sut = XmlGenerator.GenerateXml(result);
Assert.AreEqual(0, sut.Elements(ChangedElement).Count());
}
private void CompareName()
{
if (ReferenceType.Name != NewType.Name)
{
ComparerResult.AddChangedProperty("Name", ReferenceType.Name, NewType.Name, Severities.ParameterNameChanged);
}
}
private void CompareName()
{
if (ReferenceType.Name != NewType.Name)
{
ComparerResult.AddChangedProperty("Name", ReferenceType.Name, NewType.Name, Severity.Error);
}
}
private void CompareDefaultValue()
{
if (!Equals(ReferenceType.RawDefaultValue, NewType.RawDefaultValue))
{
ComparerResult.AddChangedProperty("Default Value", ReferenceType.RawDefaultValue.ToString(), NewType.RawDefaultValue.ToString(), Severity.Error);
}
}
private void CompareDefaultValue()
{
if (!Equals(ReferenceType.RawDefaultValue, NewType.RawDefaultValue))
{
ComparerResult.AddChangedProperty("Default Value", (ReferenceType.RawDefaultValue ?? "null").ToString(), (NewType.RawDefaultValue ?? "null").ToString(), Severities.DefaultValueChanged);
}
}
private void CompareReturnType()
{
if (ReferenceType.ReturnType.GetCompareableName() != NewType.ReturnType.GetCompareableName())
{
ComparerResult.AddChangedProperty("Return Type", ReferenceType.ReturnType.GetCompareableName(), NewType.ReturnType.GetCompareableName(), Severity.Error);
}
}
public Builder Result(ResultContext resultContext = ResultContext.Class, string name = null)
{
ComparerResult comparerResult = new ComparerResult(resultContext, name);
_comparerResult.AddComparerResult(comparerResult);
return(new Builder(this, comparerResult));
}
private void AddToResultIfNotEqual(string propertyName, string referenceValue, string newValue, Severity severity)
{
if (referenceValue != newValue)
{
ComparerResult.AddChangedProperty(propertyName, referenceValue, newValue, severity);
}
}
// [HttpPost]
public ActionResult Results(ComparerModel model)
{
/* Set Original document Path */
// JavaScriptSerializer serializer = new JavaScriptSerializer();
ComparerResultModel result = new ComparerResultModel();
if (ModelState.IsValid)
{
CompareService cs = new CompareService(Session);
ComparerResult res = new ComparerResult();
try
{
res = cs.DoComparison(HttpContext.User, model.GetComparerArguments(UploadPath));
}
catch (Exception ex)
{
Log.Write(TraceEventType.Stop, "Upload Controller, Results | Exception {0}", ex);
res.Errors.Add(ex.Message);
}
result = new ComparerResultModel(res);
//return Json(new { success = true, results = serializer.Serialize(new ComparerResultModel(res))}, "application/json");
}
else
{
result.Errors.Add("Input values is not filled or is not valid");
//return Json(new { success = false, message = serializer.Serialize(result) }, "application/json");
}
return(View(result));
}
protected void CompareParameters()
{
IEnumerable<Tuple<ParameterInfo, ParameterInfo>> parameterPairs = ReferenceType.GetParameters().Zip(NewType.GetParameters(), (refParam, newParam) => new Tuple<ParameterInfo, ParameterInfo>(refParam, newParam));
foreach (Tuple<ParameterInfo, ParameterInfo> parameterPair in parameterPairs)
{
ComparerResult.AddComparerResult(ComparerContext.CreateComparer(parameterPair.Item1, parameterPair.Item2).Compare());
}
}
private void AddToResultIfNotEqual(string propertyName, MethodAttributes typeAttribute, Severity severity)
{
bool referenceValue = ReferenceType.Attributes.HasFlag(typeAttribute);
bool newValue = NewType.Attributes.HasFlag(typeAttribute);
if (referenceValue != newValue)
{
ComparerResult.AddChangedFlag(propertyName, referenceValue, severity);
}
}
private void AddToResultIfNotEqual(string propertyName, Func <ParameterInfo, bool> getFlag, Severity severity)
{
bool referenceValue = getFlag(ReferenceType);
bool newValue = getFlag(NewType);
if (referenceValue != newValue)
{
ComparerResult.AddChangedFlag(propertyName, referenceValue, severity);
}
}
public void When_passing_two_level_report_xml_should_contain_it()
{
IComparerResult result1 = new ComparerResult(ResultContext.Assembly, "Assembly");
IComparerResult result2 = new ComparerResult(ResultContext.Class, "Class");
result2.AddChangedFlag("dummy", true, Severity.Error);
result1.AddComparerResult(result2);
XElement sut = XmlGenerator.GenerateXml(result1);
Assert.NotNull(sut.Element(ChangedElement).Element(ChangedElement));
}
public void When_passing_removed_item_xml_should_contain_it()
{
IComparerResult result = new ComparerResult(ResultContext.Assembly, "Assembly");
result.AddRemovedItem(ResultContext.Constructor, ".ctor", Severity.Warning);
XElement xml = XmlGenerator.GenerateXml(result);
XElement sut = xml.Element(ChangedElement).Element(RemovedElement);
Assert.AreEqual(".ctor", sut.Attribute("Name").Value);
StringAssert.AreEqualIgnoringCase(Severity.Warning.ToString(), sut.Attribute("Severity").Value);
StringAssert.AreEqualIgnoringCase(ResultContext.Constructor.ToString(), sut.Attribute("Context").Value);
}
public void When_passing_changed_flag_xml_should_contain_it()
{
IComparerResult result = new ComparerResult(ResultContext.Assembly, "Assembly");
result.AddChangedFlag("Flag", true, Severity.Hint);
XElement xml = XmlGenerator.GenerateXml(result);
XElement sut = xml.Element("ChangedElement").Element("ChangedAttribute");
Assert.AreEqual("Flag", sut.Attribute("Name").Value);
StringAssert.AreEqualIgnoringCase(Severity.Hint.ToString(), sut.Attribute("Severity").Value);
StringAssert.AreEqualIgnoringCase(true.ToString(), sut.Attribute("ReferenceValue").Value);
StringAssert.AreEqualIgnoringCase(false.ToString(), sut.Attribute("NewValue").Value);
}
public void When_passing_changed_property_xml_should_contain_it()
{
IComparerResult result = new ComparerResult(ResultContext.Assembly, "Assembly");
result.AddChangedProperty("PropName", "old", "new", Severity.Error);
XElement xml = XmlGenerator.GenerateXml(result);
XElement sut = xml.Element(ChangedElement).Element(ChangedAttribute);
Assert.AreEqual("PropName", sut.Attribute("Name").Value);
StringAssert.AreEqualIgnoringCase(Severity.Error.ToString(), sut.Attribute("Severity").Value);
Assert.AreEqual("old", sut.Attribute("ReferenceValue").Value);
Assert.AreEqual("new", sut.Attribute("NewValue").Value);
}
private void CompareAttributes()
{
if (ReferenceType.IsEnum != NewType.IsEnum)
{
ComparerResult.AddChangedFlag("Enum", ReferenceType.IsEnum, Severity.Error);
}
AddToResultIfNotEqual("Static", TypeAttributes.Sealed | TypeAttributes.Abstract, Severity.Error);
if (ComparerResult.ChangedFlags.All(change => change.PropertyName != "Static"))
{
AddToResultIfNotEqual("Abstract", TypeAttributes.Abstract, Severity.Error);
AddToResultIfNotEqual("Sealed", TypeAttributes.Sealed, Severity.Error);
}
AddToResultIfNotEqual("Interface", TypeAttributes.Interface, Severity.Error);
AddToResultIfNotEqual("Serializable", TypeAttributes.Serializable, Severity.Error);
}
public override IComparerResult Compare()
{
ComparerContext.LogDetail(string.Format("Comparing event '{0}'", ReferenceType));
if (ReferenceType.EventHandlerType.GetCompareableName() != NewType.EventHandlerType.GetCompareableName())
{
ComparerResult.AddChangedProperty("Type", ReferenceType.EventHandlerType.GetCompareableName(), NewType.EventHandlerType.GetCompareableName(), Severity.Error);
}
bool referenceStatic = (ReferenceType.AddMethod != null && ReferenceType.AddMethod.IsStatic) || (ReferenceType.RaiseMethod != null && ReferenceType.RaiseMethod.IsStatic);
bool newStatic = (NewType.AddMethod != null && NewType.AddMethod.IsStatic) || (NewType.RaiseMethod != null && NewType.RaiseMethod.IsStatic);
if (referenceStatic != newStatic)
{
ComparerResult.AddChangedFlag("Static", referenceStatic, Severity.Error);
}
return(ComparerResult);
}
private void CompareInterfaces()
{
IEnumerable <string> referenceInterfaces = ReferenceType.GetInterfaces().Select(@interface => @interface.GetCompareableName()).ToList();
IEnumerable <string> newInterfaces = NewType.GetInterfaces().Select(@interface => @interface.GetCompareableName()).ToList();
// missing interfaces
foreach (string @interface in referenceInterfaces.Except(newInterfaces))
{
ComparerResult.AddRemovedItem(ResultContext.Interface, @interface, Severity.Error);
}
// new interfaces
foreach (string @interface in newInterfaces.Except(referenceInterfaces))
{
ComparerResult.AddAddedItem(ResultContext.Interface, @interface, Severity.Warning);
}
}
private void CompareInterfaces()
{
IEnumerable <string> referenceInterfaces = GetInterfaces(ReferenceType).ToList();
IEnumerable <string> newInterfaces = GetInterfaces(NewType).ToList();
// missing interfaces
foreach (string @interface in referenceInterfaces.Except(newInterfaces))
{
ComparerResult.AddRemovedItem(ResultContext.Interface, @interface, Severities.InterfacesRemoved);
}
// new interfaces
foreach (string @interface in newInterfaces.Except(referenceInterfaces))
{
ComparerResult.AddAddedItem(ResultContext.Interface, @interface, Severities.InterfacesAdded);
}
}
/// <summary> Compares the versions of the API and generates the desired reports. </summary>
/// <returns> The amount of errors and warnings found. </returns>
public int CheckApi()
{
// Comparing
_comparerContext.LogInfo("Comparing assemblies.");
ComparerResult = _comparerContext.CreateComparer(_referenceVersion, _newVersion).Compare();
// Reporting
_comparerContext.LogInfo("Generating xml result.");
XElement element = XmlGenerator.GenerateXml(ComparerResult);
if (_xmlOutput != null)
{
_comparerContext.LogInfo("Exporting xml report.");
element.Save(_xmlOutput);
}
if (_htmlOutput != null)
{
_comparerContext.LogInfo("Exporting html report.");
XmlTransformer.TransformToHtml(element.CreateReader(), _htmlOutput);
}
return(ComparerResult.GetAllCount(Severity.Error, false) + ComparerResult.GetAllCount(Severity.Warning, false));
}
public override IComparerResult Compare()
{
ComparerContext.LogDetail(string.Format("Comparing field '{0}'", ReferenceType));
if (ReferenceType.FieldType.GetCompareableName() != NewType.FieldType.GetCompareableName())
{
ComparerResult.AddChangedProperty("Type", ReferenceType.FieldType.GetCompareableName(), NewType.FieldType.GetCompareableName(), Severity.Error);
}
if (ReferenceType.IsStatic != NewType.IsStatic)
{
ComparerResult.AddChangedFlag("Static", ReferenceType.IsStatic, Severity.Error);
}
if (ReferenceType.IsStatic && NewType.IsStatic && ReferenceType.FieldType.IsEnum)
{
// compare numeric enum values
object referenceValue = ReferenceType.GetRawConstantValue();
object newValue = NewType.GetRawConstantValue();
if (Convert.ToInt32(referenceValue) != Convert.ToInt32(newValue))
{
ComparerResult.AddChangedProperty("Value", referenceValue.ToString(), newValue.ToString(), Severity.Error);
}
}
return(ComparerResult);
}
private void CompareFields()
{
IEnumerable <string> referenceFields = GetFields(ReferenceType).ToList();
IEnumerable <string> newFields = GetFields(NewType).ToList();
// missing fields
foreach (string field in referenceFields.Except(newFields))
{
ComparerResult.AddRemovedItem(ResultContext.Field, field, Severity.Error);
}
// new fields
foreach (string field in newFields.Except(referenceFields))
{
ComparerResult.AddAddedItem(ResultContext.Field, field, Severity.Warning);
}
// equal fields
foreach (string field in referenceFields.Intersect(newFields))
{
ComparerResult.AddComparerResult(ComparerContext.CreateComparer(ReferenceType.GetField(field), NewType.GetField(field)).Compare());
}
}
private void CompareEvents()
{
IEnumerable <string> referenceEvents = GetEvents(ReferenceType).ToList();
IEnumerable <string> newEvents = GetEvents(NewType).ToList();
// missing event
foreach (string @event in referenceEvents.Except(newEvents))
{
ComparerResult.AddRemovedItem(ResultContext.Event, @event, Severity.Error);
}
// new event
foreach (string @event in newEvents.Except(referenceEvents))
{
ComparerResult.AddAddedItem(ResultContext.Event, @event, Severity.Warning);
}
// equal events
foreach (string @event in newEvents.Intersect(referenceEvents))
{
ComparerResult.AddComparerResult(ComparerContext.CreateComparer(ReferenceType.GetEvent(@event), NewType.GetEvent(@event)).Compare());
}
}
private void CompareTypes()
{
IEnumerable <string> referenceTypes = GetTypeNames(() => ReferenceType.DefinedTypes).ToList();
IEnumerable <string> newTypes = GetTypeNames(() => NewType.DefinedTypes).ToList();
// Missing types
foreach (string type in referenceTypes.Except(newTypes))
{
ComparerResult.AddRemovedItem(GetItemType(ReferenceType.GetType(type)), type, Severities.TypeRemoved);
}
// New types
foreach (string type in newTypes.Except(referenceTypes))
{
ComparerResult.AddAddedItem(GetItemType(NewType.GetType(type)), type, Severities.TypeAdded);
}
// Equal types
foreach (string type in referenceTypes.Intersect(newTypes))
{
ComparerResult.AddComparerResult(ComparerContext.CreateComparer(ReferenceType.GetType(type), NewType.GetType(type)).Compare());
}
}
private void CompareProperties()
{
PairList <Item> pairList = new PairList <Item>();
GetProperties(ReferenceType).ForEach(property => pairList.AddReferenceItem(new Item(property.Name, property.GetIndexParameterTypes())));
GetProperties(NewType).ForEach(property => pairList.AddNewItem(new Item(property.Name, property.GetIndexParameterTypes())));
foreach (Item property in pairList.RemovedItems)
{
ComparerResult.AddRemovedItem(ResultContext.Property, ReferenceType.GetApiProperty(property.Name, property.Types).ToString(), Severity.Error);
}
foreach (Item property in pairList.AddedItems)
{
ComparerResult.AddAddedItem(ResultContext.Property, NewType.GetApiProperty(property.Name, property.Types).ToString(), Severity.Warning);
}
foreach (ItemPair <Item> property in pairList.EqualItems)
{
PropertyInfo referenceProperty = ReferenceType.GetApiProperty(property.ReferenceItem.Name, property.ReferenceItem.Types);
PropertyInfo newProperty = NewType.GetApiProperty(property.NewItem.Name, property.NewItem.Types);
ComparerResult.AddComparerResult(ComparerContext.CreateComparer(referenceProperty, newProperty).Compare());
}
}
private void CompareMethods(Func <Type, MethodBase[]> getMethods, Func <Type, string, Type[], MethodBase> getMethod, ResultContext resultContext)
{
PairList <Item> pairList = new PairList <Item>();
AddMethodsToPairList(pairList.AddReferenceItem, () => getMethods(ReferenceType));
AddMethodsToPairList(pairList.AddNewItem, () => getMethods(NewType));
foreach (Item method in pairList.RemovedItems)
{
ComparerResult.AddRemovedItem(resultContext, getMethod(ReferenceType, method.Name, method.Types).ToString(), Severity.Error);
}
foreach (Item method in pairList.AddedItems)
{
ComparerResult.AddAddedItem(resultContext, getMethod(NewType, method.Name, method.Types).ToString(), Severity.Warning);
}
foreach (ItemPair <Item> methodPair in pairList.EqualItems)
{
MethodBase referenceMethod = getMethod(ReferenceType, methodPair.ReferenceItem.Name, methodPair.ReferenceItem.Types);
MethodBase newMethod = getMethod(NewType, methodPair.NewItem.Name, methodPair.NewItem.Types);
ComparerResult.AddComparerResult(ComparerContext.CreateComparer(referenceMethod, newMethod).Compare());
}
}
public override IComparerResult Compare()
{
ComparerContext.LogDetail(string.Format("Comparing property '{0}'", ReferenceType));
if (ReferenceType.PropertyType.GetCompareableName() != NewType.PropertyType.GetCompareableName())
{
ComparerResult.AddChangedProperty("Type", ReferenceType.PropertyType.GetCompareableName(), NewType.PropertyType.GetCompareableName(), Severity.Error);
}
if (ReferenceType.CanWrite != NewType.CanWrite)
{
ComparerResult.AddChangedFlag("Setter", ReferenceType.CanWrite, Severity.Error);
}
if (ReferenceType.CanRead != NewType.CanRead)
{
ComparerResult.AddChangedFlag("Getter", ReferenceType.CanRead, Severity.Error);
}
bool referenceStatic = (ReferenceType.GetMethod != null && ReferenceType.GetMethod.IsStatic) || (ReferenceType.SetMethod != null && ReferenceType.SetMethod.IsStatic);
bool newStatic = (NewType.GetMethod != null && NewType.GetMethod.IsStatic) || (NewType.SetMethod != null && NewType.SetMethod.IsStatic);
if (referenceStatic != newStatic)
{
ComparerResult.AddChangedFlag("Static", referenceStatic, Severity.Error);
}
return(ComparerResult);
}
private void CompareMethods(Func <Type, MethodBase[]> getMethods, ResultContext resultContext)
{
PairList <MethodItem> pairList = new PairList <MethodItem>();
getMethods(ReferenceType).ToList().ForEach(m => pairList.AddReferenceItem(new MethodItem(m)));
getMethods(NewType).ToList().ForEach(m => pairList.AddNewItem(new MethodItem(m)));
foreach (MethodItem item in pairList.RemovedItems)
{
ComparerResult.AddRemovedItem(resultContext, item.Method.ToString(), Severities.MethodRemoved);
}
foreach (MethodItem item in pairList.AddedItems)
{
ComparerResult.AddAddedItem(resultContext, item.Method.ToString(), Severities.MethodAdded);
}
foreach (ItemPair <MethodItem> itemPair in pairList.EqualItems)
{
MethodBase referenceMethod = itemPair.ReferenceItem.Method;
MethodBase newMethod = itemPair.NewItem.Method;
ComparerResult.AddComparerResult(ComparerContext.CreateComparer(referenceMethod, newMethod).Compare());
}
}
public ComparerResultModel(ComparerResult result)
{
Comparisons = result.Comperisons;
Errors = result.Errors;
}
