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; } }