public void GroupBy_ObservableKeyChangesEraseGroup_Update()
{
var update = false;
ICollection <Dummy <string> > coll = new ObservableCollection <Dummy <string> >();
var dummy1 = new Dummy <string>("A");
var dummy2 = new ObservableDummy <string>("B");
coll.Add(dummy1);
coll.Add(dummy2);
var test = coll.WithUpdates().GroupBy(d => d.Item);
test.CollectionChanged += (o, e) =>
{
Assert.IsTrue(ContainsGroup(e.OldItems, "B"));
update = true;
};
Assert.IsTrue(Sys.Contains(Sys.Single(test, group => group.Key == "A"), dummy1));
Assert.IsTrue(Sys.Contains(Sys.Single(test, group => group.Key == "B"), dummy2));
Assert.IsFalse(update);
dummy2.Item = "A";
Assert.IsTrue(update);
Assert.AreEqual(1, test.Count());
Assert.IsTrue(Sys.Contains(Sys.Single(test, group => group.Key == "A"), dummy2));
}
public static void WriterAsReadOnlyCollection()
{
using var writer = new PooledArrayBufferWriter <int>();
IReadOnlyList <int> collection = writer;
Empty(collection);
writer.Add(42);
Equal(1, writer.WrittenCount);
Equal(1, collection.Count);
Equal(42, collection[0]);
Throws <IndexOutOfRangeException>(() => collection[1]);
Equal(42, Enumerable.First(collection));
Equal(1, Enumerable.Count(collection));
writer.AddAll(new[] { 43, 44 });
Equal(3, writer.WrittenCount);
Equal(3, collection.Count);
Equal(42, collection[0]);
Equal(43, collection[1]);
Equal(44, collection[2]);
Throws <IndexOutOfRangeException>(() => collection[3]);
Equal(3, Enumerable.Count(collection));
Equal(new[] { 42, 43, 44 }, Enumerable.ToArray(collection));
}
private void NotifySource2(ICollectionChangedNotificationResult <TSource> change, List <TSource> added, List <TSource> removed)
{
if (change.RemovedItems != null)
{
var uniqueRemoved = new HashSet <TSource>(sourceItems.Comparer);
foreach (var item in change.RemovedItems)
{
if (RemoveItem(item))
{
uniqueRemoved.Add(item);
}
}
removed.AddRange(SL.Where(source, item => uniqueRemoved.Contains(item)));
}
if (change.AddedItems != null)
{
var uniqueAdded = new HashSet <TSource>(sourceItems.Comparer);
foreach (var item in change.AddedItems)
{
if (AddItem(item))
{
uniqueAdded.Add(item);
}
}
added.AddRange(SL.Where(source, item => uniqueAdded.Contains(item)));
}
}
public void Where_ObservableSourceItemAdded_Updates()
{
var update = false;
ICollection <Dummy <bool> > coll = new ObservableCollection <Dummy <bool> >();
var dummy = new Dummy <bool>()
{
Item = true
};
var test = coll.WithUpdates().Where(d => d.Item);
test.CollectionChanged += (o, e) =>
{
update = true;
Assert.AreEqual(NotifyCollectionChangedAction.Add, e.Action);
Assert.AreEqual(dummy, e.NewItems[0]);
};
Assert.IsFalse(Sys.Any(test));
Assert.IsFalse(update);
coll.Add(dummy);
Assert.IsTrue(update);
Assert.IsTrue(Sys.Contains(test, dummy));
}
public void Select_ObservableItem_Update()
{
var update = false;
ICollection <Dummy <string> > coll = new List <Dummy <string> >();
var dummy = new ObservableDummy <string>()
{
Item = "23"
};
coll.Add(dummy);
var test = coll.WithUpdates().Select(d => d.Item);
test.CollectionChanged += (o, e) =>
{
update = true;
Assert.AreEqual("23", e.OldItems[0]);
};
Assert.IsTrue(Sys.Contains(test, "23"));
Assert.IsFalse(update);
dummy.Item = "42";
Assert.IsTrue(update);
Assert.IsTrue(Sys.Contains(test, "42"));
}
public void ngram_search_not_empty()
{
using (GetNewServer())
using (var database = new DocumentStore
{
Url = "http://localhost:8079"
}.Initialize())
{
new ImageByName().Execute(database);
using (var session = database.OpenSession())
{
session.Store(new Image {
Id = "1", Name = "Great Photo buddy"
});
session.Store(new Image {
Id = "2", Name = "Nice Photo of the sky"
});
session.SaveChanges();
}
using (var session = database.OpenSession())
{
var images = Enumerable.ToList <Image>(session.Query <Image, ImageByName>()
.Customize(x => x.WaitForNonStaleResults())
.OrderBy(x => x.Name)
.Search(x => x.Name, "phot"));
Assert.NotEmpty(images);
}
}
}
protected string GetWithClause(IEnumerable <ProviderPropertyExpression> properties)
{
bool withNoLock = GetProviderPropertyValue <WithNoLockExpression, bool>(properties, false);
IEnumerable <string> indexNames = GetProviderPropertyValue <IndexNamesExpression, IEnumerable <string> >(
properties, new string[] { });
bool forceIndex = Enumerable.Count(indexNames) > 0 &&
GetProviderPropertyValue <ForceIndexExpression, bool>(properties, false);
if (!withNoLock && !forceIndex)
{
return(String.Empty);
}
if (withNoLock && !forceIndex)
{
return(" WITH(NOLOCK) ");
}
if (forceIndex && !withNoLock)
{
return(string.Format(" WITH(INDEX({0})) ", string.Join(",", Enumerable.ToArray(indexNames))));
}
return(string.Format(" WITH(NOLOCK,INDEX({0})) ", string.Join(",", Enumerable.ToArray(indexNames))));
}
public override string ToString()
{
var fields =
Enumerable.Where(this.GetType()
.GetFields(), field =>
CustomAttributeExtensions.IsDefined((MemberInfo)field, typeof(InjectFieldValueAttribute)) &&
((field.FieldType == typeof(string)) || field.FieldType.IsPrimitive));
var objectStringRepresentation = new StringBuilder(capacity: 6000);
objectStringRepresentation.AppendFormat("{0} {1}", this.GetType().Name, Environment.NewLine);
foreach (var field in fields)
{
var fldValue = field.GetValue(this);
if (field.FieldType.IsClass && (fldValue == null))
{
objectStringRepresentation.AppendFormat("{0} --> {1}{2}", field.Name, "[Null]", Environment.NewLine);
continue;
}
if ((field.FieldType == typeof(string)) && string.IsNullOrEmpty((string)fldValue))
{
objectStringRepresentation.AppendFormat("{0} --> {1}{2}", field.Name, "[string.Empty]", Environment.NewLine);
continue;
}
objectStringRepresentation.AppendFormat("{0} --> {1}{2}", field.Name, fldValue, Environment.NewLine);
}
return(objectStringRepresentation.ToString());
}
public override IEnumerator <T> GetEnumerator()
{
if (ObservableExtensions.KeepOrder)
{
return(SL.Where(source, item =>
{
if (isValueType || item != null)
{
TaggedObservableValue <bool, ItemMultiplicity> node;
if (lambdaInstances.TryGetValue(item, out node))
{
return node.Value;
}
else
{
return false;
}
}
else
{
return nullCheck != null && nullCheck.Value;
}
}).GetEnumerator());
}
else
{
return(ItemsUnordered.GetEnumerator());
}
}
public void Aggregate_Matrix4x4_Multiply_Test()
{
using (var matrices = new NativeArray <Matrix4x4>(1024, Allocator.Persistent))
{
InitializeMatrixArray(matrices);
var identity = Matrix4x4.identity;
sw.Start();
for (var i = 0; i < Count; i++)
{
identity = matrices.Aggregate <Matrix4x4>(identity, (accumulate, seed) => accumulate * seed);
}
Debug.Log(sw.Stop().ToString());
sw.Start();
for (var i = 0; i < Count; i++)
{
matrices.Aggregate <Matrix4x4, Multiply>(ref identity, default);
}
Debug.Log(sw.Stop().ToString());
identity = Matrix4x4.identity;
sw.Start();
for (var i = 0; i < Count; i++)
{
identity = LE.Aggregate(matrices, identity, (accumulate, seed) => accumulate * seed);
}
Debug.Log(sw.Stop().ToString());
}
}
public override async Task SetOverdueNotificationsAsync(List <string> overdueNotifications)
{
CriteriaBuilder criteriaBuilder = new CriteriaBuilder();
_overdueNotifications = overdueNotifications;
_followUps = await _followUpsController.GetManyByCriteria
(
criteriaBuilder
.Add("Id", _overdueNotifications.ToArray(), ConjunctionsEnum.And, Operators.In)
);
List <Guid> followUpsToRemove = new List <Guid>();
for (int i = 0; i < _followUps.Count; i++)
{
if ((await ProspectWasConverted(_followUps[i])))
{
followUpsToRemove.Add(_followUps[i].Id);
}
}
if (followUpsToRemove.Count > 0)
{
_followUps = Enumerable.ToList(Enumerable.Where(_followUps, followup => !followUpsToRemove.Contains(followup.Id)));
}
if (_followUps.Count == 1 && _singleProspect == null)
{
_singleProspect = await new ProspectsController().GetByIdAsync(_followUps[0].ProspectId);
_singleProspect.ReminderTime = _followUps[0].ReminderTime;
}
}
public string ExpressionText(ExpressionType type)
{
var text = "(\n";
int i = 0;
List <Exception> validationExceptions = new List <Exception>();
foreach (var expression in NestedExpressions)
{
try
{
i++;
text += expression.ExpressionText(type) +
(i < NestedExpressions.Count ? " " + GroupMenuButton.Content : "") + "\n";
}
catch (InvalidQueryExpressionException e)
{
validationExceptions.Add(e);
}
}
if (validationExceptions.Any())
{
string message = Enumerable.Aggregate(validationExceptions, string.Empty, (current, exeption) => current + $"{exeption.Message}\n");
throw new InvalidQueryExpressionException(message);
}
return(text + ")");
}
public override INotificationResult Notify(IList <INotificationResult> sources)
{
var added = new List <TSource>();
var removed = new List <TSource>();
var moved = new List <TSource>();
foreach (ICollectionChangedNotificationResult change in sources)
{
if (change.IsReset)
{
OnCleared();
return(new CollectionChangedNotificationResult <TSource>(this));
}
if (change.AddedItems != null)
{
added.AddRange(SL.Cast <TSource>(change.AddedItems));
}
if (change.RemovedItems != null)
{
removed.AddRange(SL.Cast <TSource>(change.RemovedItems));
}
if (change.MovedItems != null)
{
moved.AddRange(SL.Cast <TSource>(change.MovedItems));
}
}
RaiseEvents(added, removed, moved);
return(new CollectionChangedNotificationResult <TSource>(this, added, removed, moved));
}
public void GroupBy_ObservableSourceItemAdded_Update()
{
var update = false;
ICollection <Dummy <string> > coll = new ObservableCollection <Dummy <string> >();
var test = coll.WithUpdates().GroupBy(d => d.Item);
test.CollectionChanged += (o, e) =>
{
Assert.IsTrue(ContainsGroup(e.NewItems, "42"));
Assert.AreEqual(1, e.NewItems.Count);
update = true;
};
Assert.IsTrue(!test.Any());
Assert.IsFalse(update);
coll.Add(new Dummy <string>()
{
Item = "42"
});
Assert.IsFalse(!test.Any());
Assert.IsTrue(Sys.Any(test, group => group.Key == "42"));
Assert.IsTrue(update);
}
public void InsertTest()
{
try
{
int[] insert = Enumerable.Range(0, 5).Insert(-1, 5).ToArray();
Assert.Fail(string.Join(", ", insert.Select(int32 => int32.ToString())));
}
catch (ArgumentOutOfRangeException exception)
{
Assert.AreEqual("index", exception.ParamName);
}
EnumerableAssert.AreSequentialEqual(new int[] { 5, 0, 1, 2, 3, 4 }, Enumerable.Range(0, 5).Insert(0, 5));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 5, 1, 2, 3, 4 }, Enumerable.Range(0, 5).Insert(1, 5));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 5, 2, 3, 4 }, Enumerable.Range(0, 5).Insert(2, 5));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 5, 3, 4 }, Enumerable.Range(0, 5).Insert(3, 5));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 3, 5, 4 }, Enumerable.Range(0, 5).Insert(4, 5));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 3, 4, 5 }, Enumerable.Range(0, 5).Insert(5, 5));
try
{
int[] insert = Enumerable.Range(0, 5).Insert(6, 5).ToArray();
Assert.Fail(string.Join(", ", insert.Select(int32 => int32.ToString())));
}
catch (ArgumentOutOfRangeException exception)
{
Assert.AreEqual("index", exception.ParamName);
}
}
public void Select_ObservableSourceItemAdded_Update()
{
var update = false;
ICollection <Dummy <string> > coll = new ObservableCollection <Dummy <string> >();
var test = coll.WithUpdates().Select(d => d.Item);
test.CollectionChanged += (o, e) =>
{
Assert.AreEqual(NotifyCollectionChangedAction.Add, e.Action);
Assert.IsTrue(e.NewItems.Contains("42"));
Assert.AreEqual(1, e.NewItems.Count);
update = true;
};
Assert.IsTrue(!test.Any());
Assert.IsFalse(update);
coll.Add(new Dummy <string>()
{
Item = "42"
});
Assert.IsTrue(update);
Assert.IsFalse(!test.Any());
Assert.IsTrue(Sys.Contains(test, "42"));
}
public void RemoveAtTest()
{
try
{
int[] removeAt = Enumerable.Range(0, 5).RemoveAt(-1).ToArray();
Assert.Fail(string.Join(", ", removeAt.Select(int32 => int32.ToString())));
}
catch (ArgumentOutOfRangeException exception)
{
Assert.AreEqual("index", exception.ParamName);
}
EnumerableAssert.AreSequentialEqual(new int[] { 1, 2, 3, 4 }, Enumerable.Range(0, 5).RemoveAt(0));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 2, 3, 4 }, Enumerable.Range(0, 5).RemoveAt(1));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 3, 4 }, Enumerable.Range(0, 5).RemoveAt(2));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 4 }, Enumerable.Range(0, 5).RemoveAt(3));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 3 }, Enumerable.Range(0, 5).RemoveAt(4));
try
{
int[] removeAt = Enumerable.Range(0, 5).RemoveAt(5).ToArray();
Assert.Fail(string.Join(", ", removeAt.Select(int32 => int32.ToString())));
}
catch (ArgumentOutOfRangeException exception)
{
Assert.AreEqual("index", exception.ParamName);
}
try
{
int[] removeAt = Enumerable.Range(0, 5).RemoveAt(6).ToArray();
Assert.Fail(string.Join(", ", removeAt.Select(int32 => int32.ToString())));
}
catch (ArgumentOutOfRangeException exception)
{
Assert.AreEqual("index", exception.ParamName);
}
}
public void Select_NoObservableSourceItemRemoved_KeepOrder_NoUpdate()
{
ObservableExtensions.KeepOrder = true;
var update = false;
ICollection <Dummy <string> > coll = new List <Dummy <string> >();
var dummy = new Dummy <string>()
{
Item = "42"
};
coll.Add(dummy);
var test = coll.WithUpdates().Select(d => d.Item);
test.CollectionChanged += (o, e) => update = true;
Assert.IsTrue(Sys.Contains(test, "42"));
Assert.IsFalse(update);
coll.Remove(dummy);
Assert.IsFalse(Sys.Contains(test, "42"));
Assert.IsFalse(update);
}
public void MaxRangeIsMaximumIntValue()
{
var range = Linq.Range(int.MaxValue, 1);
range.Should().OnlyContain(x => x == int.MaxValue);
range.Should().HaveCount(1);
}
private void Source2CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
int sourceCount = SL.Count(source);
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
e = new NotifyCollectionChangedEventArgs(e.Action, e.NewItems, sourceCount + e.NewStartingIndex);
break;
case NotifyCollectionChangedAction.Move:
e = new NotifyCollectionChangedEventArgs(e.Action, e.NewItems, sourceCount + e.NewStartingIndex, sourceCount + e.OldStartingIndex);
break;
case NotifyCollectionChangedAction.Remove:
e = new NotifyCollectionChangedEventArgs(e.Action, e.OldItems, sourceCount + e.OldStartingIndex);
break;
case NotifyCollectionChangedAction.Replace:
e = new NotifyCollectionChangedEventArgs(e.Action, e.NewItems, e.OldItems, sourceCount + e.OldStartingIndex);
break;
case NotifyCollectionChangedAction.Reset:
OnCleared();
return;
default:
throw new InvalidOperationException();
}
OnCollectionChanged(e);
}
public void Where_ObservableItem_Updates()
{
var update = false;
ICollection <Dummy <bool> > coll = new List <Dummy <bool> >();
var dummy = new ObservableDummy <bool>()
{
Item = true
};
coll.Add(dummy);
var test = coll.WithUpdates().Where(d => d.Item);
test.CollectionChanged += (o, e) =>
{
update = true;
Assert.AreEqual(dummy, e.OldItems[0]);
};
Assert.IsTrue(Sys.Contains(test, dummy));
Assert.IsFalse(update);
dummy.Item = false;
Assert.IsFalse(test.Any());
Assert.IsTrue(update);
}
public void EmptyContainsNoElements()
{
using (var empty = Linq.Empty <int>().GetEnumerator())
{
Assert.False(empty.MoveNext());
}
}
private bool ReadLibraryFromJson()
{
var jsonFormatter = new System.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(Books[]));
using (var fs = new System.IO.FileStream("Library.json", System.IO.FileMode.OpenOrCreate))
{
if (fs.Length == 0)
{
System.Console.WriteLine("JSON is empty");
}
else
{
var newBooks = (Books[])jsonFormatter.ReadObject(fs);
var lst = Enumerable.ToList(Enumerable.OfType <Books>(newBooks));
System.Console.WriteLine("Done reading from json");
foreach (var b in lst)
{
var book = new Books
{
Author = b.Author,
Title = b.Title,
Annotation = b.Annotation,
Isbn = b.Isbn,
PublicationDate = b.PublicationDate
};
_books.Add(book);
}
}
}
return(true);
}
public void SelectMany_ObservableSubSourceItemChanges_Updates()
{
var update = false;
ICollection <Dummy <ICollection <Dummy <string> > > > coll = new List <Dummy <ICollection <Dummy <string> > > >();
var dummy = new ObservableDummy <string>()
{
Item = "23"
};
var dummy2 = new Dummy <ICollection <Dummy <string> > >()
{
Item = new List <Dummy <string> >()
{
dummy
}
};
coll.Add(dummy2);
var test = coll.WithUpdates().SelectMany(d => d.Item, (d1, d2) => d2.Item);
test.CollectionChanged += (o, e) =>
{
update = true;
Assert.AreEqual("23", e.OldItems[0]);
Assert.AreEqual("42", e.NewItems[0]);
};
Assert.IsTrue(Sys.Contains(test, "23"));
Assert.IsFalse(update);
dummy.Item = "42";
Assert.IsTrue(update);
Assert.IsTrue(Sys.Contains(test, "42"));
}
public void Select_ObservableSourceItemRemoved_Update()
{
var update = false;
ICollection <Dummy <string> > coll = new ObservableCollection <Dummy <string> >();
var dummy = new Dummy <string>()
{
Item = "42"
};
coll.Add(dummy);
var test = coll.WithUpdates().Select(d => d.Item);
test.CollectionChanged += (o, e) =>
{
Assert.IsTrue(e.OldItems.Contains("42"));
Assert.AreEqual(1, e.OldItems.Count);
update = true;
};
Assert.IsTrue(Sys.Contains(test, "42"));
Assert.IsFalse(update);
coll.Remove(dummy);
Assert.IsTrue(update);
Assert.IsFalse(Sys.Contains(test, "42"));
}
public void SelectMany_NoObservableSubSourceItemAdded_NoUpdates()
{
var update = false;
ICollection <Dummy <ICollection <Dummy <string> > > > coll = new List <Dummy <ICollection <Dummy <string> > > >();
var dummy = new Dummy <string>()
{
Item = "23"
};
var dummy2 = new Dummy <ICollection <Dummy <string> > >()
{
Item = new List <Dummy <string> >()
};
coll.Add(dummy2);
var test = coll.WithUpdates().SelectMany(d => d.Item, (d1, d2) => d2.Item);
test.CollectionChanged += (o, e) => update = true;
Assert.IsFalse(Sys.Contains(test, "23"));
Assert.IsFalse(update);
dummy2.Item.Add(dummy);
Assert.IsFalse(update);
}
public static void RemoveWhere(ICollection <TSource> collection, Func <TSource, bool> predicate)
{
if (collection != null)
{
var list = collection as IList <TSource>;
if (list != null)
{
for (int i = list.Count - 1; i >= 0; i--)
{
if (predicate(list[i]))
{
list.RemoveAt(i);
}
}
}
else
{
var toRemove = SL.ToList(SL.Where(collection, predicate));
foreach (var item in toRemove)
{
collection.Remove(item);
}
}
}
}
public void SelectMany_ObservableSubSourceItemAdded_Updates()
{
var update = 0;
ICollection <Dummy <ICollection <Dummy <string> > > > coll = new List <Dummy <ICollection <Dummy <string> > > >();
var dummy = new Dummy <string>()
{
Item = "23"
};
var dummy2 = new Dummy <ICollection <Dummy <string> > >()
{
Item = new ObservableCollection <Dummy <string> >()
};
coll.Add(dummy2);
var test = coll.WithUpdates().SelectMany(d => d.Item, (d1, d2) => d2.Item);
test.CollectionChanged += (o, e) =>
{
update++;
Assert.AreEqual("23", e.NewItems[0]);
};
Assert.IsFalse(Sys.Contains(test, "23"));
Assert.AreEqual(0, update);
dummy2.Item.Add(dummy);
Assert.AreEqual(1, update);
Assert.IsTrue(Sys.Contains(test, "23"));
}
private static void AddToList <T>(IList <T> storage, T item, Func <T, T, bool> filter)
{
if (Enumerable.Count(Processor.Where(storage, delegate(T i) { return(filter(i, item)); })) == 0)
{
storage.Add(item);
}
}
public void GroupBy_NoObservableKeyChangesToNewGroup_NoUpdate()
{
var update = false;
ICollection <Dummy <string> > coll = new ObservableCollection <Dummy <string> >();
var dummy1 = new Dummy <string>("A");
var dummy2 = new Dummy <string>("A");
coll.Add(dummy1);
coll.Add(dummy2);
var test = coll.WithUpdates().GroupBy(d => d.Item);
test.CollectionChanged += (o, e) => update = true;
var group = Sys.Single(test);
Assert.IsTrue(Sys.Contains(group, dummy1));
Assert.IsTrue(Sys.Contains(group, dummy2));
Assert.IsFalse(update);
dummy2.Item = "B";
Assert.IsFalse(update);
}
