public string Compare(ComparerType type, string firstPath, string secondPath)
{
var firstContent = ParserFactory.Create(firstPath).GetAllResults(firstPath);
var secondContent = ParserFactory.Create(secondPath).GetAllResults(secondPath);
var generator = DifferentsInFilesGeneratorFactory.Create(type, firstContent, secondContent);
return generator.Generate();
}
/// <summary>
/// Listens for finder events which are useful for finding potential comparison problems.
///
/// The default implementation logs warnings on registration collisions, the use of inefficient or invalid comparers, and unregistered find requests for value types if JIT is disabled.
/// </summary>
public virtual void HandleFinderEvent(ComparerType comparerType, EventType eventType, Type type)
{
switch (eventType)
{
case EventType.FindUnregistered:
if (NoJit && type.IsValueType)
{
Debug.LogWarning("A " + comparerType.ToStringCached() + " has been requested for a non-registered value type with JIT disabled, this is a fragile operation and may result in a JIT exception.\nType:" + type.FullName);
}
break;
case EventType.InefficientDefault:
Debug.LogWarning("A " + comparerType.ToStringCached() + " has been requested that will perform inefficient comparisons and/or cause boxing allocations.\nType:" + type.FullName);
break;
case EventType.InvalidDefault:
Debug.LogWarning("A " + comparerType.ToStringCached() + " has been requested for a non-comparable type. Using the comparer will cause exceptions.\nType:" + type.FullName);
break;
case EventType.AlreadyRegistered:
Debug.LogWarning("Tried to register a " + comparerType.ToStringCached() + " over an existing registration.\nType: " + type.FullName);
break;
default:
break;
}
}
public void FalseMoreThenTrueForDescendingInBoolean()
{
comparer = new BooleanComparer(System.ComponentModel.ListSortDirection.Descending);
int compareResult = comparer.Compare(false.ToString(), true.ToString());
Assert.AreEqual(1, compareResult);
}
/// <summary>
/// Compare the property value.
/// </summary>
/// <param name="val1">The property value.</param>
/// <param name="val2">The property value.</param>
/// /// <param name="propType">The property type.</param>
/// <param name="compareType">The compare type.</param>
/// <returns>Return the result.</returns>
public static bool Compare(this JToken val1, JToken val2, string propType, ComparerType compareType)
{
if (0 != string.Compare("Edm.Int16", propType, true) &&
0 != string.Compare("Edm.Int32", propType, true) &&
0 != string.Compare("Edm.Int64", propType, true) &&
0 != string.Compare("Edm.String", propType, true))
{
throw new Exception("Invalid value of property type, please use the 'Edm.Int16', 'Edm.Int32', 'Edm.Int64' or 'Edm.String' as the value of the input parameter 'propType'.");
}
var result = false;
if (0 == string.Compare("Edm.Int16", propType, true) ||
0 == string.Compare("Edm.Int32", propType, true) ||
0 == string.Compare("Edm.Int64", propType, true))
{
result = CompareOperationHelper.Int64Compare(val1, val2, compareType);
}
else if (0 == string.Compare("Edm.String", propType, true))
{
result = CompareOperationHelper.StringCompare(val1, val2, compareType);
}
return(result);
}
public void Text2MoreThanText11ForDescendingInNatural()
{
comparer = new NaturalComparer(System.ComponentModel.ListSortDirection.Descending);
int compareResult = comparer.Compare("text2", "text11");
Assert.AreEqual(1, compareResult);
}
public void TodayMoreThenTomorrowForDescendingInText()
{
comparer = new DateComparer(System.ComponentModel.ListSortDirection.Descending);
int compareResult = comparer.Compare(DateTime.Now.ToString(), DateTime.Now.AddDays(1).ToString());
Assert.AreEqual(1, compareResult);
}
public void TwoMoreThenThreeForAscendingInText()
{
comparer = new TextComparer(System.ComponentModel.ListSortDirection.Ascending);
int compareResult = comparer.Compare("two", "three");
Assert.AreEqual(1, compareResult);
}
public void TwoMoreThenThreeForDescendingInNumber()
{
comparer = new NumberComparer(System.ComponentModel.ListSortDirection.Descending);
int compareResult = comparer.Compare(2.ToString(), 3.ToString());
Assert.AreEqual(1, compareResult);
}
public static IDifferentsInFilesGenerator Create(ComparerType type, List<string> content1, List<string> content2)
{
switch (type)
{
case ComparerType.Custom: return new CustomDifferentsInFilesGenerator(content1, content2);
}
throw new ArgumentException();
}
public string Compare(ComparerType type, string firstPath, string secondPath)
{
var firstContent = ParserFactory.Create(firstPath).GetAllResults(firstPath);
var secondContent = ParserFactory.Create(secondPath).GetAllResults(secondPath);
var generator = DifferentsInFilesGeneratorFactory.Create(type, firstContent, secondContent);
return(generator.Generate());
}
public static IDifferentsInFilesGenerator Create(ComparerType type, List <string> content1, List <string> content2)
{
switch (type)
{
case ComparerType.Custom: return(new CustomDifferentsInFilesGenerator(content1, content2));
}
throw new ArgumentException();
}
public void Compare_Boolean_ThrowsArgumentException(ComparerType comparerType)
{
var info = Mock.Of <PredicateArgs>(
i => i.ColumnType == ColumnType.Boolean &&
i.ComparerType == comparerType
);
var factory = new PredicateFactory();
Assert.Throws <ArgumentOutOfRangeException>(delegate { factory.Instantiate(info); });
}
public void Compare_Boolean_ThrowsArgumentException(ComparerType comparerType)
{
var info = Mock.Of <IPredicateInfo>(
i => i.ColumnType == ColumnType.Boolean &&
i.ComparerType == comparerType
);
var factory = new PredicateFactory();
Assert.Throws <ArgumentException>(delegate { factory.Get(info); });
}
public void Compare_Numeric_Result(ComparerType comparerType, object x, bool result)
{
var info = Mock.Of <PredicateArgs>(
i => i.ColumnType == ColumnType.Numeric &&
i.ComparerType == comparerType
);
var factory = new PredicateFactory();
var comparer = factory.Instantiate(info);
Assert.That(comparer.Execute(x), Is.EqualTo(result));
}
public void Apply_Text_Failure(ComparerType comparerType, object x)
{
var info = Mock.Of <PredicateArgs>(
i => i.ColumnType == ColumnType.Text &&
i.ComparerType == comparerType
);
var factory = new PredicateFactory();
var comparer = factory.Instantiate(info);
Assert.That(comparer.Execute(x), Is.False);
}
public void Compare_Numeric_Result(ComparerType comparerType, object x, bool result)
{
var info = Mock.Of <IPredicateInfo>(
i => i.ColumnType == ColumnType.Numeric &&
i.ComparerType == comparerType
);
var factory = new PredicateFactory();
var comparer = factory.Get(info);
Assert.That(comparer.Apply(x), Is.EqualTo(result));
}
public void Compare_DateTime_Success(ComparerType comparerType, int x, int y)
{
var info = Mock.Of <IPredicateInfo>(
i => i.ColumnType == ColumnType.DateTime &&
i.ComparerType == comparerType
);
var factory = new PredicateFactory();
var comparer = factory.Get(info);
Assert.That(comparer.Compare(new DateTime(2015, x, 1), new DateTime(2015, y, 1)), Is.True);
}
public void Compare_DateTime_Result(ComparerType comparerType, int hours, int minutes, int seconds, bool result)
{
var info = Mock.Of <IPredicateInfo>(
i => i.ColumnType == ColumnType.DateTime &&
i.ComparerType == comparerType
);
var factory = new PredicateFactory();
var comparer = factory.Get(info);
Assert.That(comparer.Apply(new DateTime(2015, 10, 1, hours, minutes, seconds)), Is.EqualTo(result));
}
public void Apply_Text_Success(ComparerType comparerType, object x)
{
var info = Mock.Of <IPredicateInfo>(
i => i.ColumnType == ColumnType.Text &&
i.ComparerType == comparerType
);
var factory = new PredicateFactory();
var comparer = factory.Instantiate(info);
Assert.That(comparer.Apply(x), Is.True);
}
public void Compare_Numeric_Success(ComparerType comparerType, object x, object y)
{
var info = Mock.Of <IPredicateInfo>(
i => i.ColumnType == ColumnType.Numeric &&
i.ComparerType == comparerType
);
var factory = new PredicateFactory();
var comparer = factory.Get(info);
Assert.That(comparer.Compare(x, y), Is.True);
}
public void Apply_Text_Failure(ComparerType comparerType, object x)
{
var info = Mock.Of <IPredicateInfo>(
i => i.ColumnType == ColumnType.Text &&
i.ComparerType == comparerType
);
var factory = new PredicateFactory();
var comparer = factory.Get(info);
Assert.That(comparer.Apply(x), Is.False);
}
public void Compare_Boolean_Success(ComparerType comparerType, object x, bool result)
{
var info = Mock.Of <IPredicateInfo>(
i => i.ColumnType == ColumnType.Boolean &&
i.ComparerType == comparerType
);
var factory = new PredicateFactory();
var comparer = factory.Instantiate(info);
Assert.That(comparer.Apply(x), Is.EqualTo(result));
}
public void Compare_Text_Success(ComparerType comparerType, object x, string culture)
{
var predicate = new Mock <CultureSensitivePredicateArgs>();
predicate.SetupGet(p => p.ColumnType).Returns(ColumnType.Text);
predicate.SetupGet(p => p.ComparerType).Returns(comparerType);
predicate.SetupGet(p => p.Culture).Returns(culture);
var factory = new PredicateFactory();
var comparer = factory.Instantiate(predicate.Object);
Assert.That(comparer.Execute(x), Is.True);
}
public void Compare_DateTime_Success(ComparerType comparerType, int x, int y)
{
var predicate = new Mock <IPredicateInfo>();
predicate.SetupGet(p => p.ColumnType).Returns(ColumnType.DateTime);
predicate.SetupGet(p => p.ComparerType).Returns(comparerType);
predicate.As <IReferencePredicateInfo>().SetupGet(p => p.Reference).Returns((object)new DateTime(2015, y, 1));
var factory = new PredicateFactory();
var comparer = factory.Instantiate(predicate.Object);
Assert.That(comparer.Execute(new DateTime(2015, x, 1)), Is.True);
}
public void Compare_Text_Success(ComparerType comparerType, object x, object y)
{
var info = Mock.Of <IPredicateInfo>(
i => i.ColumnType == ColumnType.Text &&
i.ComparerType == comparerType &&
i.Reference == y
);
var factory = new PredicateFactory();
var comparer = factory.Get(info);
Assert.That(comparer.Apply(x), Is.True);
}
public void Compare_Numeric_Failure(ComparerType comparerType, object x, object y)
{
var info = Mock.Of <IPredicateInfo>(
i => i.ColumnType == ColumnType.Numeric &&
i.ComparerType == comparerType &&
i.Reference == y
);
var factory = new PredicateFactory();
var comparer = factory.Get(info);
Assert.That(comparer.Apply(x), Is.False);
}
public void Compare_DateTime_Success(ComparerType comparerType, int x, int y)
{
var predicate = new Mock <ReferencePredicateArgs>();
predicate.SetupGet(p => p.ColumnType).Returns(ColumnType.DateTime);
predicate.SetupGet(p => p.ComparerType).Returns(comparerType);
predicate.SetupGet(p => p.Reference).Returns(new LiteralScalarResolver <DateTime>(new DateTime(2015, y, 1)));
var factory = new PredicateFactory();
var comparer = factory.Instantiate(predicate.Object);
Assert.That(comparer.Execute(new DateTime(2015, x, 1)), Is.True);
}
public void Compare_Numeric_Failure(ComparerType comparerType, object x, object y)
{
var predicate = new Mock <IPredicateInfo>();
predicate.SetupGet(p => p.ColumnType).Returns(ColumnType.Numeric);
predicate.SetupGet(p => p.ComparerType).Returns(comparerType);
predicate.As <IReferencePredicateInfo>().SetupGet(p => p.Reference).Returns(y);
var factory = new PredicateFactory();
var comparer = factory.Instantiate(predicate.Object);
Assert.That(comparer.Execute(x), Is.False);
}
public void Compare_DateTime_Success(ComparerType comparerType, int x, int y)
{
var info = Mock.Of <IPredicateInfo>(
i => i.ColumnType == ColumnType.DateTime &&
i.ComparerType == comparerType &&
i.Reference == (object)new DateTime(2015, y, 1)
);
var factory = new PredicateFactory();
var comparer = factory.Instantiate(info);
Assert.That(comparer.Apply(new DateTime(2015, x, 1)), Is.True);
}
public void Compare_Text_Failure(ComparerType comparerType, object x, string culture)
{
var predicate = new Mock <IPredicateInfo>();
predicate.SetupGet(p => p.ColumnType).Returns(ColumnType.Text);
predicate.SetupGet(p => p.ComparerType).Returns(comparerType);
predicate.As <ICultureSensitivePredicateInfo>().SetupGet(p => p.Culture).Returns(culture);
var factory = new PredicateFactory();
var comparer = factory.Instantiate(predicate.Object);
Assert.That(comparer.Execute(x), Is.False);
}
public void Compare_Boolean_Success(ComparerType comparerType, object x, object y)
{
var predicate = new Mock <IPredicateInfo>();
predicate.SetupGet(p => p.ColumnType).Returns(ColumnType.Boolean);
predicate.SetupGet(p => p.ComparerType).Returns(comparerType);
predicate.As <IReferencePredicateInfo>().SetupGet(p => p.Reference).Returns((object)y);
var factory = new PredicateFactory();
var comparer = factory.Instantiate(predicate.Object);
Assert.That(comparer.Execute(x), Is.True);
}
public void Compare_TextIgnoreCase_Success(ComparerType comparerType, object x, object y)
{
var info = Mock.Of <IPredicateInfo>(
i => i.ColumnType == ColumnType.Text &&
i.ComparerType == comparerType &&
i.Reference == y &&
i.StringComparison == StringComparison.InvariantCultureIgnoreCase
);
var factory = new PredicateFactory();
var comparer = factory.Get(info);
Assert.That(comparer.Apply(x), Is.True);
}
protected virtual void HandleFinderEvent(ComparerType comparerType, EventType eventType, Type type) {
if (eventType == EventType.FindUnregistered && type.IsValueType) {
switch (comparerType) {
case ComparerType.Comparer:
comparers.Add(type);
break;
case ComparerType.EqualityComparer:
equalityComparers.Add(type);
break;
default:
break;
}
}
}
public static SUIComparer GetComparer(ComparerType type)
{
switch (type)
{
case ComparerType.File:
return new SUIFileComparer();
case ComparerType.Image:
return new SUIImageComparer();
case ComparerType.Color:
return new SUIColorComparer();
case ComparerType.WindowImage:
return new SUIWindowImageComparer();
default:
return null;
}
}
