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