public Compare ( KeyValuePair x, KeyValuePair y ) : int | ||
x | KeyValuePair | |
y | KeyValuePair | |
Результат | int |
public static void Ctor_CultureInfo(object a, object b, int expected) { var culture = new CultureInfo("en-US"); var comparer = new Comparer(culture); Assert.Equal(expected, Math.Sign(comparer.Compare(a, b))); }
private static unsafe int QuickSortPartion(TemplateStructType* array, int start, int end, Comparer<TemplateStructType> comparer) { TemplateStructType pivot, startValue, endValue; pivot = array[start]; while (start < end) { startValue = array[start]; while (start < end && comparer.Compare(startValue, pivot) > 0) { start++; startValue = array[start]; } endValue = array[end]; while (start < end && comparer.Compare(endValue, pivot) < 0) { end--; endValue = array[end]; } if (start < end) { array[end] = startValue; array[start] = endValue; } } return start; }
public static void TestCtor_CultureInfo(object a, object b, int expected) { var culture = new CultureInfo("en-US"); var comparer = new Comparer(culture); Assert.Equal(expected, Helpers.NormalizeCompare(comparer.Compare(a, b))); }
internal static bool GetPassword(IDataAccess dataAccess, int userId, out byte[] password, out byte[] passwordSalt, out bool isApproved, out bool isSuspended) { var entity = new UserEntity(); var oql = new OQL(entity); var comparer = new Comparer(oql); comparer = comparer.Compare(entity.UserId, "=", userId); return GetPasswordCore(dataAccess, comparer, entity, out password, out passwordSalt, out isApproved, out isSuspended) != 0; }
public void Compare() { var list = new List<string> { "76561197975995523", // ice_mouton "76561197962208538", // dubispacebar "76561197965572012", // siliticx }; var c = new Comparer(_api); var games = c.Compare(list); Assert.IsTrue(games.Count > 0); }
public void NoChange_SameOrderOfElements() { //Arrange var xml1 = @"<?xml version=""1.0"" encoding=""utf-8"" ?> <root> <elem1>This is element 1</elem1> <elem2>This is element 2</elem2> <add name=""name1"" value=""value1"" /> </root> "; var xml2 = @"<?xml version=""1.0"" encoding=""utf-8"" ?> <root> <elem1>This is element 1</elem1> <elem2>This is element 2</elem2> <add name=""name1"" value=""value1""/> </root> "; var mockHandler = new Mock<IXmlCompareHandler>(MockBehavior.Strict); //mockHandler.Setup(a => a.AttributeAdded(It.IsAny<string>(),It.IsAny<XAttribute>())); //mockHandler.Setup(a => a.AttributeChanged(It.IsAny<string>(),It.IsAny<XAttribute>(), It.IsAny<XAttribute>())); //mockHandler.Setup(a => a.AttributeRemoved(It.IsAny<string>(),It.IsAny<XAttribute>())); //mockHandler.Setup(a => a.ElementAdded(It.IsAny<string>(),It.IsAny<XElement>())); //mockHandler.Setup(a => a.ElementChanged(It.IsAny<string>(),It.IsAny<XElement>(), It.IsAny<XElement>())); //mockHandler.Setup(a => a.ElementRemoved(It.IsAny<string>(),It.IsAny<XElement>())); var comparer = new Comparer(mockHandler.Object); //act comparer.Compare(GetStream(xml1), GetStream(xml2), mockHandler.Object); //assert mockHandler.Verify(a => a.AttributeAdded(It.IsAny<AttributeAddedEventArgs>()), Times.Never); mockHandler.Verify(a => a.AttributeChanged(It.IsAny<AttributeChangedEventArgs>()), Times.Never); mockHandler.Verify(a => a.AttributeRemoved(It.IsAny<AttributeRemovedEventArgs>()), Times.Never); mockHandler.Verify(a => a.ElementAdded(It.IsAny<ElementAddedEventArgs>()), Times.Never); mockHandler.Verify(a => a.ElementChanged(It.IsAny<ElementChangedEventArgs>()), Times.Never); mockHandler.Verify(a => a.ElementRemoved(It.IsAny<ElementRemovedEventArgs>()), Times.Never); }
static void Main(string[] args) { try { var file1 = @".\TestFiles\a1.config"; var file2 = @".\TestFiles\a2.config"; var handler = new TestXmlCompareHandler(); using (var comparer = new Comparer(handler)) { comparer.Compare(file1, file2, handler); } } catch (Exception ex) { Console.WriteLine("ERROR: " + ex); } Console.Write("Press RETURN to close..."); Console.ReadLine(); }
public int Compare(TEntity first, TEntity second) { return(Comparer.Compare(ExtractValue(first), ExtractValue(second))); }
public void GeneralElement_ElementChanged() { //Arrange #region sample values var xml1 = @"<?xml version=""1.0"" encoding=""utf-8"" ?> <root> <elem1 name=""MyLogger"">This is element 1</elem1> <elem2>This is element 2</elem2> <add name=""name1"" value=""value1"" oldAttribute=""to be deleted""/> </root> "; var xml2 = @"<?xml version=""1.0"" encoding=""utf-8"" ?> <root> <elem1 name=""MyLogger"">This is element 1 but changed now</elem1> <elem2>This is element 2</elem2> <add name=""name1"" value=""value1"" oldAttribute=""to be deleted""/> </root> "; #endregion var oldValue = string.Empty; var newValue = string.Empty; var mockHandler = new Mock<IXmlCompareHandler>(MockBehavior.Strict); mockHandler.Setup(a => a.ElementChanged(It.IsAny<ElementChangedEventArgs>())) .Callback<ElementChangedEventArgs>((e) => { oldValue = e.LeftElement.ToString(); newValue = e.RightElement.ToString(); }); var comparer = new Comparer(mockHandler.Object); //act comparer.Compare(GetStream(xml1), GetStream(xml2), mockHandler.Object); //assert mockHandler.Verify(a => a.AttributeAdded(It.IsAny<AttributeAddedEventArgs>()), Times.Never); mockHandler.Verify(a => a.AttributeChanged(It.IsAny<AttributeChangedEventArgs>()), Times.Never); mockHandler.Verify(a => a.AttributeRemoved(It.IsAny<AttributeRemovedEventArgs>()), Times.Never); mockHandler.Verify(a => a.ElementAdded(It.IsAny<ElementAddedEventArgs>()), Times.Never); mockHandler.Verify(a => a.ElementChanged(It.IsAny<ElementChangedEventArgs>()), Times.Once); mockHandler.Verify(a => a.ElementRemoved(It.IsAny<ElementRemovedEventArgs>()), Times.Never); Assert.AreEqual(@"<elem1 name=""MyLogger"">This is element 1 but changed now</elem1>", newValue); }
public void GeneralElement_ChildElementChanged_WithNamespace() { //Arrange #region sample values var xml1 = @"<?xml version=""1.0"" encoding=""utf-8"" ?> <root xmlns:ns1=""http://www.example.com/ns1""> <elem1>This does not change</elem1> <ns1:elem3 attr1=""attr1""><child>This is old child in element 3</child></ns1:elem3> </root> "; var xml2 = @"<?xml version=""1.0"" encoding=""utf-8"" ?> <root xmlns:ns1=""http://www.example.com/ns1""> <elem1>This does not change</elem1> <ns1:elem3 attr1=""attr1""><child>This is new child in element 3</child></ns1:elem3> </root> "; #endregion var oldValue = string.Empty; var newValue = string.Empty; var mockHandler = new Mock<IXmlCompareHandler>(MockBehavior.Strict); mockHandler.Setup(a => a.ElementChanged(It.IsAny<ElementChangedEventArgs>())) .Callback<ElementChangedEventArgs>((e) => { oldValue = e.LeftElement.ToString(); newValue = e.RightElement.ToString(); }); var comparer = new Comparer(mockHandler.Object); //act comparer.Compare(GetStream(xml1), GetStream(xml2), mockHandler.Object); //assert mockHandler.Verify(a => a.AttributeAdded(It.IsAny<AttributeAddedEventArgs>()), Times.Never); mockHandler.Verify(a => a.AttributeChanged(It.IsAny<AttributeChangedEventArgs>()), Times.Never); mockHandler.Verify(a => a.AttributeRemoved(It.IsAny<AttributeRemovedEventArgs>()), Times.Never); mockHandler.Verify(a => a.ElementAdded(It.IsAny<ElementAddedEventArgs>()), Times.Never); mockHandler.Verify(a => a.ElementChanged(It.IsAny<ElementChangedEventArgs>()), Times.Once); mockHandler.Verify(a => a.ElementRemoved(It.IsAny<ElementRemovedEventArgs>()), Times.Never); Assert.AreEqual(@"<child>This is new child in element 3</child>", newValue); }
public int Compare(T x, T y) { return(Comparer.Compare(x.Seq, y.Seq)); }
public int Compare(Vector2D x, Vector2D y) { return(comparer.Compare(Math.Atan2(x.y, x.x), Math.Atan2(y.y, y.x))); }
/// <remarks/> public override bool IsMatch(SyslogMessage message) { if (message == null) { throw new ArgumentNullException("message"); } object property; switch (propertyName) { case Property.Severity: { property = message.Severity; break; } case Property.Facility: { property = message.Facility; break; } case Property.Timestamp: { property = message.Timestamp; break; } case Property.Host: { property = message.Host; break; } case Property.ApplicationName: { property = message.ApplicationName; break; } case Property.ProcessID: { property = message.ProcessID; break; } case Property.MessageID: { property = message.MessageId; break; } case Property.Data: { throw new NotSupportedException("Data is structured. Cannot be compared"); } case Property.Text: { property = message.Text; break; } default: { throw new ArgumentException("Invalid property"); } } if (property == null) { return(false); } if (property is IComparable) { Comparer cmp = Comparer.DefaultInvariant; int result = cmp.Compare(property, targetvalue); switch (comparison) { case ComparisonOperator.eq: { return(result == 0); } case ComparisonOperator.geq: { return(result >= 0); } case ComparisonOperator.gt: { return(result > 0); } case ComparisonOperator.leq: { return(result <= 0); } case ComparisonOperator.lt: { return(result < 0); } case ComparisonOperator.neq: { return(result != 0); } default: { throw new InvalidOperationException(); } } } if (property is int) { switch (comparison) { case ComparisonOperator.eq: { return((int)property == (int)targetvalue); } case ComparisonOperator.geq: { return((int)property >= (int)targetvalue); } case ComparisonOperator.gt: { return((int)property > (int)targetvalue); } case ComparisonOperator.leq: { return((int)property <= (int)targetvalue); } case ComparisonOperator.lt: { return((int)property < (int)targetvalue); } case ComparisonOperator.neq: { return((int)property != (int)targetvalue); } default: { throw new InvalidOperationException(); } } } if (property is DateTime) { switch (comparison) { case ComparisonOperator.eq: { return((DateTime)property == (DateTime)targetvalue); } case ComparisonOperator.geq: { return((DateTime)property >= (DateTime)targetvalue); } case ComparisonOperator.gt: { return((DateTime)property > (DateTime)targetvalue); } case ComparisonOperator.leq: { return((DateTime)property <= (DateTime)targetvalue); } case ComparisonOperator.lt: { return((DateTime)property < (DateTime)targetvalue); } case ComparisonOperator.neq: { return((DateTime)property != (DateTime)targetvalue); } default: { throw new InvalidOperationException(); } } } throw new InvalidProgramException("Software bug!"); }
public static Pair <TSource, TSource> MinMax <TSource>(this IEnumerable <TSource> source) { if (source == null) { throw new ArgumentNullException(nameof(source)); } var valueMin = default(TSource); var valueMax = default(TSource); Comparer <TSource> comparer = Comparer <TSource> .Default; TSource value = default(TSource); if (value == null) { using (var e = source.GetEnumerator()) { do { if (!e.MoveNext()) { return(new Pair <TSource, TSource>(value, value)); } value = e.Current; }while (value == null); valueMin = valueMax = value; while (e.MoveNext()) { TSource x = e.Current; if (x != null) { if (comparer.Compare(x, valueMin) < 0) { valueMin = x; } else if (comparer.Compare(x, valueMax) > 0) { valueMax = x; } } } } } else { using (var e = source.GetEnumerator()) { if (!e.MoveNext()) { throw new ArgumentException("No elements"); } valueMin = valueMax = e.Current; while (e.MoveNext()) { TSource x = e.Current; if (comparer.Compare(x, valueMin) < 0) { valueMin = x; } else if (comparer.Compare(x, valueMax) > 0) { valueMax = x; } } } } return(new Pair <TSource, TSource>(valueMin, valueMax)); }
public void Sort(Comparer <RenderOrderKey> keyComparer) { _indices.Sort( (RenderItemIndex first, RenderItemIndex second) => keyComparer.Compare(first.Key, second.Key)); }
public void Invariant() { Comparer c = Comparer.DefaultInvariant; Assert.IsTrue(c.Compare("a", "A") < 0); }
public override int Compare(RngmedValIndex x, RngmedValIndex y) { return(_comparer.Compare(x.Data, y.Data)); }
public static int?Compare <T>(Comparer <T> comparer, T first, T second) { var ret = comparer.Compare(first, second); return(ret == 0 ? new int?() : ret); }
int IComparer <PittsburgElementofStorage> .Compare(PittsburgElementofStorage x, PittsburgElementofStorage y) { return(noReverse.Compare(x.LearnError, y.LearnError)); }
int IComparer <double> .Compare(double x, double y) { return(noReverse.Compare(y, x)); }
public static T MaxBy <T, TKey>(this IEnumerable <T> src, Func <T, TKey> key, Comparer <TKey> keyComparer) => src.Aggregate((a, b) => keyComparer.Compare(key(a), key(b)) > 0 ? a : b);
void MoveTo(TK key, bool backwards) { var entries = Entries(this.CurrentNode) as IEnumerable <Entry <TK> >; var childrenAddresses = ChildrenAddresses(this.CurrentNode) as IEnumerable <Int64>; if (backwards) { entries = entries.Reverse(); childrenAddresses = childrenAddresses.Reverse(); } int i = -1; if (!backwards) { i = entries.TakeWhile(entry => Comparer.Compare(key, entry.Key) > 0).Count(); } else { i = entries.TakeWhile(entry => Comparer.Compare(key, entry.Key) < 0).Count(); } int absoluteIndex = backwards ? (entries.Count() - 1) - i : i; if (i < entries.Count() && Comparer.Compare(entries.ElementAt(i).Key, key) == 0) { //found it this.CurrentEntryIndex = absoluteIndex; return; } else if (this.CurrentNode.IsLeaf) { //it's a leaf, but no entry matches this.CurrentEntryIndex = absoluteIndex; return; } else if (i >= childrenAddresses.Count()) { //tree seems unbalanced this.CurrentEntryIndex = absoluteIndex; return; } //push the breadcrumb var breadCrumb = new BreadCrumb() { CurrentEntryIndex = backwards ? absoluteIndex : absoluteIndex - 1, Node = CurrentNode }; this.BreadCrumbs.Push(breadCrumb); // set the target child as current node this.CurrentNode = this.DataProvider.GetNode(childrenAddresses.ElementAt(i)); //and search in childnode MoveTo(key, backwards); }
public void Constructor() { Comparer c = new Comparer(CultureInfo.InvariantCulture); Assert.IsTrue(c.Compare("a", "A") < 0); }
/// <inheritdoc /> protected sealed override int Compare(TKey x, TKey y) { return(Comparer.Compare(x, y)); }
public int Compare(ReqPriority x, ReqPriority y) { return(-1 * Comparer.Compare(x, y)); }
public static Pair <TResult, TResult> MinMax <TSource, TResult>(this IEnumerable <TSource> source, Func <TSource, TResult> selector) { if (source == null) { throw new ArgumentNullException(nameof(source)); } if (selector == null) { throw new ArgumentNullException(nameof(selector)); } TResult valueMin = default(TResult); TResult valueMax = default(TResult); Comparer <TResult> comparer = Comparer <TResult> .Default; TResult value = default(TResult); if (value == null) { using (IEnumerator <TSource> e = source.GetEnumerator()) { do { if (!e.MoveNext()) { return(new Pair <TResult, TResult>(value, value)); } value = selector(e.Current); }while (value == null); valueMin = valueMax = value; while (e.MoveNext()) { TResult x = selector(e.Current); if (x != null) { if (comparer.Compare(x, valueMin) < 0) { valueMin = x; } else if (comparer.Compare(x, valueMax) > 0) { valueMax = x; } } } } } else { using (IEnumerator <TSource> e = source.GetEnumerator()) { if (!e.MoveNext()) { throw new ArgumentException("No Elements"); } valueMin = valueMax = selector(e.Current); while (e.MoveNext()) { TResult x = selector(e.Current); if (comparer.Compare(x, valueMin) < 0) { valueMin = x; } else if (comparer.Compare(x, valueMax) > 0) { valueMax = x; } } } } return(new Pair <TResult, TResult>(valueMin, valueMax)); }
public int Compare(T x, T y) { CompareCount++; return(Asc ? Comparer.Compare(x, y) : -Compare(x, y)); }
internal static Func <IDictionary <string, object>, bool> GetComparer <T>(string rangeParamName, T fromValue, T toValue) where T : IComparable { Comparer comparer = Comparer.DefaultInvariant; bool sameRange = comparer.Compare(fromValue, toValue) == 0; // FromValue == ToValue bool insideRange = comparer.Compare(fromValue, toValue) < 0; // FromValue < ToValue Func <IDictionary <string, object>, bool> compareClause; if (sameRange) { compareClause = data => { if (data == null || data.Count <= 0) { return(false); } if (!data.ContainsKey(rangeParamName)) { var error = string.Format("Cannot find column '{0}' for range query from {1} to {2} in Data={3}", rangeParamName, fromValue, toValue, StorageProviderUtils.PrintData(data)); throw new KeyNotFoundException(error); } T obj = (T)data[rangeParamName]; return(comparer.Compare(obj, fromValue) == 0); }; } else if (insideRange) { compareClause = data => { if (data == null || data.Count <= 0) { return(false); } if (!data.ContainsKey(rangeParamName)) { var error = string.Format("Cannot find column '{0}' for range query from {1} to {2} in Data={3}", rangeParamName, fromValue, toValue, StorageProviderUtils.PrintData(data)); throw new KeyNotFoundException(error); } T obj = (T)data[rangeParamName]; return(comparer.Compare(obj, fromValue) >= 0 && comparer.Compare(obj, toValue) <= 0); }; } else { compareClause = data => { if (data == null || data.Count <= 0) { return(false); } if (!data.ContainsKey(rangeParamName)) { var error = string.Format("Cannot find column '{0}' for range query from {1} to {2} in Data={3}", rangeParamName, fromValue, toValue, StorageProviderUtils.PrintData(data)); throw new KeyNotFoundException(error); } T obj = (T)data[rangeParamName]; return(comparer.Compare(obj, fromValue) >= 0 || comparer.Compare(obj, toValue) <= 0); }; } return(compareClause); }
public void NameValueElement_WithNamespace_AttributeChanged() { //Arrange #region sample values var xml1 = @"<?xml version=""1.0"" encoding=""utf-8"" ?> <root xmlns:ns1=""http://www.example.com/ns1""> <elem1>This is element 1</elem1> <elem2>This is element 2</elem2> <add name=""name1"" value=""value1"" newAttribute=""old value"" ns1:newAttribute=""old value in ns1""/> </root> "; var xml2 = @"<?xml version=""1.0"" encoding=""utf-8"" ?> <root xmlns:ns1=""http://www.example.com/ns1""> <elem1>This is element 1</elem1> <elem2>This is element 2</elem2> <add name=""name1"" value=""value1"" newAttribute=""new value"" ns1:newAttribute=""new value in ns1""/> </root> "; #endregion var oldValue1 = string.Empty; var newValue1 = string.Empty; var oldValue2 = string.Empty; var newValue2 = string.Empty; var mockHandler = new Mock<IXmlCompareHandler>(MockBehavior.Strict); mockHandler.Setup(a => a.AttributeChanged(It.IsAny<AttributeChangedEventArgs>())) .Callback<AttributeChangedEventArgs>((e) => { if (e.LeftAttribute.Name.Namespace == "") { oldValue1 = e.LeftAttribute.Value; } if (e.LeftAttribute.Name.Namespace == "http://www.example.com/ns1") { oldValue2 = e.LeftAttribute.Value; } if (e.RightAttribute.Name.Namespace == "") { newValue1 = e.RightAttribute.Value; } if (e.RightAttribute.Name.Namespace == "http://www.example.com/ns1") { newValue2 = e.RightAttribute.Value; } }); var comparer = new Comparer(mockHandler.Object); //act comparer.Compare(GetStream(xml1), GetStream(xml2), mockHandler.Object); //assert mockHandler.Verify(a => a.AttributeAdded(It.IsAny<AttributeAddedEventArgs>()), Times.Never); mockHandler.Verify(a => a.AttributeChanged(It.IsAny<AttributeChangedEventArgs>()), Times.Exactly(2)); mockHandler.Verify(a => a.AttributeRemoved(It.IsAny<AttributeRemovedEventArgs>()), Times.Never); mockHandler.Verify(a => a.ElementAdded(It.IsAny<ElementAddedEventArgs>()), Times.Never); mockHandler.Verify(a => a.ElementChanged(It.IsAny<ElementChangedEventArgs>()), Times.Never); mockHandler.Verify(a => a.ElementRemoved(It.IsAny<ElementRemovedEventArgs>()), Times.Never); Assert.AreEqual("old value", oldValue1); Assert.AreEqual("new value", newValue1); Assert.AreEqual("old value in ns1", oldValue2); Assert.AreEqual("new value in ns1", newValue2); }
/// <inheritdoc /> public override void AddRange(IEnumerable <KeyValuePair <TKey, TValue> > items) { if (items == null) { throw new ArgumentNullException(nameof(items)); } var NewItems = items.Select(item => new RangeKeyValue(item.Key, item.Value)).ToArray(); if (NewItems.Length == 0) { return; } Array.Sort(NewItems, CompareRange); // Check the new items don't have any duplicates { var Index = 0; var CurrentItem = NewItems[0]; while (++Index < NewItems.Length) { var LastItem = CurrentItem; CurrentItem = NewItems[Index]; if (Comparer.Compare(LastItem.Key, CurrentItem.Key) == 0) { throw new ArgumentException("Input collection has duplicates"); } } } // No duplicates in the new items. Check the keys aren't already in the Dictionary for (var Index = 0; Index < NewItems.Length; Index++) { var CurrentItem = NewItems[Index]; var InnerIndex = Array.BinarySearch(_Keys, 0, _Size, CurrentItem.Key); // No exact match? if (InnerIndex >= 0) { throw new ArgumentException("An item with the same key has already been added."); } NewItems[Index].EstimatedIndex = ~InnerIndex; } // Ensure we have enough space for the new items EnsureCapacity(_Size + NewItems.Length); var ItemsNotify = new KeyValuePair <TKey, TValue> [NewItems.Length]; // Add the new items for (var Index = 0; Index < NewItems.Length; Index++) { var CurrentItem = NewItems[Index]; // We need to adjust where we're inserting since these are the old indexes // Since the new items are ordered by key, we can just add the number of already added items var NewIndex = CurrentItem.EstimatedIndex + Index; // Move things up, unless we're adding at the end if (NewIndex < _Size) { Array.Copy(_Keys, NewIndex, _Keys, NewIndex + 1, _Size - NewIndex); Array.Copy(_Values, NewIndex, _Values, NewIndex + 1, _Size - NewIndex); } _Keys[NewIndex] = CurrentItem.Key; _Values[NewIndex] = CurrentItem.Value; ItemsNotify[Index] = new KeyValuePair <TKey, TValue>(CurrentItem.Key, CurrentItem.Value); _Size++; } OnCollectionChanged(NotifyCollectionChangedAction.Add, ItemsNotify); }
public int Compare(STuple <T1> x, STuple <T1> y) { return(Comparer1.Compare(x.Item1, y.Item1)); }
public void NameValueElement_AttributeAdded() { //Arrange #region sample values var xml1 = @"<?xml version=""1.0"" encoding=""utf-8"" ?> <root> <elem1>This is element 1</elem1> <elem2>This is element 2</elem2> <add name=""name1"" value=""value1"" /> </root> "; var xml2 = @"<?xml version=""1.0"" encoding=""utf-8"" ?> <root> <elem1>This is element 1</elem1> <elem2>This is element 2</elem2> <add name=""name1"" value=""value1"" newAttribute=""new value""/> </root> "; #endregion var newValue = string.Empty; var mockHandler = new Mock<IXmlCompareHandler>(MockBehavior.Strict); mockHandler.Setup(a => a.AttributeAdded(It.IsAny<AttributeAddedEventArgs>())).Callback<AttributeAddedEventArgs>((e) => { newValue = e.Attribute.Value; }); var comparer = new Comparer(mockHandler.Object); //act comparer.Compare(GetStream(xml1), GetStream(xml2), mockHandler.Object); //assert mockHandler.Verify(a => a.AttributeAdded(It.IsAny<AttributeAddedEventArgs>()), Times.Once); mockHandler.Verify(a => a.AttributeChanged(It.IsAny<AttributeChangedEventArgs>()), Times.Never); mockHandler.Verify(a => a.AttributeRemoved(It.IsAny<AttributeRemovedEventArgs>()), Times.Never); mockHandler.Verify(a => a.ElementAdded(It.IsAny<ElementAddedEventArgs>()), Times.Never); mockHandler.Verify(a => a.ElementChanged(It.IsAny<ElementChangedEventArgs>()), Times.Never); mockHandler.Verify(a => a.ElementRemoved(It.IsAny<ElementRemovedEventArgs>()), Times.Never); Assert.AreEqual("new value", newValue); }
public static Heap <T> Create <T, Key>(Func <T, Key> keySelector, Comparer <Key> keyComparer) { Comparison <T> comparison = (x, y) => keyComparer.Compare(keySelector(x), keySelector(y)); return(new Heap <T>(comparison)); }
// is there a element-value pair with the given element? public bool Contains(TEl element) { var someElement = default(TEl); return(TryFind(el => Comparer.Compare(el, element), out someElement)); }
public int Compare(T x, T y) => Comparer.Compare(_selector(x), _selector(y));
public void GeneralElement_ElementChanged_WithNamespace() { //Arrange #region sample values var xml1 = @"<?xml version=""1.0"" encoding=""utf-8"" ?> <root xmlns:ns1=""http://www.example.com/ns1""> <elem1 name=""MyLogger"">This is element 1</elem1> <elem2>This is element 2</elem2> <ns1:elem2>This is element 2 in ns1</ns1:elem2> </root> "; var xml2 = @"<?xml version=""1.0"" encoding=""utf-8"" ?> <root xmlns:ns1=""http://www.example.com/ns1""> <elem1 name=""MyLogger"">This is element 1 but changed now</elem1> <elem2>This is element 2</elem2> <ns1:elem2>This is element 2 in ns1 but changed now</ns1:elem2> </root> "; #endregion var oldValue1 = string.Empty; var newValue1 = string.Empty; var oldValue2 = string.Empty; var newValue2 = string.Empty; var mockHandler = new Mock<IXmlCompareHandler>(MockBehavior.Strict); mockHandler.Setup(a => a.ElementChanged(It.IsAny<ElementChangedEventArgs>())) .Callback<ElementChangedEventArgs>((e) => { if (e.LeftElement.Name.Namespace == "") { oldValue1 = e.LeftElement.ToString(); newValue1 = e.RightElement.ToString(); } if (e.LeftElement.Name.Namespace == "http://www.example.com/ns1") { oldValue2 = e.LeftElement.ToString(); newValue2 = e.RightElement.ToString(); } }); var comparer = new Comparer(mockHandler.Object); //act comparer.Compare(GetStream(xml1), GetStream(xml2), mockHandler.Object); //assert mockHandler.Verify(a => a.AttributeAdded(It.IsAny<AttributeAddedEventArgs>()), Times.Never); mockHandler.Verify(a => a.AttributeChanged(It.IsAny<AttributeChangedEventArgs>()), Times.Never); mockHandler.Verify(a => a.AttributeRemoved(It.IsAny<AttributeRemovedEventArgs>()), Times.Never); mockHandler.Verify(a => a.ElementAdded(It.IsAny<ElementAddedEventArgs>()), Times.Never); mockHandler.Verify(a => a.ElementChanged(It.IsAny<ElementChangedEventArgs>()), Times.Exactly(2)); mockHandler.Verify(a => a.ElementRemoved(It.IsAny<ElementRemovedEventArgs>()), Times.Never); Assert.AreEqual(@"<elem1 name=""MyLogger"">This is element 1</elem1>", oldValue1); Assert.AreEqual(@"<elem1 name=""MyLogger"">This is element 1 but changed now</elem1>", newValue1); Assert.AreEqual(@"<ns1:elem2 xmlns:ns1=""http://www.example.com/ns1"">This is element 2 in ns1</ns1:elem2>", oldValue2); Assert.AreEqual(@"<ns1:elem2 xmlns:ns1=""http://www.example.com/ns1"">This is element 2 in ns1 but changed now</ns1:elem2>", newValue2); }
public int Compare(T x, T y) { return(_defaultComparer.Compare(y, x)); }
public bool runTest() { //////////// Global Variables used for all tests int iCountErrors = 0; int iCountTestcases = 0; Comparer comp; string[] str1 = { "Apple", "abc", }; string[] str2 = { "Æble", "ABC" }; try { do { ///////////////////////// START TESTS //////////////////////////// /////////////////////////////////////////////////////////////////// //[] Vanilla test case - The TextInfo property of the CultureInfo is used in the CaseInsensitiveHashCodeProvider //TextInfo has GetCaseInsensitiveHashCode() methods iCountTestcases++; var somePopularCultureNames = new string[] { "cs-CZ","da-DK","de-DE","el-GR","en-US", "es-ES","fi-FI","fr-FR","hu-HU","it-IT", "ja-JP","ko-KR","nb-NO","nl-NL","pl-PL", "pt-BR","pt-PT","ru-RU","sv-SE","tr-TR", "zh-CN","zh-HK","zh-TW" }; foreach (string cultureName in somePopularCultureNames) { CultureInfo culture = new CultureInfo(cultureName); if (culture == null) { continue; } iCountTestcases++; comp = new Comparer(culture); //The following cultures do this the other way round //da-DK, is-IS, nb-NO, nn-NO if (culture.Name != "da-DK" && culture.Name != "is-IS" && culture.Name != "nb-NO" && culture.Name != "nn-NO") { if (comp.Compare(str1[0], str2[0]) != 1) { iCountErrors++; Console.WriteLine("Err_3245sdg, Wrong value returned, {0}, culture: {1}", comp.Compare(str1[0], str2[0]), culture); } } else { if (comp.Compare(str1[0], str2[0]) != -1) { iCountErrors++; Console.WriteLine("Err_297dg, Wrong value returned, {0}, culture: {1}", comp.Compare(str1[0], str2[0]), culture.Name); } } if (comp.Compare(str1[1], str2[1]) != -1) { iCountErrors++; Console.WriteLine("Err_3467tsg, Wrong value returned, {0}, culture: {1}", comp.Compare(str1[1], str2[1]), culture.Name); } } //[] Call ctor with null CultureInfo try { comp = new Comparer((CultureInfo)null); iCountErrors++; Console.WriteLine("Err_89743asjppn Expected ctor to throw ArgumentNullException"); } catch (ArgumentNullException) { } catch (Exception e) { iCountErrors++; Console.WriteLine("Err_4447abcn Unexpected exceptin thrown: {0}", e); } /////////////////////////// END TESTS ///////////////////////////// } while (false); } catch (Exception exc_general) { ++iCountErrors; Console.WriteLine(" : Error Err_8888yyy! exc_general==\n" + exc_general.ToString()); } //// Finish Diagnostics if (iCountErrors == 0) { return true; } else { Console.WriteLine("Fail! iCountErrors==" + iCountErrors); return false; } }
protected override bool Dominates(T x, T y) { return(Comparer.Compare(x, y) <= 0); }
internal static Comparer GetUserIdentityComparer(string identity, string @namespace, Comparer comparer, UserEntity entity, out UserIdentityType identityType) { if(string.IsNullOrWhiteSpace(identity)) throw new ArgumentNullException("identity"); string text; // 默认条件 comparer = comparer & comparer.Compare(entity.Namespace, "=", TrimNamespace(@namespace)); if(Zongsoft.Text.TextRegular.Web.Email.IsMatch(identity, out text)) { identityType = UserIdentityType.Email; comparer = comparer & comparer.Compare(entity.Email, "=", text); } else if(Zongsoft.Text.TextRegular.Chinese.Cellphone.IsMatch(identity, out text)) { identityType = UserIdentityType.Phone; comparer = comparer & comparer.Compare(entity.PhoneNumber, "=", text); } else { identityType = UserIdentityType.Name; comparer = comparer & comparer.Compare(entity.Name, "=", text); } return comparer; }
public bool runTest() { //////////// Global Variables used for all tests int iCountErrors = 0; int iCountTestcases = 0; Comparer comp; string[] str1 = { "Apple", "abc", }; string[] str2 = { "Æble", "ABC" }; try { do { ///////////////////////// START TESTS //////////////////////////// /////////////////////////////////////////////////////////////////// //[] Vanilla test case - The TextInfo property of the CultureInfo is used in the CaseInsensitiveHashCodeProvider //TextInfo has GetCaseInsensitiveHashCode() methods iCountTestcases++; var somePopularCultureNames = new string[] { "cs-CZ", "da-DK", "de-DE", "el-GR", "en-US", "es-ES", "fi-FI", "fr-FR", "hu-HU", "it-IT", "ja-JP", "ko-KR", "nb-NO", "nl-NL", "pl-PL", "pt-BR", "pt-PT", "ru-RU", "sv-SE", "tr-TR", "zh-CN", "zh-HK", "zh-TW" }; foreach (string cultureName in somePopularCultureNames) { CultureInfo culture = new CultureInfo(cultureName); if (culture == null) { continue; } iCountTestcases++; comp = new Comparer(culture); //The following cultures do this the other way round //da-DK, is-IS, nb-NO, nn-NO if (culture.Name != "da-DK" && culture.Name != "is-IS" && culture.Name != "nb-NO" && culture.Name != "nn-NO") { if (comp.Compare(str1[0], str2[0]) != 1) { iCountErrors++; Console.WriteLine("Err_3245sdg, Wrong value returned, {0}, culture: {1}", comp.Compare(str1[0], str2[0]), culture); } } else { if (comp.Compare(str1[0], str2[0]) != -1) { iCountErrors++; Console.WriteLine("Err_297dg, Wrong value returned, {0}, culture: {1}", comp.Compare(str1[0], str2[0]), culture.Name); } } if (comp.Compare(str1[1], str2[1]) != -1) { iCountErrors++; Console.WriteLine("Err_3467tsg, Wrong value returned, {0}, culture: {1}", comp.Compare(str1[1], str2[1]), culture.Name); } } //[] Call ctor with null CultureInfo try { comp = new Comparer((CultureInfo)null); iCountErrors++; Console.WriteLine("Err_89743asjppn Expected ctor to throw ArgumentNullException"); } catch (ArgumentNullException) { } catch (Exception e) { iCountErrors++; Console.WriteLine("Err_4447abcn Unexpected exceptin thrown: {0}", e); } /////////////////////////// END TESTS ///////////////////////////// } while (false); } catch (Exception exc_general) { ++iCountErrors; Console.WriteLine(" : Error Err_8888yyy! exc_general==\n" + exc_general.ToString()); } //// Finish Diagnostics if (iCountErrors == 0) { return(true); } else { Console.WriteLine("Fail! iCountErrors==" + iCountErrors); return(false); } }
public virtual int Compare(object x, object y) { if (x is string) { return ((string)x).CompareTo((string)y); } var comparer = new Comparer(System.Globalization.CultureInfo.InvariantCulture); if (x is int || y is string) { return comparer.Compare(x, y); } return -1; }
protected override bool MatchesImpl(IAttributeBag attributeBag, ConstraintContext context) { var element = attributeBag.GetAdapter <Element>(); return(element != null && Comparer.Compare(IsVisible(element).ToString())); }
private bool MatchesKey(TKey key, SkipListNode currentNode) { return(!(currentNode is HeaderSkipListNode) && _comparer.Compare(key, currentNode.Key) == 0); }
public int Compare(Point x, Point y) { return(double_cmp.Compare(x.X, y.X)); }