public void Equals_EqualValues_True() { var compare = new FuncComparer<A>((x, y) => x.Value == y.Value); var value = new A { Value = 1 }; Assert.True(compare.Equals(value, value)); }
public void compare_test() { var funcComparer = new FuncComparer<int>((x, y) => y.CompareTo(x)); Assert.That(funcComparer.Compare(1, 2), Is.EqualTo(1)); Assert.That(funcComparer.Compare(5, -1), Is.EqualTo(-1)); Assert.That(funcComparer.Compare(4, 4), Is.EqualTo(0)); }
public void Equals_NotEqualValues_False() { var compare = new FuncComparer<A>((x, y) => x.Value == y.Value); var value1 = new A { Value = 1 }; var value2 = new A { Value = 2 }; Assert.False(compare.Equals(value1, value2)); }
public void Compare_SecondObjectIsNull_ReturnsOne() { var comparer = new FuncComparer <ComparerTestObject, string>(x => x.StrValue, SortOrder.Ascending); var result = comparer.Compare(new ComparerTestObject(), null); Assert.Equal(1, result); }
public void Compare_FirstObjectIsNull_ReturnsMinusOne() { var comparer = new FuncComparer <ComparerTestObject, string>(x => x.StrValue, SortOrder.Ascending); var result = comparer.Compare(null, new ComparerTestObject()); Assert.Equal(-1, result); }
public void Compare_AllObjectsNull_ReturnsZero() { var comparer = new FuncComparer <ComparerTestObject, string>(x => x.StrValue, SortOrder.Ascending); var result = comparer.Compare(null, null); Assert.Equal(0, result); }
public void Equals_EqualValues_True() { var compare = new FuncComparer <A>((x, y) => x.Value == y.Value); var value = new A { Value = 1 }; Assert.True(compare.Equals(value, value)); }
public void Equals_NotEqualValues_False() { var compare = new FuncComparer <A>((x, y) => x.Value == y.Value); var value1 = new A { Value = 1 }; var value2 = new A { Value = 2 }; Assert.False(compare.Equals(value1, value2)); }
private List<TagEntity> GetCommonTags() { List<TagEntity> result = _images.First().Tags; IEnumerable<List<TagEntity>> imageTags = _images.Select(x => x.Tags); var comparer = new FuncComparer<TagEntity>((x, y) => x.Equals(y)); foreach (List<TagEntity> tags in imageTags) { result = result.Intersect(tags, comparer).ToList(); } return result; }
public void compare_multiple_test() { Func<string, string, int> skipX = (str1, str2) => string.Compare(str1, "skipX", StringComparison.Ordinal); Func<string, string, int> skipY = (str1, str2) => string.Compare(str2, "skipY", StringComparison.Ordinal); var funcComparer = new FuncComparer<string>( skipX, skipY, (str1, str2) => string.Compare(str1, str2, StringComparison.Ordinal)); Assert.That(funcComparer.Compare("X", "Y"), Is.EqualTo(skipX("X", "Y"))); Assert.That(funcComparer.Compare("skipX", "Y"), Is.EqualTo(skipY("skipX", "Y"))); Assert.That(funcComparer.Compare("skipX", "skipY"), Is.EqualTo(string.Compare("skipX", "skipY", StringComparison.Ordinal))); }
public void Compare_StrValue_ReturnCorrectCompareResult(string value0, string value1, int expectedResult) { var obj0 = new ComparerTestObject { StrValue = value0 }; var obj1 = new ComparerTestObject { StrValue = value1 }; var comparer = new FuncComparer <ComparerTestObject, string>(x => x.StrValue, SortOrder.Ascending); var result = comparer.Compare(obj0, obj1); Assert.Equal(expectedResult, result); }
public void Compare_IntValue_ReturnCorrectCompareResult(int value0, int value1, int expectedResult) { var obj0 = new ComparerTestObject { IntValue1 = value0 }; var obj1 = new ComparerTestObject { IntValue1 = value1 }; var comparer = new FuncComparer <ComparerTestObject, int>(x => x.IntValue1, SortOrder.Ascending); var result = comparer.Compare(obj0, obj1); Assert.Equal(expectedResult, result); }
public static void FuncDictionaryAdd(int[] xs, string[] ys, int key, string value) { var intComp = new FuncComparer <int>((x, y) => x.CompareTo(y), x => x.GetHashCode()); var fd = new FuncDictionary <int, string>(intComp, (xs ?? new int[0]).Zip(ys ?? new string[0])); var origLength = fd.Count; fd.Add(key, value); var dict = new FuncDictionary <int, string>(intComp, (xs ?? new int[0]).Zip(ys ?? new string[0])) { { key, value } }; Assert.Equal(dict.OrderBy(kv => kv.Key), fd.OrderBy(kv => kv.Key)); Assert.Equal(origLength + 1, fd.Count); }
/// <summary> /// Implementation of sorting by a bubble. /// </summary> /// <param name="items">input jagged array</param> /// <param name="filterArray">array of row sorting characteristics.</param> /// <param name="comparer">Compares value when sorting.</param> private void BubbleSort(int[][] items, int[] filterArray, FuncComparer comparer) { bool swapped; do { swapped = false; for (int i = 1; i < items.Length; i++) { if (comparer(filterArray[i - 1], filterArray[i])) { Swap(items, i - 1, i); Swap(filterArray, i - 1, i); swapped = true; } } }while (swapped != false); }
public void CompareTest() { var comp = FuncComparer.Make <int>(); Assert.True(comp.Compare(4, 4) == 0); Assert.True(comp.Compare(7, 4) == 1); Assert.True(comp.Compare(4, 7) == -1); Assert.Equal(50.GetHashCode(), comp.GetHashCode(50)); Assert.True(comp.Equals(5, 5)); Assert.False(comp.Equals(8, 5)); comp = FuncComparer.Make <int>((x, y) => x.CompareTo(y), x => x.GetHashCode()); Assert.True(comp.Compare(4, 4) == 0); Assert.True(comp.Compare(7, 4) == 1); Assert.True(comp.Compare(4, 7) == -1); Assert.Equal(50.GetHashCode(), comp.GetHashCode(50)); Assert.NotEqual(comp.GetHashCode(50), comp.GetHashCode(60)); Assert.True(comp.Equals(5, 5)); Assert.False(comp.Equals(8, 5)); }
// // Summary: // Sorts the elements of a sequence in ascending order by using a specified // comparer. // // Parameters: // source: // A sequence of values to order. // // keySelector: // A function to extract a key from an element. // // comparer: // A function to compare keys. // // Type parameters: // TSource: // The type of the elements of source. // // TKey: // The type of the key returned by keySelector. // // Returns: // An System.Linq.IOrderedEnumerable<TElement> whose elements are sorted according // to a key. // // Exceptions: // System.ArgumentNullException: // source or keySelector is null. public static IOrderedEnumerable <TSource> OrderBy <TSource, TKey>(this IEnumerable <TSource> source, Func <TSource, TKey> keySelector, Func <TKey, TKey, int> comparer) { FuncComparer <TKey> fc = new FuncComparer <TKey>(comparer); return(source.OrderBy(keySelector, fc)); }
private void RemoveEmpyTags(List<TagEntity> tags) { if (tags.IsNullOrEmpty()) { return; } var comparer = new FuncComparer<TagEntity>((x, y) => x.Equals(y)); tags = tags.Distinct(comparer).ToList(); var emptyTags = new List<TagEntity>(); foreach (TagEntity tag in tags) { if (_taggedImages.Values.Any(x => x.ContainsTag(tag)) == false) { emptyTags.Add(tag); } } TagCache.Instance.Remove(emptyTags); }
private List<ImageEntity> GetUntagged() { var result = new List<ImageEntity>(); var comparer = new FuncComparer<ImageEntity>((x, y) => x.Equals(y)); lock (_locker) { List<ImageEntity> untaggedImages = _actualImages.Values.Except(_taggedImages.Values.ToList(), comparer).ToList(); result.AddRange(untaggedImages); return result; } }
private List<TagEntity> GetDistinctTags(List<ImageEntity> images) { var comparer = new FuncComparer<TagEntity>((x, y) => x.Equals(y)); return images.SelectMany(x => x.Tags).Distinct(comparer).ToList(); }
public static IEnumerable <T> DistinctBy <T, TOut>(this IEnumerable <T> source, Func <T, TOut> func) { var comparer = new FuncComparer <T, TOut>(func); return(source.Distinct(comparer)); }
private List<TagEntity> GetTags() { var commparer = new FuncComparer<TagEntity>((x, y) => x.Equals(y)); List<TagEntity> commonTags = _controller.GetCommonTags(); return _tagCache.GetUserTags() .Except(commonTags, commparer) .ToList(); }