public void Enumerable_RepeatValue_NegativeTimes_EnumeratesEmptySequence()
{
int source = 13;
var result = EnumerableSource.Repeat(source, -1);
Assert.IsTrue(result.SequenceEqual(new int[] { }), "Item should not be repeated.");
}
public void JoinTestMethod1()
{
var joinQuery = from cust in this.baseCustomerQuery
join ctr in this.baseContractQuery on cust.Id equals ctr.CustomerId into joined select new Customer()
{
Id = cust.Id,
Vorname = cust.Vorname,
Nachname = cust.Nachname,
Age = cust.Age,
Contracts = joined
};
//var r = joinQuery.ToList();
var query = new EnumerableSource <Customer>().Where(x => x.Contracts.Any(c => c.Descriptions.Contains("test"))).OrderByDescending(x => x.Nachname);
var node = query.Serialize();
var expression = new QNodeConverter().Convert(joinQuery, node);
var target = joinQuery.Execute(expression) as List <Customer>;
var source = this.customers.AsQueryable().Execute(expression) as List <Customer>;
Assert.AreEqual(target.Count, source.Count);
for (int i = 0; i < target.Count; i++)
{
Assert.AreEqual(target[i].Vorname, source[i].Vorname);
Assert.AreEqual(target[i].Nachname, source[i].Nachname);
}
}
public void Enumerable_RepeatValue_Infinitely_EnumeratesRepeatedItem()
{
int source = 13;
var result = EnumerableSource.Repeat(source).Take(3);
Assert.IsTrue(result.SequenceEqual(new[] { 13, 13, 13 }), "Item should be repeated.");
}
public void Enumerable_Generate_WithFiniteSimpleDelegate_GeneratesSequence()
{
int source = 13;
IEnumerable <int> result = EnumerableSource.Generate(() => source++, 3);
Assert.IsTrue(result.SequenceEqual(new[] { 13, 14, 15 }), "Generate should return the requested sequence.");
}
public void Enumerable_Generate_WithFiniteSimpleDelegate_NegativeCount_GeneratesEmptySequence()
{
int source = 13;
IEnumerable <int> result = EnumerableSource.Generate(() => source++, -1);
Assert.IsTrue(result.SequenceEqual(new int[] { }), "Generate should return an empty sequence.");
}
private readonly int _targetSum; // сумма значений для каждого разбиения
public ContextPartitioner(WorkItem[] data, int target)
: base(true, false, true)
{
_dataItems = data;
_targetSum = target;
_enumSource = new EnumerableSource(this);
}
protected void DoTest(string Input, bool untilEnd, string expected)
{
// Lex and filter the input, then wrap it in an EnumerableSource and parse it
StringCharSourceFile input = new StringCharSourceFile(Input);
IEnumerable <AstNode> lexer;
if (untilEnd)
{
lexer = new BooLexerCore(input, new Dictionary <string, Symbol>());
}
else
{
lexer = new BooLexer(input, new Dictionary <string, Symbol>(), true);
}
IEnumerable <AstNode> lexFilter = new VisibleTokenFilter <AstNode>(lexer);
EnumerableSource <AstNode> source = new EnumerableSource <AstNode>(lexFilter);
int pos = 0;
OneOperatorMatch <AstNode> expr = _parser.Parse((IParserSource <AstNode>)source, ref pos, untilEnd);
// Build result string
Assert.IsNotNull(expr);
string result = BuildResult(expr);
Assert.AreEqual(expected, result);
}
public void Next_Returns_A_Enumration_Of_A_Hundred()
{
var source = new EnumerableSource <RandomStringSource, string>(100, new object[] { 4, 20 });
var value = source.Next(null);
Assert.AreEqual(100, value.Count());
}
public void Enumerable_Defer_IsNotEvaluatedUntilEnumeration()
{
int invokeCount = 0;
IEnumerable <int> result = EnumerableSource.Defer(() => { ++invokeCount; return(new int[] { }); });
Assert.AreEqual(0, invokeCount, "Defer should not be evaluated until it's enumerated.");
}
public void Enumerable_Return_EnumeratesSingleItem()
{
int source = 13;
var result = EnumerableSource.Return(source);
Assert.IsTrue(result.SequenceEqual(new[] { 13 }), "Item should be enumerated.");
}
public void TestMethod1()
{
var set = new EnumerableSource <TestIndex>();
var query = set.Where(x => x.Vorname == "Dirk" || x.Nachname.Contains("b"));
var node = query.Serialize();
var d = new QueryContainerBuilder(client);
var result = d.Convert <TestIndex>(node);
}
public void Enumerable_Run_ExecutesSequence()
{
int value = 0;
IEnumerable <int> source = EnumerableSource.Generate(0, i => i != 10, _ => ++ value, i => i + 1);
source.Run();
Assert.AreEqual(10, value, "Run should evaluate the sequence.");
}
public ContextPartitioner(WorkItem[] data, int target) : base(true, false, true)
{
// set the instance variables from the parameters
dataItems = data;
targetSum = target;
// create the enumerable source
enumSource = new EnumerableSource(this);
}
public void TestMethod1()
{
var query = new EnumerableSource<PersonDto>().Where(x => x.Vorname.Contains("a"));
var node = query.Serialize();
var converter = new QNodeConverter();
var expression = converter.Convert(this.persons.AsQueryable(),node);
var result = this.persons.AsQueryable().Execute(expression);
}
public void CountMethod1()
{
var query = new EnumerableSource<PersonDto>().Where(x => x.Mitarbeiters.Count > 0);
var node = query.Serialize();
var converter = new QNodeConverter();
var expression = converter.Convert(this.persons.AsQueryable(),node);
var result = this.persons.AsQueryable().Execute(expression);
}
public void SkipMethod1()
{
var query = new EnumerableSource<PersonDto>().Where(x => x.Vorname.EndsWith("a")).OrderBy(x => x.Vorname).Skip(1);
var node = query.Serialize();
var converter = new QNodeConverter();
var expression = converter.Convert(this.persons.AsQueryable(),node);
var result = this.persons.AsQueryable().Execute(expression);
}
public void QueryStringMethod2()
{
var query = new EnumerableSource<PersonDto>().QueryString("a", dto => new object[] { dto.Vorname, dto.Nachname, dto.Leiter.Vorname });
var node = query.Serialize();
var converter = new QNodeConverter();
var expression = converter.Convert(this.persons.AsQueryable(), node);
var result = this.persons.AsQueryable().Execute(expression);
}
public void Enumerable_Defer_IsReevaluatedEachEnumeration()
{
int invokeCount = 0;
IEnumerable <int> result = EnumerableSource.Defer(() => { ++invokeCount; return(new int[] { }); });
result.Run();
result.Run();
Assert.AreEqual(2, invokeCount, "Defer should be evaluated each time it's enumerated.");
}
public void InTestMethod()
{
var list = new List<string>() { "Hans" , "Dirk" };
var query = new EnumerableSource<PersonDto>().Where(x => list.Contains(x.Vorname));
var node = query.Serialize();
var converter = new QNodeConverter();
var expression = converter.Convert(this.persons.AsQueryable(),node);
var result = this.persons.AsQueryable().Execute(expression);
}
public void Get()
{
ILazySource <IEnumerable <int> > lazySource = new LazySource <IEnumerable <int> >(() => Enumerable.Range(1, 5));
ISource <IEnumerable <int> > source = new EnumerableSource <int>(lazySource);
Assert.NotNull(source.Value);
Assert.False(lazySource.IsLoaded);
source.Value.ForEach();
Assert.True(lazySource.IsLoaded);
Assert.True(source.Value.SequenceEqual(lazySource.Value));
}
public void Get()
{
ILazySource<IEnumerable<int>> lazySource = new LazySource<IEnumerable<int>>(() => Enumerable.Range(1, 5));
ISource<IEnumerable<int>> source = new EnumerableSource<int>(lazySource);
Assert.NotNull(source.Value);
Assert.False(lazySource.IsLoaded);
source.Value.ForEach();
Assert.True(lazySource.IsLoaded);
Assert.True(source.Value.SequenceEqual(lazySource.Value));
}
public void SortTest1()
{
var set = new EnumerableSource <TestIndex>();
var query = set.OrderBy(x => x.Vorname).OrderByDescending(x => x.Nachname);
var node = query.Serialize();
var d = new QueryContainerBuilder(client);
var result = d.Convert <TestIndex>(node).ToList();
var sorted = result.OrderBy(x => x.Vorname).ThenByDescending(x => x.Nachname).ToList();
for (int i = 0; i < result.Count; i++)
{
Assert.AreSame(result[i].Vorname, sorted[i].Vorname);
Assert.AreSame(result[i].Nachname, sorted[i].Nachname);
}
}
/// <summary>
/// Inserts an element at the specified view index.
/// </summary>
/// <param name="index">The zero-based view index at which the element should be inserted. This index is guaranteed to be valid.</param>
/// <param name="item">The element to store in the list.</param>
protected override void DoInsert(int index, T item)
{
this.EnsureCapacityForOneElement();
if (index == 0)
{
this.DoAddToFront(item);
return;
}
else if (index == this.count)
{
this.DoAddToBack(item);
return;
}
this.DoInsertRange(index, EnumerableSource.Return(item), 1);
}
public void ProjectionTestMethod1()
{
var query = new EnumerableSource <Customer>().Select(x => new { name = x.Vorname });
var node = query.Serialize();
var sourceExpression = new QNodeConverter().Convert(this.baseCustomerQuery, node);
var source = this.baseCustomerQuery.Execute(sourceExpression);
var targetExpression = new QNodeConverter().Convert(this.customers.AsQueryable(), node);
var target = this.customers.AsQueryable().Execute(targetExpression);
//Assert.AreEqual(target.Count, source.Count);
//for (int i = 0; i < target.Count; i++)
//{
// Assert.AreEqual(target[i].Vorname, source[i].Vorname);
// Assert.AreEqual(target[i].Nachname, source[i].Nachname);
//}
}
public void ProjectionTestMethod1()
{
var v = this.baseCustomerQuery.SelectMany(x => x.Contracts).Where(c => c.Descriptions.ToLower().Contains("test")).ToList();
var query = new EnumerableSource <Customer>().Select(x => new { Vorname = x.Vorname, Contracts = x.Contracts });
var node = query.Serialize();
var sourceExpression = new QNodeConverter().Convert(this.baseCustomerQuery, node);
var source = this.baseCustomerQuery.Execute(sourceExpression);
var targetExpression = new QNodeConverter().Convert(this.customers.AsQueryable(), node);
var target = this.customers.AsQueryable().Execute(targetExpression);
//Assert.AreEqual(target.Count, source.Count);
//for (int i = 0; i < target.Count; i++)
//{
// Assert.AreEqual(target[i].Vorname, source[i].Vorname);
// Assert.AreEqual(target[i].Nachname, source[i].Nachname);
//}
}
public void WhereTestMethod1()
{
var query = new EnumerableSource <Customer>().Where(x => x.Vorname.ToLower().Contains("d"));
var node = query.Serialize();
var sourceExpression = new QNodeConverter().Convert(this.baseCustomerQuery, node);
var source = this.baseCustomerQuery.Execute(sourceExpression) as List <Customer>;
var targetExpression = new QNodeConverter(new QNodeConverterSettings()
{
QueryStringIgnoreCase = false
}).Convert(this.customers.AsQueryable(), node);
var target = this.customers.AsQueryable().Execute(targetExpression) as List <Customer>;
Assert.AreEqual(target.Count, source.Count);
for (int i = 0; i < target.Count; i++)
{
Assert.AreEqual(target[i].Vorname, source[i].Vorname);
Assert.AreEqual(target[i].Nachname, source[i].Nachname);
}
}
public void WhereTestMethod1()
{
Expression <Func <TestIndex, bool> > predicate =
(x) =>
(x.Vorname == "Dirk" && x.Nachname == "Fischer") ||
(x.Nachname.Contains("M") && x.Vorname.Contains("n"));
var set = new EnumerableSource <TestIndex>();
var query = set.Where(predicate);
var node = query.Serialize();
var d = new QueryContainerBuilder(client);
var result = d.Convert <TestIndex>(node).ToList().OrderBy(x => x.Nachname).OrderBy(x => x.Vorname).ToList();
var source = this.persons.Where(predicate.Compile()).OrderBy(x => x.Nachname).OrderBy(x => x.Vorname).ToList();
Assert.AreEqual(result.Count, source.Count());
for (int i = 0; i < result.Count; i++)
{
Assert.AreEqual(result[i].Vorname, source[i].Vorname);
Assert.AreEqual(result[i].Nachname, source[i].Nachname);
}
}
public void InTestMethod1()
{
var ages = new List <int>()
{
39, 31
};
Expression <Func <TestIndex, bool> > predicate = x => ages.Contains(x.Age);
var set = new EnumerableSource <TestIndex>();
var query = set.Where(predicate);
var node = query.Serialize();
var d = new QueryContainerBuilder(client);
var result = d.Convert <TestIndex>(node).OrderBy(x => x.Nachname).OrderBy(x => x.Vorname).ToList();
var source = this.persons.AsQueryable().Where(predicate).OrderBy(x => x.Nachname).OrderBy(x => x.Vorname).ToList();
Assert.AreEqual(result.Count, source.Count());
for (int i = 0; i < result.Count; i++)
{
Assert.AreEqual(result[i].Vorname, source[i].Vorname);
Assert.AreEqual(result[i].Nachname, source[i].Nachname);
}
}
public ContextPartitioner(WorkItem[] data, int target)
{
dataItems = data;
targetSum = target;
enumSource = new EnumerableSource(this);
}
public void Enumerable_Generate_WithInfiniteSingleValueDelegate_GeneratesSequence()
{
IEnumerable <int> result = EnumerableSource.Generate(0, i => i + 1, i => i * 2).Take(4);
Assert.IsTrue(result.SequenceEqual(new[] { 0, 2, 4, 6 }), "Generate should return the requested sequence.");
}
public void Enumerable_Generate_WithFiniteIndexedDelegate_NegativeCount_GeneratesEmptySequence()
{
IEnumerable <int> result = EnumerableSource.Generate((i) => i * 2, -1);
Assert.IsTrue(result.SequenceEqual(new int[] { }), "Generate should return an empty sequence.");
}
