public void TakeWithInsufficientData() { DataProducer <int> subject = new DataProducer <int>(); IDataProducer <int> result = subject.Take(4); ProduceAndCheck(subject, result, new[] { 3, 10 }, new[] { 3, 10 }); }
public void WhereWithCondition() { DataProducer <int> subject = new DataProducer <int>(); ProduceAndCheck(subject, subject.Where((x, index) => x > index), new[] { 0, 3, 1, 4, 5, 2 }, new[] { 3, 4, 5 }); }
public void GroupByWithElementProjection() { DataProducer <string> producer = new DataProducer <string>(); var query = producer.GroupBy(word => word[0], word => word + word.Length) .Select(group => new { group.Key, Words = group.AsFutureEnumerable() }) .AsFutureEnumerable(); producer.ProduceAndEnd("One", "Two", "Three", "Four", "Five", "Six", "Seven", "others"); var results = query.Value.ToList(); Assert.AreEqual(5, results.Count); Assert.AreEqual('O', results[0].Key); Assert.IsTrue(results[0].Words.Value.SequenceEqual(new[] { "One3" })); Assert.AreEqual('T', results[1].Key); Assert.IsTrue(results[1].Words.Value.SequenceEqual(new[] { "Two3", "Three5" })); Assert.AreEqual('F', results[2].Key); Assert.IsTrue(results[2].Words.Value.SequenceEqual(new[] { "Four4", "Five4" })); Assert.AreEqual('S', results[3].Key); Assert.IsTrue(results[3].Words.Value.SequenceEqual(new[] { "Six3", "Seven5" })); Assert.AreEqual('o', results[4].Key); Assert.IsTrue(results[4].Words.Value.SequenceEqual(new[] { "others6" })); }
public void ShouldProduceValuesForIdentityColumns() { ValueStore vs = new ValueStore(); DataProducer producer = new DataProducer(vs); DataRowEntity row = producer.ProduceRow(customerTable, 1); // check that the value of the identity column have not been generated Assert.That(vs.GetByKey(row.Fields[0].KeyValue), Is.Null); IDataConsumer consumer = GetImplementedType(); if (consumer.Init("", options)) { int counter = 0; consumer.ReportInsertionCallback = new Action(() => { counter++; }); consumer.Consume(new List <DataRowEntity> { row }, vs); // now assert that the identity value have been generated by the consumer Assert.That(row.Fields[0].FieldName, Is.EqualTo("CustomerId"), "Column should be customerID"); Assert.That(vs.GetByKey(row.Fields[0].KeyValue), Is.Not.Null, consumer.GetType().ToString()); } }
public void SkipWithZeroCount() { DataProducer <int> subject = new DataProducer <int>(); IDataProducer <int> result = subject.Skip(0); ProduceAndCheck(subject, result, new[] { 3, 10, 5, 7, 2, 8 }, new[] { 3, 10, 5, 7, 2, 8 }); }
public void GroupByWithElementProjectionAndResultProjection() { DataProducer <string> producer = new DataProducer <string>(); var query = producer.GroupBy(word => word[0].ToString(), word => word + word, (key, words) => new { Key = key, MaxLength = words.Max(word => word.Length) }) .AsFutureEnumerable(); producer.ProduceAndEnd("One", "Two", "Three", "Four", "Five", "Six", "Seven", "others"); var results = query.Value.ToList(); Assert.AreEqual(5, results.Count); Assert.AreEqual("O", results[0].Key); Assert.AreEqual(6, results[0].MaxLength.Value); Assert.AreEqual("T", results[1].Key); Assert.AreEqual(10, results[1].MaxLength.Value); Assert.AreEqual("F", results[2].Key); Assert.AreEqual(8, results[2].MaxLength.Value); Assert.AreEqual("S", results[3].Key); Assert.AreEqual(10, results[3].MaxLength.Value); Assert.AreEqual("o", results[4].Key); Assert.AreEqual(12, results[4].MaxLength.Value); }
void ProduceAndCheck <T>(DataProducer <T> source, IDataProducer <T> result, T[] inputData, T[] expectedOutput) { IEnumerable <T> enumerable = result.AsEnumerable(); source.ProduceAndEnd(inputData); Assert.IsTrue(expectedOutput.SequenceEqual(enumerable)); }
public void TakeWhileAndConditionMetInSequenceWithIndex() { DataProducer <int> subject = new DataProducer <int>(); IDataProducer <int> result = subject.TakeWhile((x, index) => x > index); ProduceAndCheck(subject, result, new[] { 3, 4, 10, 2, 3 }, new[] { 3, 4, 10 }); }
/// <summary> /// Returns a data-producer that will yield a specified number of /// contiguous elements from the start of a sequence - i.e. /// "the first <x> elements". /// </summary> /// <param name="source">The source data-producer</param> /// <param name="count">The maximum number of elements to return</param> public static IDataProducer <TSource> Take <TSource>(this IDataProducer <TSource> source, int count) { source.ThrowIfNull("source"); DataProducer <TSource> ret = new DataProducer <TSource>(); Action completion = () => ret.End(); Action <TSource> production = null; production = value => { if (count > 0) { ret.Produce(value); count--; } if (count <= 0) { source.EndOfData -= completion; source.DataProduced -= production; ret.End(); } }; source.DataProduced += production; source.EndOfData += completion; return(ret); }
public void GroupByWithElementProjection() { DataProducer<string> producer = new DataProducer<string>(); var query = producer.GroupBy(word => word[0], word => word + word.Length) .Select(group => new { group.Key, Words = group.AsFutureEnumerable() }) .AsFutureEnumerable(); producer.ProduceAndEnd("One", "Two", "Three", "Four", "Five", "Six", "Seven", "others"); var results = query.Value.ToList(); Assert.AreEqual(5, results.Count); Assert.AreEqual('O', results[0].Key); Assert.IsTrue(results[0].Words.Value.SequenceEqual(new[] { "One3" })); Assert.AreEqual('T', results[1].Key); Assert.IsTrue(results[1].Words.Value.SequenceEqual(new[] { "Two3", "Three5" })); Assert.AreEqual('F', results[2].Key); Assert.IsTrue(results[2].Words.Value.SequenceEqual(new[] { "Four4", "Five4" })); Assert.AreEqual('S', results[3].Key); Assert.IsTrue(results[3].Words.Value.SequenceEqual(new[] { "Six3", "Seven5" })); Assert.AreEqual('o', results[4].Key); Assert.IsTrue(results[4].Words.Value.SequenceEqual(new[] { "others6" })); }
/// <summary> /// Returns a data-producer that will yield /// elements a sequence as long as a condition /// (involving the element's index in the sequence) /// is satsified; when the condition fails for an element, /// that element and all subsequent elements are ignored. /// </summary> /// <param name="source">The source data-producer</param> /// <param name="predicate">The condition to yield elements</param> public static IDataProducer <TSource> TakeWhile <TSource>(this IDataProducer <TSource> source, DotNet20.Func <TSource, int, bool> predicate) { source.ThrowIfNull("source"); predicate.ThrowIfNull("predicate"); DataProducer <TSource> ret = new DataProducer <TSource>(); Action completion = () => ret.End(); Action <TSource> production = null; int index = 0; production = value => { if (!predicate(value, index++)) { ret.End(); source.DataProduced -= production; source.EndOfData -= completion; } else { ret.Produce(value); } }; source.DataProduced += production; source.EndOfData += completion; return(ret); }
/// <summary> /// Returns a data-producer that will ignore the /// elements from the start of a sequence while a condition /// (involving the elements's index in the sequence) /// is satsified; when the condition fails for an element, /// that element and all subsequent elements are yielded. /// </summary> /// <param name="source">The source data-producer</param> /// <param name="predicate">The condition to skip elements</param> public static IDataProducer <TSource> SkipWhile <TSource>(this IDataProducer <TSource> source, DotNet20.Func <TSource, int, bool> predicate) { source.ThrowIfNull("source"); predicate.ThrowIfNull("predicate"); DataProducer <TSource> ret = new DataProducer <TSource>(); Action completion = () => ret.End(); bool skipping = true; int index = 0; source.DataProduced += value => { if (skipping) { skipping = predicate(value, index++); } // Note - not an else clause! if (!skipping) { ret.Produce(value); } }; source.EndOfData += completion; return(ret); }
public void LongCount() { DataProducer<string> subject = new DataProducer<string>(); IFuture<long> count = subject.LongCount(); subject.ProduceAndEnd("a", "b", "c", "d"); Assert.AreEqual(4L, count.Value); }
public void DefaultIfEmptyWithoutData() { DataProducer <string> subject = new DataProducer <string>(); IDataProducer <string> result = subject.DefaultIfEmpty(); ProduceAndCheck(subject, result, new string[0], new string[] { null }); }
public void LongCountWithFilter() { DataProducer<string> subject = new DataProducer<string>(); IFuture<long> count = subject.LongCount(x => x.Length >= 2); subject.ProduceAndEnd("a", "bbb", "cc", "d"); Assert.AreEqual(2L, count.Value); }
public void ShouldUseSameValueWhenUsingIdentityFromOtherColumn() { ValueStore valuestore = new ValueStore(); var dp = new DataProducer(valuestore); var tables = new List <ExecutionTable>(); tables.Add(new ExecutionTable(customerTable, 1)); tables.Add(new ExecutionTable(orderTable, 2)); List <DataRowEntity> rows = new List <DataRowEntity>(); long n = 1L; rows.AddRange(dp.ProduceRows(tables)); Assert.That(rows.Count, Is.EqualTo(2)); var customerRow = rows[0]; var orderRow = rows[1]; Assert.That(customerRow.Fields.Count, Is.EqualTo(4)); Assert.That(orderRow.Fields.Count, Is.EqualTo(4)); Assert.That(orderRow.Fields[1].FieldName, Is.EqualTo("CustomerId")); Assert.That(customerRow.Fields[0].FieldName, Is.EqualTo("CustomerId")); // Check key is the same as it is for the CustomerId column in CustomerRow Assert.That(orderRow.Fields[1].KeyValue, Is.EqualTo(customerRow.Fields[0].KeyValue)); }
public void SelectWithIndex() { DataProducer <int> subject = new DataProducer <int>(); IDataProducer <int> result = subject.Select((x, index) => x * 5 + index); ProduceAndCheck(subject, result, new[] { 3, 10, 5 }, new[] { 15, 51, 27 }); }
public void TakeWhileAndConditionMetInSequence() { DataProducer <int> subject = new DataProducer <int>(); IDataProducer <int> result = subject.TakeWhile(x => x < 5); ProduceAndCheck(subject, result, new[] { 3, 4, 10, 2, 3 }, new[] { 3, 4 }); }
public void Select() { DataProducer <int> subject = new DataProducer <int>(); IDataProducer <int> result = subject.Select(x => x * 5); ProduceAndCheck(subject, result, new[] { 3, 10, 5 }, new[] { 15, 50, 25 }); }
public void TakeWithZeroCount() { DataProducer <int> subject = new DataProducer <int>(); IDataProducer <int> result = subject.Take(0); ProduceAndCheck(subject, result, new[] { 3, 10 }, new int[0]); }
public void DefaultIfEmptyWithoutDataButWithDefaultReplacement() { DataProducer <string> subject = new DataProducer <string>(); IDataProducer <string> result = subject.DefaultIfEmpty("foo"); ProduceAndCheck(subject, result, new string[0], new string[] { "foo" }); }
public void GroupByWithResultProjectionAndElementProjectionAndComparer() { DataProducer <string> producer = new DataProducer <string>(); var query = producer.GroupBy(word => word[0].ToString(), word => word + word, (key, words) => new { Key = key, MaxLength = words.Max(word => word.Length) }, StringComparer.OrdinalIgnoreCase) .AsFutureEnumerable(); producer.ProduceAndEnd("one", "Two", "three", "Four", "Five", "six", "seven", "Others"); var results = query.Value.ToList(); Assert.AreEqual(4, results.Count); Assert.AreEqual("o", results[0].Key); Assert.AreEqual(12, results[0].MaxLength.Value); Assert.AreEqual("T", results[1].Key); Assert.AreEqual(10, results[1].MaxLength.Value); Assert.AreEqual("F", results[2].Key); Assert.AreEqual(8, results[2].MaxLength.Value); Assert.AreEqual("s", results[3].Key); Assert.AreEqual(10, results[3].MaxLength.Value); }
public void DefaultIfEmptyWithDataAndDefaultReplacement() { DataProducer <string> subject = new DataProducer <string>(); IDataProducer <string> result = subject.DefaultIfEmpty("foo"); ProduceAndCheck(subject, result, new[] { "a", "b", "c" }, new[] { "a", "b", "c" }); }
public void GroupByWithComparerAndElementProjection() { DataProducer <string> producer = new DataProducer <string>(); var query = producer.GroupBy(word => word[0].ToString(), word => word + word.Length, StringComparer.OrdinalIgnoreCase) .Select(group => new { group.Key, Words = group.AsFutureEnumerable() }) .AsFutureEnumerable(); producer.ProduceAndEnd("one", "Two", "three", "Four", "Five", "six", "seven", "Others"); var results = query.Value.ToList(); Assert.AreEqual(4, results.Count); Assert.AreEqual("o", results[0].Key); Assert.IsTrue(results[0].Words.Value.SequenceEqual(new[] { "one3", "Others6" })); Assert.AreEqual("T", results[1].Key); Assert.IsTrue(results[1].Words.Value.SequenceEqual(new[] { "Two3", "three5" })); Assert.AreEqual("F", results[2].Key); Assert.IsTrue(results[2].Words.Value.SequenceEqual(new[] { "Four4", "Five4" })); Assert.AreEqual("s", results[3].Key); Assert.IsTrue(results[3].Words.Value.SequenceEqual(new[] { "six3", "seven5" })); }
public void PumpWithBufferingRequired() { // This will keep track of how many we've consumed already int consumed = 0; DataProducer <int> producer = new DataProducer <int>(); IDataProducer <int> ordered = producer.OrderBy(x => x); var selected = ordered.Select(x => new { X = x, Consumed = consumed }); int[] data = new int[] { 1, 0, 4, 2, 3, 5 }; var results = producer.PumpProduceAndEnd(data, selected); int count = 0; foreach (var result in results) { Assert.AreEqual(count, result.X); count++; // Nothing will be yielded until we end everything, at which point // everything will have been buffered internally before we can increment Consumed Assert.AreEqual(0, result.Consumed); consumed++; } Assert.AreEqual(count, 6); }
public void SkipWithInsufficientData() { DataProducer <int> subject = new DataProducer <int>(); IDataProducer <int> result = subject.Skip(4); ProduceAndCheck(subject, result, new[] { 3, 10 }, new int[0]); }
public void TakeWhileAndConditionAlwaysMet() { DataProducer <int> subject = new DataProducer <int>(); IDataProducer <int> result = subject.TakeWhile(x => x < 100); ProduceAndCheck(subject, result, new[] { 3, 4, 10, 2, 3 }, new[] { 3, 4, 10, 2, 3 }); }
public void SkipWithEnoughData() { DataProducer <int> subject = new DataProducer <int>(); IDataProducer <int> result = subject.Skip(4); ProduceAndCheck(subject, result, new[] { 3, 10, 5, 7, 2, 8 }, new[] { 2, 8 }); }
public void TakeWhileAndConditionNeverMet() { DataProducer <int> subject = new DataProducer <int>(); IDataProducer <int> result = subject.TakeWhile(x => x > 10); ProduceAndCheck(subject, result, new[] { 3, 4, 10, 2, 3 }, new int[0]); }
public void ShouldProduceDataForAllTables() { ValueStore valuestore = new ValueStore(); var dp = new DataProducer(valuestore); var tables = new List <ExecutionTable>(); tables.Add(new ExecutionTable(customerTable, 1)); tables.Add(new ExecutionTable(orderTable, 2)); List <DataRowEntity> rows = new List <DataRowEntity>(); rows.AddRange(dp.ProduceRows(tables)); Assert.That(rows.Count, Is.EqualTo(2)); Assert.That(rows[0].Fields.Count, Is.EqualTo(4)); AssertFieldsInRowHaveSomeValues(valuestore, rows[0], 2); // simulate consuming and producing the identity value of CustomerId // this will cause the Order table to have a value for its CustomerId column valuestore.Put(rows[0].Fields[0].KeyValue, 1); Assert.That(rows[1].Fields.Count, Is.EqualTo(4)); AssertFieldsInRowHaveSomeValues(valuestore, rows[1], 0); }
public void ShouldInsertLotsOfRows() { prepareTables(); using (SQLDataProducer.DataConsumers.DataToMSSSQLInsertionConsumer.InsertConsumer consumer = new DataConsumers.DataToMSSSQLInsertionConsumer.InsertConsumer()) { var valueStore = new ValueStore(); DataProducer producer = new DataProducer(valueStore); consumer.Init(connectionString, new Dictionary <string, string>()); int rowCount = 0; consumer.ReportInsertionCallback = new Action(() => { rowCount++; }); for (int i = 0; i < 150; i++) { consumer.Consume(producer.ProduceRows(new List <ExecutionTable> { new ExecutionTable(customerTable, 1), new ExecutionTable(orderTable, 2) }), valueStore); } Assert.That(rowCount, Is.EqualTo(300)); } verifyRowCount("Customer", 150); verifyRowCount("Orders", 150); }
/// <summary> /// Groups and executes a pipeline for two results per group /// </summary> public static IEnumerable <KeyValueTuple <TKey, TResult1, TResult2> > GroupWithPipeline <TElement, TKey, TResult1, TResult2> (this IEnumerable <TElement> source, Func <TElement, TKey> keySelector, IEqualityComparer <TKey> comparer, Func <IDataProducer <TElement>, IFuture <TResult1> > pipeline1, Func <IDataProducer <TElement>, IFuture <TResult2> > pipeline2) { var keyMap = new Dictionary <TKey, DataProducer <TElement> >(comparer); var results = new List <KeyValueTuple <TKey, IFuture <TResult1>, IFuture <TResult2> > >(); foreach (TElement element in source) { TKey key = keySelector(element); DataProducer <TElement> producer; if (!keyMap.TryGetValue(key, out producer)) { producer = new DataProducer <TElement>(); keyMap[key] = producer; results.Add(new KeyValueTuple <TKey, IFuture <TResult1>, IFuture <TResult2> >(key, pipeline1(producer), pipeline2(producer))); } producer.Produce(element); } foreach (var producer in keyMap.Values) { producer.End(); } foreach (var result in results) { yield return(new KeyValueTuple <TKey, TResult1, TResult2>(result.Key, result.Value1.Value, result.Value2.Value)); } }
public void MaxNullableInt32WithProjectionNoElements() { DataProducer <int?> subject = new DataProducer <int?>(); IFuture <int?> result = subject.Max(x => - x); subject.End(); Assert.IsNull(result.Value); }
public void CountWithNulls() { int?[] data = { 1, null, 4, null, 3, null, 2 }; DataProducer<int?> subject = new DataProducer<int?>(); IFuture<int> count = subject.Count(); subject.ProduceAndEnd(data); Assert.AreEqual(data.Length, count.Value); Assert.AreEqual(7, count.Value); // to be sure... }
public void JustEnd() { DataProducer<string> subject = new DataProducer<string>(); bool endReached = false; subject.DataProduced += val => { throw new Exception(); }; subject.EndOfData += () => endReached = true; subject.End(); Assert.IsTrue(endReached); }
public void EndWithinEnd() { DataProducer<string> subject = new DataProducer<string>(); subject.EndOfData += () => { subject.End(); }; try { subject.End(); } catch (InvalidOperationException) { // Expected } }
public void EndTwice() { DataProducer<string> subject = new DataProducer<string>(); subject.End(); try { subject.End(); Assert.Fail("Expected exception"); } catch (InvalidOperationException) { // Expected } }
public void EventHooks() { var producer = new DataProducer<int>(); var grp = new ProducerGrouping<int, int>(5, producer); Action<int> act = x => { }; Action end = () => { }; IFuture<int> sum = grp.Sum(); grp.DataProduced += act; grp.EndOfData += end; producer.ProduceAndEnd(1, 2, 3); grp.DataProduced -= act; grp.EndOfData -= end; Assert.AreEqual(6, sum.Value); }
public void AggregateNoSeed() { string sentence = "the quick brown fox jumps over the lazy dog"; // Split the string into individual words. string[] words = sentence.Split(' '); DataProducer<string> subject = new DataProducer<string>(); // Prepend each word to the beginning of the // new sentence to reverse the word order. IFuture<string> reversed = subject.Aggregate((workingSentence, next) => next + " " + workingSentence); subject.ProduceAndEnd(words); Assert.AreEqual("dog lazy the over jumps fox brown quick the", reversed.Value); }
public void ValueThenEnd() { DataProducer<string> subject = new DataProducer<string>(); string pushed = null; bool endReached = false; subject.DataProduced += val => pushed = val; subject.EndOfData += () => endReached = true; Assert.IsFalse(endReached); Assert.IsNull(pushed); subject.Produce("foo"); Assert.IsFalse(endReached); Assert.AreEqual("foo", pushed); subject.End(); Assert.IsTrue(endReached); }
public void GroupByWithComparer() { DataProducer<string> producer = new DataProducer<string>(); var query = producer.GroupBy(word => word[0].ToString(), StringComparer.OrdinalIgnoreCase) .Select(group => new { group.Key, Words = group.AsFutureEnumerable() }) .AsFutureEnumerable(); producer.ProduceAndEnd("one", "Two", "three", "Four", "Five", "six", "seven", "Others"); var results = query.Value.ToList(); Assert.AreEqual(4, results.Count); Assert.AreEqual("o", results[0].Key); Assert.IsTrue(results[0].Words.Value.SequenceEqual(new[] { "one", "Others" })); Assert.AreEqual("T", results[1].Key); Assert.IsTrue(results[1].Words.Value.SequenceEqual(new[] { "Two", "three" })); Assert.AreEqual("F", results[2].Key); Assert.IsTrue(results[2].Words.Value.SequenceEqual(new[] { "Four", "Five" })); Assert.AreEqual("s", results[3].Key); Assert.IsTrue(results[3].Words.Value.SequenceEqual(new[] { "six", "seven" })); }
public void ElementAtOrDefaultOutsideRange() { DataProducer<string> subject = new DataProducer<string>(); IFuture<string> result = subject.ElementAtOrDefault(5); subject.ProduceAndEnd("zero", "one", "two", "three", "four"); Assert.IsNull(result.Value); }
public void AllNoData() { DataProducer<string> subject = new DataProducer<string>(); IFuture<bool> result = subject.All(x => x.Length < 5); subject.End(); Assert.IsTrue(result.Value); }
public void SingleOrDefaultNoMatchingData() { DataProducer<int> subject = new DataProducer<int>(); IFuture<int> single = subject.SingleOrDefault(x => x > 5); subject.ProduceAndEnd(1, 2, 3); Assert.AreEqual(0, single.Value); }
public void SingleOrDefaultWithSingleMatchingElement() { DataProducer<int> subject = new DataProducer<int>(); IFuture<int> single = subject.SingleOrDefault(x => x % 10 == 0); subject.ProduceAndEnd(5, 10, 15); Assert.AreEqual(10, single.Value); }
public void GroupByWithElementProjectionAndResultProjection() { DataProducer<string> producer = new DataProducer<string>(); var query = producer.GroupBy(word => word[0].ToString(), word => word + word, (key, words) => new { Key = key, MaxLength = words.Max(word => word.Length) }) .AsFutureEnumerable(); producer.ProduceAndEnd("One", "Two", "Three", "Four", "Five", "Six", "Seven", "others"); var results = query.Value.ToList(); Assert.AreEqual(5, results.Count); Assert.AreEqual("O", results[0].Key); Assert.AreEqual(6, results[0].MaxLength.Value); Assert.AreEqual("T", results[1].Key); Assert.AreEqual(10, results[1].MaxLength.Value); Assert.AreEqual("F", results[2].Key); Assert.AreEqual(8, results[2].MaxLength.Value); Assert.AreEqual("S", results[3].Key); Assert.AreEqual(10, results[3].MaxLength.Value); Assert.AreEqual("o", results[4].Key); Assert.AreEqual(12, results[4].MaxLength.Value); }
public void ContainsWithComparerWithMatch() { DataProducer<string> subject = new DataProducer<string>(); IFuture<bool> result = subject.Contains("FOUR", StringComparer.OrdinalIgnoreCase); subject.ProduceAndEnd("zero", "one", "two", "three", "four"); Assert.IsTrue(result.Value); }
public void AggregateWithSeed() { int[] ints = { 4, 8, 8, 3, 9, 0, 7, 8, 2 }; DataProducer<int> subject = new DataProducer<int>(); // Count the even numbers in the array, using a seed value of 0. IFuture<int> result = subject.Aggregate (0, (total, next) => next % 2 == 0 ? total + 1 : total); subject.ProduceAndEnd(ints); Assert.AreEqual(6, result.Value); }
public void ElementAtOrDefaultWithinRange() { DataProducer<string> subject = new DataProducer<string>(); IFuture<string> result = subject.ElementAtOrDefault(2); subject.ProduceAndEnd("zero", "one", "two", "three", "four"); Assert.AreEqual("two", result.Value); }
public void ContainsNoComparerNoMatch() { DataProducer<string> subject = new DataProducer<string>(); IFuture<bool> result = subject.Contains("FOUR"); subject.ProduceAndEnd("zero", "one", "two", "three", "four"); Assert.IsFalse(result.Value); }
public void ElementAtOutsideRange() { DataProducer<string> subject = new DataProducer<string>(); subject.ElementAt(5); subject.Produce("zero"); subject.Produce("one"); subject.Produce("two"); subject.Produce("three"); try { subject.End(); Assert.Fail("Expected exception"); } catch (ArgumentOutOfRangeException) { // Expected } }
public void AnyWithPredicateNoMatch() { DataProducer<string> subject = new DataProducer<string>(); IFuture<bool> result = subject.Any(x => x.Length == 6); subject.ProduceAndEnd("zero", "one", "two", "three", "four"); Assert.IsFalse(result.Value); }
public void GroupByWithResultProjectionAndElementProjectionAndComparer() { DataProducer<string> producer = new DataProducer<string>(); var query = producer.GroupBy(word => word[0].ToString(), word => word + word, (key, words) => new { Key = key, MaxLength = words.Max(word => word.Length) }, StringComparer.OrdinalIgnoreCase) .AsFutureEnumerable(); producer.ProduceAndEnd("one", "Two", "three", "Four", "Five", "six", "seven", "Others"); var results = query.Value.ToList(); Assert.AreEqual(4, results.Count); Assert.AreEqual("o", results[0].Key); Assert.AreEqual(12, results[0].MaxLength.Value); Assert.AreEqual("T", results[1].Key); Assert.AreEqual(10, results[1].MaxLength.Value); Assert.AreEqual("F", results[2].Key); Assert.AreEqual(8, results[2].MaxLength.Value); Assert.AreEqual("s", results[3].Key); Assert.AreEqual(10, results[3].MaxLength.Value); }
public void AnyWithPredicateNoData() { DataProducer<string> subject = new DataProducer<string>(); IFuture<bool> result = subject.Any(x => x.Length < 5); subject.End(); Assert.IsFalse(result.Value); }
public void SingleOrDefaultWithMultipleElements() { DataProducer<string> subject = new DataProducer<string>(); subject.SingleOrDefault(); subject.Produce("foo"); try { subject.Produce("bar"); Assert.Fail("Expected exception"); } catch (InvalidOperationException) { // Expected } }
public void AnyNoPredicateWithData() { DataProducer<string> subject = new DataProducer<string>(); IFuture<bool> result = subject.Any(); subject.ProduceAndEnd("zero", "one"); Assert.IsTrue(result.Value); }
public void SingleOrDefaultWithSingleElement() { DataProducer<int> subject = new DataProducer<int>(); IFuture<int> single = subject.SingleOrDefault(); subject.ProduceAndEnd(5); Assert.AreEqual(5, single.Value); }
public void AllReturningFalse() { DataProducer<string> subject = new DataProducer<string>(); IFuture<bool> result = subject.All(x => x.Length < 5); subject.ProduceAndEnd("zero", "one", "two", "three", "four"); Assert.IsFalse(result.Value); }
public void ProduceAndEnd() { DataProducer<string> subject = new DataProducer<string>(); List<string> pushed = new List<string>(); bool endReached = false; subject.DataProduced += val => pushed.Add(val); subject.EndOfData += () => endReached = true; subject.ProduceAndEnd("foo", "bar"); Assert.IsTrue(endReached); Assert.AreEqual(2, pushed.Count); Assert.AreEqual("foo", pushed[0]); Assert.AreEqual("bar", pushed[1]); }
public void SingleOrDefaultNoData() { DataProducer<int> subject = new DataProducer<int>(); IFuture<int> single = subject.SingleOrDefault(); subject.End(); Assert.AreEqual(0, single.Value); }