public void ByAllProperties_TrueOnMatchedObjectInstancesWithCustomComparer() { B b = new B(6, new A(5, "Foo")), b2 = new B(6, new A(5, "Bar")); Assert.Equal(b, b2, GenericEqualityComparer <B> .ByAllMembers(new[] { A.IntegerOnlyComparer })); }
public void ByAllProperties_FalseOnUnMatchedObjectInstances() { A a = new A(5, "Foo"), b = new A(3, "Bar"); Assert.NotEqual(a, b, GenericEqualityComparer <A> .ByAllMembers()); }
public void Constructor_StoresException() { var exception = new ArgumentNullException("foo"); var poison = new Poison <int>(42, exception); Assert.Equal(new ExceptionDetails(exception), poison.Exception, GenericEqualityComparer <ExceptionDetails> .ByAllMembers()); }
public void UsesProvidedGenericEqualityComparer() { var comparer = new GenericEqualityComparer <int>(); Assert.That(2 + 2, Is.EqualTo(4).Using(comparer)); Assert.That(comparer.WasCalled, "Comparer was not called"); }
/// <summary> /// Determines if the objects are equal /// </summary> /// <param name="obj">Object to compare to</param> /// <returns>Determines if the commands are equal</returns> public override bool Equals(object obj) { Command OtherCommand = obj as Command; if (OtherCommand == null) { return(false); } if (OtherCommand.SQLCommand != SQLCommand || OtherCommand.CommandType != CommandType || Parameters.Count != OtherCommand.Parameters.Count) { return(false); } GenericEqualityComparer <object> Comparer = new GenericEqualityComparer <object>(); for (int x = 0; x < Parameters.Count; ++x) { if (!Comparer.Equals(Parameters[x], OtherCommand.Parameters[x])) { return(false); } } return(true); }
/// <summary> /// Saves (inserts/updates) an object based on the following criteria: /// 1) If autoincrement is set to true and the primary key is the default value, it inserts /// 2) If autoincrement is set to true and the primary key is not the default value, it updates /// 3) If autoincrement is set to false and the primary key is the default value, it inserts /// 4) If autoincrement is set to false and the primary key is not the default value, /// it does an Any call to see if the item is already in the database. If it is, it does an /// update. Otherwise it does an insert. /// On an insert, the primary key property is updated with the resulting value of the insert. /// </summary> /// <param name="Object">Object to save</param> /// <param name="Parameters">Extra parameters to be added to the insert/update function</param> public virtual void Save <PrimaryKeyType>(ClassType Object, params IParameter[] Parameters) { PrimaryKeyType PrimaryKeyVal = (PrimaryKeyType)GetPrimaryKey(Object); GenericEqualityComparer <PrimaryKeyType> Comparer = new GenericEqualityComparer <PrimaryKeyType>(); if (Comparer.Equals(PrimaryKeyVal, default(PrimaryKeyType))) { PrimaryKeyVal = Insert <PrimaryKeyType>(Object, Parameters); PrimaryKeyMapping.CopyRightToLeft(PrimaryKeyVal, Object); return; } if (AutoIncrement) { Update(Object, Parameters); return; } Parameter <PrimaryKeyType> Param1 = new Parameter <PrimaryKeyType>(PrimaryKeyVal, PrimaryKey, ParameterStarter); ClassType TempVal = Any(PrimaryKey, null, null, Param1); if (TempVal == null) { PrimaryKeyVal = Insert <PrimaryKeyType>(Object, Parameters); PrimaryKeyMapping.CopyRightToLeft(PrimaryKeyVal, Object); return; } Update(Object, Parameters); }
public void GetHashCodeTest() { var Comparer = new GenericEqualityComparer <string>(); Assert.Equal("A".GetHashCode(), Comparer.GetHashCode("A")); Assert.Equal("B".GetHashCode(), Comparer.GetHashCode("B")); }
public async Task <IEnumerable <DishPreviewDto> > GetDishesByIngredients(FilterRequest filterRequest) { var dishComparer = GenericEqualityComparer <Dish> .GetEqualityComparer((d1, d2) => d1.Id == d2.Id, d => d.Id); var query = (await(filterRequest.IncludeIngredients?.Any() ?? false ? _unitOfWork.Dishes.GetByIngredientsAsync(filterRequest.IncludeIngredients) : _unitOfWork.Dishes.GetDishesWithIngredientsCategoriesAndRatingsAsync(null, null))).AsQueryable(); query = query.Where(d => d.Name.IndexOf(filterRequest.Name, StringComparison.InvariantCultureIgnoreCase) != -1); query = filterRequest.ExcludeIngredients?.Any() ?? false ? query.Except(await _unitOfWork.Dishes.GetByIngredientsAsync(filterRequest.ExcludeIngredients), dishComparer) : query; query = filterRequest.IncludeIngredients?.Any() ?? false ? query.Where( res => res.DishIngredients.Select(di => di.IngredientId) .Intersect(filterRequest.IncludeIngredients) .Count() / (double)filterRequest.IncludeIngredients.Count() >= 0.5) : query; return(query.Select(_mapper.Map <Dish, DishPreviewDto>) .ToList()); }
/// <summary> /// Initializes new instance of <see cref="AbstractionEventHandlerLookup{TAbstraction,TImplementation}"/>. /// </summary> public AbstractionEventHandlerLookup() { var comparer = new GenericEqualityComparer <EventHandler <TAbstraction> >( (key, otherKey) => ReferenceEquals(key.Target, otherKey.Target) && ReferenceEquals(key.GetMethodInfo(), otherKey.GetMethodInfo()), key => ((key.Target?.GetHashCode() ?? 0) * 397) ^ (key.GetMethodInfo()?.GetHashCode() ?? 0)); _lookup = new Dictionary <EventHandler <TAbstraction>, AbstractionEventHandlerContext <TImplementation> >(comparer); }
public void CompareNullNonValueType() { var Comparer = new GenericEqualityComparer <string>(); Assert.True(Comparer.Equals(null, null)); Assert.False(Comparer.Equals(null, "B")); Assert.False(Comparer.Equals("B", null)); }
public void AddIfUniqueParamsWithNullIEqualityComparer() { var TestObject = new ConcurrentBag <int>(new int[] { 1, 2, 3, 4, 5, 6 }); GenericEqualityComparer <int> Comparer = null; Assert.False(TestObject.AddIfUnique(Comparer, new int[] { 1 })); Assert.True(TestObject.AddIfUnique(Comparer, new int[] { 7 })); }
public void CompareValueType() { var Comparer = new GenericEqualityComparer <int>(); Assert.True(Comparer.Equals(0, 0)); Assert.False(Comparer.Equals(0, 1)); Assert.False(Comparer.Equals(1, 0)); }
public void Compare() { var Comparer = new GenericEqualityComparer <string>(); Assert.True(Comparer.Equals("A", "A")); Assert.False(Comparer.Equals("A", "B")); Assert.False(Comparer.Equals("B", "A")); }
public void IndexOfWithComparerTest() { const int expected = 1; var comparer = new GenericEqualityComparer <Fake>(Equals); var result = GetEnumerableFakeList().IndexOf(new Fake("Test2"), comparer); result.Should().Be(expected); }
protected ReactiveListViewModel(IReactiveData <TModel> reactive, ISchedulersFactory schedulersFactory) { this.reactive = reactive ?? throw new ArgumentNullException(nameof(reactive)); this.schedulersFactory = schedulersFactory ?? throw new ArgumentNullException(nameof(schedulersFactory)); Comparer = new GenericEqualityComparer <TModel>((x, y) => Equals(GetId(x), GetId(y))); Init(); }
public override void Validate(ObjectType Object) { GenericEqualityComparer <string> Comparer = new GenericEqualityComparer <string>(); if (Comparer.Equals(ItemToValidate(Object), DefaultValue)) { throw new NotValid(ErrorMessage); } }
public override void Validate(ObjectType Object) { GenericEqualityComparer <DataType> Comparer = new GenericEqualityComparer <DataType>(); if (!Comparer.Equals(ItemToValidate(Object), Value)) { throw new NotValid(ErrorMessage); } }
public void ForExpression_FirstNameChar_OK() { Func <Customer, Customer, bool> ExpressionComparator = (a, b) => a.Name.FirstOrDefault() == b.Name.FirstOrDefault(); instance = new GenericEqualityComparer <Customer>(ExpressionComparator); var result = customers.Distinct(instance).Count(); Assert.AreEqual(4, result); }
public void ForField_ID() { Func <Customer, object> fieldComparator = a => a.ID; instance = new GenericEqualityComparer <Customer>(fieldComparator); var result = customers.Distinct(instance).Count(); Assert.AreEqual(6, result); }
public void Queue_GeneratesExpectedOnQueueAction() { var actionType = DurableJobQueueActionType.Queued; var observation = SubscribeForAction(actionType, (store, item, poison) => { store.Queue(item); }); Assert.True(observation.Action.ActionType == actionType && GenericEqualityComparer <TQueue> .ByAllMembers().Equals(observation.Action.Input, observation.Input)); }
public void Subscribe_ResumesInProperQueuePositionAfterReadingMaximumDuringInterval() { int maxToSlurp = 3; var jobStorage = A.Fake <IDurableJobQueue <Incoming, Incoming> >(); var scheduler = new HistoricalScheduler(); var monitor = new DurableJobQueueMonitor <Incoming, Incoming>(jobStorage, maxToSlurp, DurableJobQueueMonitor.DefaultPollingInterval, scheduler); List <Incoming> incomingItems = new List <Incoming>(); var queuedItems = Enumerable.Repeat(Item.From(new Incoming() { Id = 1 }), 3) .Concat(new [] { Item.From(new Incoming() { Id = 456 }), Item.From(new Incoming() { Id = 222 }), Item.From(new Incoming() { Id = 8714 }) }) .Concat(Enumerable.Repeat(Item.From(new Incoming() { Id = 5 }), 2)) .Concat(Enumerable.Repeat(Item.From(new Incoming() { Id = 2 }), 4)) .Concat(Enumerable.Repeat(Item.From(new Incoming() { Id = 3 }), 3)) .ToArray(); A.CallTo(() => jobStorage.NextQueuedItem()).ReturnsNextFromSequence(queuedItems); using (var subscription = monitor.Subscribe(publishedItem => { incomingItems.Add(publishedItem); })) { scheduler.AdvanceBy(monitor.PollingInterval); scheduler.AdvanceBy(monitor.PollingInterval); Assert.True(queuedItems.Take(maxToSlurp * 2) .Select(item => item.Value) .SequenceEqual(incomingItems, GenericEqualityComparer <Incoming> .ByAllMembers())); } }
public bool UpdateWhenChanged(IEnumerable <MetricDefinition> metricDefinitions) { if (this.MetricDefinitions == null || !this.MetricDefinitions.SequenceEqual( metricDefinitions, GenericEqualityComparer <MetricDefinition> .CreateComparer((a, b) => a.ValueEquals(b), a => a.GetHashCode()))) { this.MetricDefinitions = metricDefinitions; return(true); } return(false); }
public void Top_keyselector01() { Assert.True(new[] { 0, 5, 10, 15, 20, 25 }.Select(x => new ComparableClass2 { Value = x }) .Top(3, x => x.Value) .OrderByDescending(x => x.Value) .SequenceEqual(new[] { 25, 20, 15 }.Select(x => new ComparableClass2 { Value = x }), GenericEqualityComparer <ComparableClass2> .By(x => x.Value))); }
public void Bottom_keyselector01() { Assert.True(new[] { 25, 20, 15, 10, 5, 0 }.Select(x => new ComparableClass2 { Value = x }) .Bottom(3, x => x.Value) .OrderBy(x => x.Value) .SequenceEqual(new[] { 0, 5, 10 }.Select(x => new ComparableClass2 { Value = x }), GenericEqualityComparer <ComparableClass2> .By(x => x.Value))); }
public void ForField_AllCityMadrid_OK() { Func <Customer, object> fieldComparator = a => a.City; customers.ForEach(a => a.City = "Madrid"); instance = new GenericEqualityComparer <Customer>(fieldComparator); var result = customers.Distinct(instance).Count(); Assert.AreEqual(1, result); }
public ActionResult Index(String faction = "horde", String realm = "bonechewer", Int32 count = 20, Int32 results = 25, Int32 buymin = 250) { var StartDate = DateTime.Today.Subtract(new TimeSpan(3, 0, 0, 0)); // EqulityComparer for Item var itemComparer = new GenericEqualityComparer<Item>( (a, b) => a.ID == b.ID, (a) => a.GetHashCode() ); // Get a set of Item:IE<Auction> var items = (from a in wac.Auctions where a.MyAuctionHouse.Realm == realm && a.MyAuctionHouse.Faction == faction && a.TimeStamp >= StartDate && a.TimeStamp <= DateTime.Now && a.Buyout > 0 select a.MyItem).ToList(); items = items.Distinct(itemComparer).ToList(); // result collection ConcurrentBag<AuctionSummary> bag = new ConcurrentBag<AuctionSummary>(); Parallel.ForEach(items, new ParallelOptions { MaxDegreeOfParallelism = 8 }, (itemAuctions) => { AuctionSummary ret = new AuctionSummary(); AuctionAPIController api = new AuctionAPIController(); var result = api.SingleZStats(realm, faction, itemAuctions.ID, StartDate, DateTime.Now, .15, 250); // If there is no variance, there is no volatility if (result.StdDev != 0.0 && result.AvgSeen >= count) { ret.ItemID = itemAuctions.ID; ret.ItemName = itemAuctions.Name; ret.Mean = Math.Round(result.Mean, 4); ret.MinBuyout = result.CurrMin; ret.StdDev = Math.Round(result.StdDev, 4); ret.ZValue = Math.Round(result.ZValue, 4); bag.Add(ret); } } ); var vmIndex = new HomeIndexVM() { Faction = faction, Realm = realm }; vmIndex.Items = bag.OrderBy(a => a.ZValue).Take(results).ToList(); ViewData["faction"] = faction; ViewData["realm"] = realm; return View(vmIndex); }
public void In_comparer01() { var value = new ComparableClass2() { Value = 1 }; var source = new[] { 1, 2, 3 }.Select(x => new ComparableClass2() { Value = x }); Assert.IsTrue(value.In(source, GenericEqualityComparer <ComparableClass2> .By(x => x.Value))); }
public void GetQueued_PreservesOrdering() { var storage = JobStorageFactory(); var queueItems = Fixture.CreateMany <TQueue>(15).ToList(); foreach (var item in queueItems) { storage.Queue(item); } Assert.True(queueItems.SequenceEqual(storage.GetQueued(), GenericEqualityComparer <TQueue> .ByAllMembers())); }
public override void Validate(ObjectType Object) { GenericEqualityComparer <DataType> Comparer = new GenericEqualityComparer <DataType>(); foreach (DataType Item in ItemToValidate(Object)) { if (Comparer.Equals(Item, Value)) { return; } } throw new NotValid(ErrorMessage); }
public void Bottom_comparer01() { var comparer = new ComparableClass2Comparer(); Assert.True(new[] { 25, 20, 15, 10, 5, 0 }.Select(x => new ComparableClass2 { Value = x }) .Bottom(3, comparer) .OrderBy(x => x, comparer) .SequenceEqual(new[] { 0, 5, 10 }.Select(x => new ComparableClass2 { Value = x }), GenericEqualityComparer <ComparableClass2> .By(x => x))); }
public void DictionariesAreEqualWhenUsingCustomKeyComparer() { var comparer = new GenericEqualityComparer <int>((x, y) => x == y, HashCodeUtility.GetPersistentHashCode); var dict1 = new Dictionary <int, int>(comparer) { { 1, 1 }, { 2, 2 }, { 3, 3 } }; var dict2 = new Dictionary <int, int>(comparer) { { 1, 1 }, { 2, 2 }, { 3, 3 } }; Assert.IsTrue(DictionaryUtility.AreEqual(dict1, dict2)); }
public void GenericEqualityComparer_Equals() { var strs = new string[] { "Abr", "Adr", "Afr" }; var gcc0 = new GenericEqualityComparer<string>(i => i[0], withoutHash: true); var gcc1 = new GenericEqualityComparer<string>(i => i[1], withoutHash: true); var gcc2 = new GenericEqualityComparer<string>(i => i[2]); var cnt0 = strs.Distinct(gcc0).Count(); var cnt1 = strs.Distinct(gcc1).Count(); var cnt2 = strs.Distinct(gcc2).Count(); Assert.AreEqual(1, cnt0, "All strings must equals by first character"); Assert.AreEqual(3, cnt1, "All strings must not equals by second character"); Assert.AreEqual(3, cnt2, "All strings must not equals by third character becase we not disable to use hash"); }
public void GetHashCodeTest() { var testSamples = new List<UriFormat> { UriFormat.SafeUnescaped, UriFormat.Unescaped, UriFormat.UriEscaped }; var comparer = new GenericEqualityComparer<UriFormat>((x, y) => x == y, x => x.GetHashCode()); for (var index = 0; index < testSamples.Count; index++) { Assert.AreEqual(testSamples[index].GetHashCode(), comparer.GetHashCode(testSamples[index])); } }
public void NotEqualsTest() { var first = new List<UriFormat> { UriFormat.SafeUnescaped, UriFormat.Unescaped, UriFormat.UriEscaped }; var second = new List<UriFormat> { UriFormat.Unescaped, UriFormat.SafeUnescaped, UriFormat.UriEscaped }; var comparer = new GenericEqualityComparer<UriFormat>((x, y) => x == y, x => x.GetHashCode()); var actualResult = first.SafeSequenceEqual(second, comparer); Assert.IsFalse(actualResult); }
public void Constructor_NullComparison_ThrowsException() { GenericEqualityComparer<string> c = new GenericEqualityComparer<string>(null); }
public void EqualsWithEnumerableSubModelsReturnsExpectedResult( IEnumerable<SubModel> x, IEnumerable<SubModel> y, bool expected) { var sut = new GenericEqualityComparer<IEnumerable<SubModel>>(); Assert.Equal(expected, sut.Equals(x, y)); }
public void GetHashCodeForValidObjectReturnsObjectHashCode() { var sut = new GenericEqualityComparer<Model>(); var model = new Model(); Assert.Equal(model.GetHashCode(), sut.GetHashCode(model)); }
public void Constructor_NonNullComparison_DoesNotThrowException() { GenericEqualityComparer<string> c = new GenericEqualityComparer<string>((x, y) => { return false; }); }
public void EqualsWithSubModelsReturnsExpectedResult(SubModel x, SubModel y, bool expected) { var sut = new GenericEqualityComparer<SubModel>(); Assert.Equal(expected, sut.Equals(x, y)); }
public void GetHashCodeForNullObjectReturnsZero() { var sut = new GenericEqualityComparer<Model>(); Assert.Equal(0, sut.GetHashCode(null)); }
public void EqualsWithStringsReturnsExpectedResult(string x, string y, bool expected) { var sut = new GenericEqualityComparer<string>(); Assert.Equal(expected, sut.Equals(x, y)); }
public void EqualsWithListsReturnsExpectedResult(List<int> x, List<int> y, bool expected) { var sut = new GenericEqualityComparer<List<int>>(); Assert.Equal(expected, sut.Equals(x, y)); }
public void Constructor_ThrowsOnNullFunc() { Assert.Throws<ArgumentNullException>(() => { var comparer = new GenericEqualityComparer<A>(null); }); }
public void Constructor_ThrowsOnNullHashGenerator() { Assert.Throws<ArgumentNullException>(() => { var comparer = new GenericEqualityComparer<A>((a, b) => a.Integer == b.Integer, null); }); }
/// <summary> /// Determines if the objects are equal /// </summary> /// <param name="obj">Object to compare to</param> /// <returns>Determines if the commands are equal</returns> public override bool Equals(object obj) { Command OtherCommand = obj as Command; if (OtherCommand == null) return false; if (OtherCommand.SQLCommand != SQLCommand || OtherCommand.CommandType != CommandType || Parameters.Count != OtherCommand.Parameters.Count) return false; GenericEqualityComparer<object> Comparer = new GenericEqualityComparer<object>(); for (int x = 0; x < Parameters.Count; ++x) { if (!Comparer.Equals(Parameters[x], OtherCommand.Parameters[x])) return false; } return true; }
public void EqualsWithEnumsReturnsExpectedResult(Enum x, Enum y, bool expected) { var sut = new GenericEqualityComparer<Enum>(); Assert.Equal(expected, sut.Equals(x, y)); }
public void EqualsWithIntsReturnsExpectedResult(int x, int y, bool expected) { var sut = new GenericEqualityComparer<int>(); Assert.Equal(expected, sut.Equals(x, y)); }
/// <summary> /// Determines if the property is valid /// </summary> /// <param name="value">Value to check</param> /// <param name="validationContext">Validation context</param> /// <returns>The validation result</returns> protected override ValidationResult IsValid(object value, ValidationContext validationContext) { if (value==null) return ValidationResult.Success; GenericEqualityComparer<IComparable> Comparer = new GenericEqualityComparer<IComparable>(); IEnumerable ValueList = value as IEnumerable; IComparable ValueTemp = 0; foreach (IComparable Item in ValueList) { ValueTemp = (IComparable)Value.To<object>(Item.GetType()); break; } foreach (IComparable Item in ValueList) { if (Comparer.Equals(Item, ValueTemp)) return new ValidationResult(FormatErrorMessage(validationContext.DisplayName)); } return ValidationResult.Success; }
public ZStatsResults SingleZStats(String realm, String faction, Int32 itemID, DateTime startTime, DateTime endTime, double percentile = .25, Int32 minPrice = 250) { ZStatsResults result = new ZStatsResults(); var auctions = (from auc in wac.Auctions where auc.MyAuctionHouse.Realm == realm && auc.MyAuctionHouse.Faction == faction && auc.MyItem.ID == itemID && auc.TimeStamp >= startTime && auc.TimeStamp < endTime // I work with buyouts, not concerned with bid only operations && auc.Buyout > 0 select auc).ToList(); // stop if there is no results if (auctions.Count() == 0) { return result; } // Finds distinct auctions GenericEqualityComparer<Auction> comparer = new GenericEqualityComparer<Auction>( (a, b) => a.AucID == b.AucID, (a) => a.GetHashCode() ); var buyouts = auctions.Distinct(comparer).SelectMany(a => { return Enumerable.Range(0, a.Quanity).Select(buy => a.Buyout / a.Quanity * 1.0); } ).ToList(); // Calculates the average number of items found per TimeStamp result.AvgSeen = auctions.Count() * 1.0 / auctions.GroupBy(a => a.TimeStamp).Count(); // buyouts in a certain percentile var culledBuyouts = buyouts.OrderBy(a => a).Take((int)Math.Ceiling(buyouts.Count() * percentile)); result.Mean = culledBuyouts.Average(); // Min of latest scan result.CurrMin = auctions.Where(a => a.TimeStamp == auctions.Select(ts => ts.TimeStamp).Max()).Select(auc => auc.Buyout / auc.Quanity).Min(); Int64 sumOfDeviation = (Int64)Math.Floor(culledBuyouts.Sum(d => (d - result.Mean) * (d - result.Mean))); result.StdDev = Math.Sqrt(sumOfDeviation / culledBuyouts.Count()); result.ZValue = (result.CurrMin - result.Mean) / result.StdDev; return result; }