// void SetSettingAuxiliary<T>(string key, T value, Type settingType,
// bool xmlConvertible, out bool alreadySet)
// {
// alreadySet = false;
// cache.Remove(key);
//
// object existingValue;
// if (localStore.Status == SettingsStoreStatus.Ready
// && localStore.TryGetValue(key, settingType, out existingValue)
// || (roamingStore != null && roamingStore.Status == SettingsStoreStatus.Ready
// && roamingStore.TryGetValue(key, settingType, out existingValue)))
// {
// if (xmlConvertible)
// {
// object existingObject;
// if (TryConvertFromXml(settingType, existingValue, out existingObject))
// {
// if (object.Equals(existingObject, value))
// {
// alreadySet = true;
// return;
// }
// }
// }
// else if (existingValue != null && existingValue is byte[] && settingType != typeof(byte[]))
// {
// var existingObject = SilverlightSerializer.Deserialize((byte[])existingValue);
// if (AreEqual(value, existingObject))
// {
// alreadySet = true;
// return;
// }
// }
//
// if (existingValue != null && existingValue.Equals(value))
// {
// alreadySet = true;
// return;
// }
// }
//
// if (transientStore.Status == SettingsStoreStatus.Ready
// && transientStore.TryGetValue(key, settingType, out existingValue)
// && existingValue.Equals(value))
// {
// alreadySet = true;
// }
// }
static bool AreEqual <T>(T value, object existingObject)
{
if (existingObject != null &&
existingObject is IDictionary &&
value is IDictionary)
{
if (CollectionComparer.AreEqualDictionaries((IDictionary)existingObject, (IDictionary)value))
{
return(true);
}
}
else if (existingObject != null &&
existingObject is IList &&
value is IList)
{
if (CollectionComparer.AreEqualLists((IList)existingObject, (IList)value))
{
return(true);
}
}
if (object.Equals(existingObject, value))
{
return(true);
}
return(false);
}
public void AreCollectionsEquivalentByItemProperties_All_Items_Is_Equal()
{
var list1 = new List <MyTestObject>
{
new MyTestObject
{
Id = 1,
Description = "Description1"
},
new MyTestObject
{
Id = 2,
Description = "Description2"
}
};
var list2 = new List <MyTestObject> // data matching list1
{
new MyTestObject
{
Id = 1,
Description = "Description1"
},
new MyTestObject
{
Id = 2,
Description = "Description2"
}
};
var result = CollectionComparer.AreCollectionsEqualByItemProperties(list1, list2);
Assert.True(result);
}
public void AreCollectionsEquivalentByItemProperties_One_Item_Is_Not_Equal()
{
var list1 = new List <MyTestObject>
{
new MyTestObject
{
Id = 1,
Description = "Description1"
},
new MyTestObject
{
Id = 2,
Description = "Description2"
}
};
var list2 = new List <MyTestObject>
{
new MyTestObject
{
Id = 1,
Description = "Description1"
},
new MyTestObject
{
Id = 3, // not 2 like in list 1
Description = "Description2"
}
};
var result = CollectionComparer.AreCollectionsEqualByItemProperties(list1, list2);
Assert.False(result);
}
public void TestCollectionComparionNullSanity()
{
var comparer = new CollectionComparer();
Assert.IsTrue(comparer.Equals(null, null), "Comparer dit not evaluate null and null as equal");
Assert.IsFalse(comparer.Equals(null, new object()), "Comparer thinks null == new object()");
Assert.IsFalse(comparer.Equals(new object(), null), "Comparer thinks new object() == null");
}
public void CompareElementsWithNull_ShouldNotBeEqualTest()
{
var col1 = new int[] { 1, 3, 2, 4, 4 };
var result = CollectionComparer.Compare(col1, null);
Assert.IsFalse(result);
}
static VisualElementExtension()
{
AttributeMapperStore.Default.Register(BehaviourAttribute,
BehaviourAttribute.Mapper <Behavior[], Xamarin.Forms.VisualElement>(
(s, a) =>
{
foreach (var item in a)
{
s.Item.Behaviors.Add(item);
}
},
(s, c, n) =>
{
var comparer = CollectionComparer <Behavior> .Default();
var operations = comparer.Compare(c, n);
// and apply them to the list
operations.Apply(s.Item.Behaviors);
},
(s, c) =>
{
s.Item.Behaviors.Clear();
}));
}
public void CompareNullWithElements_ShouldNotBeEqualTest()
{
var col2 = new int[] { 1, 3, 2, 4, 4 };
var result = CollectionComparer.Compare(null, col2);
Assert.IsFalse(result);
}
/// <summary>
/// Returns the expression that compares two IDictionary members
/// </summary>
/// <param name="ctx"></param>
/// <param name="engine"></param>
/// <param name="memberType"></param>
/// <returns></returns>
private static MethodCallExpression GetIDictionaryMemberExpression(Context ctx, IComparerEngine engine, Type memberType)
{
var nullChecked = new NullChecked(ctx, memberType);
var genericPropTypes = memberType.GetGenericArguments();
var methodInfo = CollectionComparer.GetCompareIDictionaryMethodInfo(genericPropTypes);
if (IsSimpleType(genericPropTypes[1]))
{
return(Expression.Call(ctx.List,
_listAddRange,
Expression.Call(
methodInfo,
Expression.Constant(ctx.Name),
nullChecked.PropA,
nullChecked.PropB)));
}
return(Expression.Call(ctx.List,
_listAddRange,
Expression.Call(
methodInfo,
Expression.Constant(engine),
Expression.Constant(ctx.Name),
nullChecked.PropA,
nullChecked.PropB)));
}
/// <summary>
/// Returns the expression that compares two IEnumerable members
/// </summary>
/// <param name="ctx"></param>
/// <param name="engine"></param>
/// <param name="configuration"></param>
/// <param name="memberType"></param>
/// <returns></returns>
private static Expression GetIEnumerableMemberExpression(Context ctx, IComparerEngine engine, EnumerableConfiguration configuration, Type memberType)
{
var nullChecked = new NullChecked(ctx, memberType);
if (configuration != null && !string.IsNullOrEmpty(configuration.Match))
{
var itemType = memberType.IsArray ? memberType.GetElementType() : GetGenericIEnumerableType(memberType).First();
var types = new[] { itemType, configuration.MatcherType };
// Static call to CollectionComparer.CompareIEnumerableWithKeyAndDefault<T, TKey> to compare IEnumerable properties
return(Expression.Call(ctx.List,
_listAddRange,
Expression.Call(CollectionComparer.GetCompareIEnumerableWithKeyAndDefaultMethodInfo(types),
Expression.Constant(engine),
Expression.Constant(ctx.Name),
nullChecked.PropA,
nullChecked.PropB,
configuration.Matcher,
Expression.Convert(
Expression.Constant(configuration.DefaultId),
configuration.MatcherType))));
}
// Static call to CollectionComparer.CompareIEnumerable<T> to compare IEnumerable properties
return(Expression.Call(ctx.List,
_listAddRange,
Expression.Call(CollectionComparer.GetCompareIEnumerableMethodInfo(GetGenericIEnumerableType(memberType)),
Expression.Constant(ctx.Name), nullChecked.PropA, nullChecked.PropB)));
}
public void CompareLessStringWithString_ShouldBeEqualTest()
{
var col1 = new[] { "Ann", "Max" };
var col2 = new string[] { "Ann", "Max", "Nik" };
var result = CollectionComparer.Compare <string>(col1, col2);
Assert.IsFalse(result);
}
internal static void AssertAreEqual <T>(List <T> expected, List <T> actual)
{
Assert.AreEqual(expected.Count, actual.Count);
for (var i = 0; i < expected.Count; i++)
{
CollectionComparer.AssertAreEqual(expected[i], actual[i]);
}
}
public void CompareEmptyAndNotEmpty_ShouldBeNotEqualTest()
{
var col1 = new[] { 1, 2, 3, 4, 5 };
var col2 = new int[] { };
var result = CollectionComparer.Compare(col1, col2);
Assert.IsFalse(result);
}
public void CompareTheElementsFromExample_ShouldBeNotEqualTest()
{
var col1 = new[] { 1, 1, 1, 2, 3 };
var col2 = new int[] { 1, 2, 4 };
var result = CollectionComparer.Compare(col1, col2);
Assert.IsFalse(result);
}
public void CompareWithTheSameValues_ShouldBeEqualTest()
{
var col1 = new[] { 1, 1, 1, 1, 1 };
var col2 = new int[] { 1, 1, 1, 1, 1 };
var result = CollectionComparer.Compare(col1, col2);
Assert.IsTrue(result);
}
public void CompareDoubleWithDouble_ShouldBeEqualTest()
{
var col1 = new[] { 2.1, 3.5, 4.6 };
var col2 = new double[] { 2.1, 3.5, 4.6 };
var result = CollectionComparer.Compare <double>(col1, col2);
Assert.IsTrue(result);
}
public void TestCollectionComparionNullSanity()
{
var comparer = new CollectionComparer();
Assert.IsTrue(comparer.Equals(null, null), "Comparer dit not evaluate null and null as equal");
Assert.IsFalse(comparer.Equals(null, new object()), "Comparer thinks null == new object()");
Assert.IsFalse(comparer.Equals(new object(), null), "Comparer thinks new object() == null");
}
public void CompareTheDifferentElements_ShouldNotBeEqualTest()
{
var col1 = new[] { 1, 2, 3, 4, 5 };
var col2 = new int[] { 1, 3, 2, 4, 4 };
var result = CollectionComparer.Compare(col1, col2);
Assert.IsFalse(result);
}
public void CompareTheSameElementsOrder_ShouldBeEqualTest()
{
var col1 = new[] { 1, 2, 3, 4, 5 };
var col2 = new int[] { 1, 2, 3, 4, 5 };
var result = CollectionComparer.Compare(col1, col2);
Assert.IsTrue(result);
}
public void TestCompareDifferentCollections()
{
var value = new int[] { 1, 2, 6, 4, 5 };
var otherValue = new int[] { 1, 2, 3, 4, 5 };
var comparer = new CollectionComparer(new ComparerItem(null, new ValueComparer((ComparerItem)null)));
Assert.IsFalse(comparer.AreEqual(value, otherValue));
}
public void CommentRepozitoryTest()
{
var Repository = new CommentRepository(new InMemoryDbContextFactory());
Assert.Throws <System.InvalidOperationException>(() => Repository.GetById(0));
var Comment1 = new CommentModel()
{
Author = 1,
AuthorName = "Milos Hlava",
Date = new DateTime(2019, 1, 4),
Id = 1,
Text = "Testovaci koment"
};
var Comment2 = new CommentModel()
{
Author = 2,
AuthorName = "Jozef Hlava",
Date = new DateTime(2019, 1, 5),
Id = 2,
Text = "Testovaci koment cislo 2"
};
Repository.Create(Comment1);
Repository.Create(Comment2);
var ReceivedComment1 = Repository.GetById(1);
var ReceivedComment2 = Repository.GetById(2);
Assert.Equal(Comment1, ReceivedComment1);
Assert.Equal(Comment2, ReceivedComment2);
Comment1.Text = "Updatovany text";
Repository.Update(Comment1);
ReceivedComment1 = Repository.GetById(1);
Assert.Equal(Comment1, ReceivedComment1);
List <CommentModel> ReceivedAllComments = Repository.GetAll();
var AllComments = new List <CommentModel>();
AllComments.Add(Comment1);
AllComments.Add(Comment2);
var Comparer = new CollectionComparer <CommentModel>();
Assert.True(Comparer.Equals(AllComments, ReceivedAllComments));
Repository.Delete(1);
Assert.Throws <System.InvalidOperationException>(() => Repository.GetById(1));
Repository.Delete(2);
Assert.Throws <System.InvalidOperationException>(() => Repository.GetById(2));
}
public CarComparer()
{
_stringComparer = new StringComparer();
_guidComparer = new NullableStructComparer <Guid>();
_decimalComparer = new NullableStructComparer <decimal>();
_dateTimeComparer = new NullableStructComparer <DateTime>();
_manufacturerComparer = new ManufacturerComparer();
_bothNullOrNotNullComparer = new BothNullOrNotNullComparer();
_codesComparer = new CollectionComparer <string, StringComparer>();
}
private static Likeness <ActivityDto, ActivityDto> CreateLikeness(ActivityDto sourceDto)
{
var historyComparer = new CollectionComparer <ActivityHistoryItemDto>();
return(sourceDto.AsSource().OfLikeness <ActivityDto>()
.With(x => x.LeadTime)
.EqualsWhen((x, y) => x.LeadTime.AsSource().OfLikeness <DateProjectionDto>().Equals(y.LeadTime))
.With(x => x.Recurrence)
.EqualsWhen((x, y) => x.Recurrence.AsSource().OfLikeness <DateRecurrenceDto>().Equals(y.Recurrence))
.With(x => x.CompletionHistory)
.EqualsWhen((x, y) => historyComparer.Equals(x.CompletionHistory, y.CompletionHistory)));
}
public void Enumerable_structs_are_comparable()
{
var referenceComparer = new CollectionComparer <int>();
var x = _fixture.Create <EnumerableStruct <int> >();
var y = _fixture.Create <EnumerableStruct <int> >();
var expected = referenceComparer.Compare(x, y);
var comparer = new ComparerBuilder().GetComparer <EnumerableStruct <int> >();
var result = comparer.Compare(x, y);
result.Should().Be(expected);
}
public void Should_use_delayed_comparison()
{
var x = Fixture.CreateMany <SampleStruct <EnumSmall?>?>().ToArray();
var y = Fixture.CreateMany <SampleStruct <EnumSmall?>?>().ToArray();
var referenceComparer = new CollectionComparer <SampleStruct <EnumSmall?>?>(new NullableComparer <SampleStruct <EnumSmall?> >(new SampleStructComparer <EnumSmall?>()));
var comparer = new ComparerBuilder().GetComparer <object>();
var expected = referenceComparer.Compare(x, y).Normalize();
var actual = comparer.Compare(x, y).Normalize();
actual.Should().Be(expected);
}
public override bool Equals(object obj)
{
if (!(obj is PostListModel posts))
{
return(false);
}
var comparer = new CollectionComparer <PostModel>();
return(Id == posts.Id &&
Team.Equals(posts.Team) &&
comparer.Equals(Posts, posts.Posts));
}
public override bool Equals(object obj)
{
if (!(obj is TeamDetailModel team))
{
return(false);
}
var comparer = new CollectionComparer <UserListModel>();
return(Id == team.Id &&
Name.Equals(team.Name) &&
Leader.Equals(team.Leader) &&
comparer.Equals(Members, team.Members));
}
public override bool Equals(object obj)
{
if (!(obj is TeamEntity Team))
{
return(false);
}
var Comparer = new CollectionComparer <TeamUserEntity>();
return(Id == Team.Id &&
Name.Equals(Team.Name) &&
Leader.Equals(Team.Leader) &&
Comparer.Equals(Members, Team.Members));
}
public static void InsertSort()
{
var index = new SortedCollection <SqlObject, long>();
var items = new BigList <SqlObject>();
items.Add(SqlObject.Integer(435));
items.Add(SqlObject.Integer(1920));
var comparer = new CollectionComparer(items);
index.InsertSort(SqlObject.Double(2234.99), 45, comparer);
Assert.Equal(1, index.Count);
}
private static void RemoveAll(SortedCollection <SqlObject, long> index, int count)
{
var items = new BigList <SqlObject>();
for (int i = 0; i < count; i++)
{
items.Add(SqlObject.Integer(i * 2));
}
var comparer = new CollectionComparer(items);
for (int i = 0; i < items.Count; i++)
{
index.RemoveSort(items[i], i, comparer);
}
}
public override bool Equals(object obj)
{
if (!(obj is PostModel post))
{
return(false);
}
var comparer = new CollectionComparer <CommentModel>();
return(Id == post.Id &&
Author.Equals(post.Author) &&
AuthorName.Equals(post.AuthorName) &&
Text.Equals(post.Text) &&
Date.Equals(post.Date) &&
Title.Equals(post.Title) &&
Team.Equals(post.Team) &&
comparer.Equals(Comments, post.Comments));
}
public static void ContainsItem()
{
var index = new SortedCollection <SqlObject, long>();
var items = new BigList <SqlObject>();
items.Add(SqlObject.Integer(435));
items.Add(SqlObject.Integer(1920));
items.Add(SqlObject.Integer(9182));
var comparer = new CollectionComparer(items);
index.InsertSort(items[0], 0, comparer);
index.InsertSort(items[1], 1, comparer);
index.InsertSort(items[2], 2, comparer);
Assert.True(index.Contains(SqlObject.Integer(435), comparer));
Assert.False(index.Contains(SqlObject.Integer(21), comparer));
}
