private FilterOperationBase BuildFilter(FilterTreeNode node)
{
// Если узел - операция
OperationTreeNode operationNode = node as OperationTreeNode;
{
if (operationNode != null)
{
FilterOperation operation = new FilterOperation(operationNode.Operation);
foreach (object obj in operationNode.Items)
{
FilterTreeNode childNode = obj as FilterTreeNode;
if (childNode != null)
{
FilterOperationBase filter = BuildFilter(childNode);
if (filter != null)
{
operation.Children.Add(filter);
}
}
}
return operation;
}
}
// Если узел - операнд
OperandTreeNode operand = node as OperandTreeNode;
if (operand != null)
{
return operand.Operand;
}
return null;
}
public void ByDefaultOperatorToExpressionConvertersAreTakenFromStaticProperty()
{
var marker1 = "MARKER1";
var marker2 = "MARKER2";
var wasCalled = false;
Type typePassed = null;
Config.DefaultOperatorToExpressionConverters.Add(marker2, new OperatorHandler((propTypeUnwrapped, propTypeRaw, left, right) =>
{
wasCalled = true;
typePassed = propTypeUnwrapped;
return(Expression.Equal(Expression.Constant(marker1), Expression.Constant(marker1)));
}));
var filter = new FilterTreeNode(
new GridFilter()
{
PropName = "A",
StringValue = "0",
Operator = marker2
});
var query = filter.WrapFilter(Collection);
var result = query.ToArray();
var expectation = "Linq.GridQuery.Test.TestSubject[].Where(par => (\"MARKER1\" == \"MARKER1\"))";
Assert.That(query.ToString(), Is.EqualTo(expectation));
Assert.That(wasCalled, Is.EqualTo(true));
Assert.That(typePassed, Is.EqualTo(typeof(Int32)));
Assert.That(result, Is.EquivalentTo(Collection));
}
public void InOrNullTest()
{
var filter =
new FilterTreeNode(
new FilterTreeNode(
new GridFilter()
{
PropName = "E",
StringValue = "null",
Operator = "isnull"
}),
LogicalOpertor.OR,
new FilterTreeNode(
new GridFilter()
{
PropName = "E",
StringValue = "[1,2]",
Operator = "in"
}));
var query = filter.WrapFilter(Collection);
var result = query.ToArray();
var expectation =
"Linq.GridQuery.Test.TestSubject[].Where(par => (Not(par.E.HasValue) Or IIF(par.E.HasValue, value(Linq.GridQuery.Test.TestEnum[]).Contains(par.E.Value), False)))";
Assert.That(query.ToString(), Is.EqualTo(expectation));
Assert.That(result, Is.EquivalentTo(Collection.Take(2)));
}
void item_ctrl_CustomCommandClick(object sender, CustomItemEventArgs e)
{
switch (e.Type)
{
case CustomControlTypes.Clear:
this.Items.Clear();
break;
case CustomControlTypes.Delete:
FilterTreeNode node = this.Parent as FilterTreeNode;
if (node != null)
{
node.Items.Remove(this);
}
break;
case CustomControlTypes.AddOperation:
OperationTreeNode operationNode = new OperationTreeNode(OperationTypes.And, false, m_Properties);
operationNode.ApplyFilter += new EventHandler(OnApplyFilter);
this.Items.Add(operationNode);
OperandTreeNode operand1_Node = new OperandTreeNode(m_Properties);
operand1_Node.ApplyFilter += new EventHandler(OnApplyFilter);
operationNode.Items.Add(operand1_Node);
break;
case CustomControlTypes.AddOperand:
OperandTreeNode operandNode = new OperandTreeNode(m_Properties);
operandNode.ApplyFilter += new EventHandler(OnApplyFilter);
this.Items.Add(operandNode);
break;
}
}
public void IsNotNull()
{
var filter = new FilterTreeNode(
new GridFilter()
{
PropName = "E",
StringValue = "null",
Operator = "isnotnull"
});
var query = filter.WrapFilter(Collection);
var result = query.ToArray();
var expectation = "Linq.GridQuery.Test.TestSubject[].Where(par => par.E.HasValue)";
Assert.That(query.ToString(), Is.EqualTo(expectation));
Assert.That(result, Is.EquivalentTo(Collection.Skip(1)));
filter = new FilterTreeNode(
new GridFilter()
{
PropName = "B",
StringValue = "null",
Operator = "isnotnull"
});
query = filter.WrapFilter(Collection);
result = query.ToArray();
expectation = "Linq.GridQuery.Test.TestSubject[].Where(par => (par.B != null))";
Assert.That(query.ToString(), Is.EqualTo(expectation));
Assert.That(result, Is.EquivalentTo(Collection.Take(2)));
}
private FilterOperationBase BuildFilter(FilterTreeNode node)
{
// Если узел - операция
OperationTreeNode operationNode = node as OperationTreeNode;
{
if (operationNode != null)
{
FilterOperation operation = new FilterOperation(operationNode.Operation);
foreach (object obj in operationNode.Items)
{
FilterTreeNode childNode = obj as FilterTreeNode;
if (childNode != null)
{
FilterOperationBase filter = BuildFilter(childNode);
if (filter != null)
{
operation.Children.Add(filter);
}
}
}
return(operation);
}
}
// Если узел - операнд
OperandTreeNode operand = node as OperandTreeNode;
if (operand != null)
{
return(operand.Operand);
}
return(null);
}
public void ByDefaultValueDeserializationFunctionIsTakenFromConfig()
{
var marker1 = "MARKER1";
string valCapture = null;
Type typeCapture = null;
Config.DefaultValueDeserialiationFunction = (val, type) =>
{
valCapture = val;
typeCapture = type;
return(5);
};
var filter = new FilterTreeNode(
new GridFilter()
{
PropName = "A",
StringValue = marker1,
Operator = "eq"
});
var query = filter.WrapFilter(Collection);
var result = query.ToArray();
var expectation = "Linq.GridQuery.Test.TestSubject[].Where(par => (par.A == 5))";
Assert.That(valCapture, Is.EqualTo(marker1));
Assert.That(typeCapture, Is.EqualTo(typeof(int)));
Assert.That(query.ToString(), Is.EqualTo(expectation));
Assert.That(query.Count, Is.EqualTo(1));
Assert.That(query.Single().A, Is.EqualTo(5));
}
public TreeNodeViewModel(
FilterTreeNode filterTreeNode,
IMessageBus messageBus)
{
_filterTreeNode = filterTreeNode;
_messageBus = messageBus;
}
public void TwoBranchesQueryWorks()
{
var filter = new FilterTreeNode(
new FilterTreeNode(
new GridFilter()
{
PropName = "A",
StringValue = "3",
Operator = "eq"
}),
LogicalOpertor.OR,
new FilterTreeNode(
new GridFilter()
{
PropName = "A",
StringValue = "5",
Operator = "eq"
})
);
var query = filter.WrapFilter(Collection);
var result = query.ToArray();
var expectation = "Linq.GridQuery.Test.TestSubject[].Where(par => ((par.A == 3) Or (par.A == 5)))";
Assert.That(query.ToString(), Is.EqualTo(expectation));
Assert.That(query.Count, Is.EqualTo(2));
Assert.That(query.ElementAt(0).A, Is.EqualTo(3));
Assert.That(query.ElementAt(1).A, Is.EqualTo(5));
}
public void FullTest()
{
var filter =
new FilterTreeNode(
new GridFilter("A", "gt", "3"),
LogicalOpertor.AND,
new FilterTreeNode(
new GridFilter("E", "isnull", "null"),
LogicalOpertor.OR,
new GridFilter("E", "in", "[1,2]")));
var sort = new[]
{
new GridSort("C", isDescending: false, treatNullLowest: true),
new GridSort("E", isDescending: true)
};
var gridQuery = new GridRequest()
{
Filter = filter,
Sort = sort,
Skip = 1,
Take = 5
};
var query = gridQuery.WrapQuery(Collection);
var result = query.ToArray();
var expectation =
"Linq.GridQuery.Test.TestSubject[].Where(par => " +
"((par.A > 3) And (Not(par.E.HasValue) " +
"Or IIF(par.E.HasValue, value(Linq.GridQuery.Test.TestEnum[]).Contains(par.E.Value), False))))" +
".OrderBy(Param_0 => Param_0.C.HasValue)" +
".ThenBy(Param_0 => Param_0.C)" +
".ThenByDescending(Param_1 => Param_1.E)" +
".Skip(1).Take(5)";
Assert.That(query.ToString(), Is.EqualTo(expectation));
Assert.That(result, Is.EquivalentTo(new []
{
Collection.ElementAt(8),
Collection.ElementAt(11),
Collection.ElementAt(9),
Collection.ElementAt(12),
Collection.ElementAt(7)
}));
var queryWithCount = gridQuery.WrapQueryWithCount(Collection);
var result2 = queryWithCount.Query.ToArray();
Assert.That(result, Is.EquivalentTo(result2));
Assert.That(queryWithCount.Count, Is.EqualTo(7));
var resultWithCount = gridQuery.GetQueryResultWithCount(Collection);
var result3 = resultWithCount.Result.ToArray();
Assert.That(result, Is.EquivalentTo(result3));
Assert.That(resultWithCount.Count, Is.EqualTo(7));
}
void item_ctrl_CustomCommandClick(object sender, CustomItemEventArgs e)
{
switch (e.Type)
{
case CustomControlTypes.Delete:
FilterTreeNode node = this.Parent as FilterTreeNode;
if (node != null)
{
node.Items.Remove(this);
}
break;
}
}
public FilterOperationBase GetFilter()
{
if (Tree.Items.Count > 0)
{
FilterTreeNode node = Tree.Items[0] as FilterTreeNode;
if (node != null)
{
FilterOperationBase res = BuildFilter(node);
return(res);
}
}
return(null);
}
public void FilterOnWrongPropertyThrows()
{
Assert.Throws <ArgumentException>(() =>
{
var filter = new FilterTreeNode(
new GridFilter()
{
PropName = "X",
StringValue = "4",
Operator = "gt"
});
var query = filter.WrapFilter(Collection);
});
}
public void ThrowsIfOperatorToExpressionConverterIsNotFound()
{
var filter = new FilterTreeNode(
new GridFilter()
{
PropName = "A",
StringValue = "0",
Operator = "IGNORE"
});
Assert.Throws <ArgumentException>(() =>
{
var query = filter.WrapFilter(Collection);
});
}
public void IsNotNullThrowsForNonNullableTypes()
{
Assert.Throws <ArgumentException>(() =>
{
var filter = new FilterTreeNode(
new GridFilter()
{
PropName = "A",
StringValue = "0",
Operator = "isnotnull"
});
var query = filter.WrapFilter(Collection);
var result = query.ToArray();
});
}
public void GetLambdaExpressionTest()
{
var filter = new FilterTreeNode(
new GridFilter()
{
PropName = "A",
StringValue = "4",
Operator = "gt"
});
var lambdaExpression = filter.GetLambdaExpression <TestSubject>();
var expectation = "par => (par.A > 4)";
Assert.That(lambdaExpression.ToString(), Is.EqualTo(expectation));
}
public void NoValueDeserializationFunctionFoundThrowsOnWrap()
{
Config.DefaultValueDeserialiationFunction = null;
var filter = new FilterTreeNode(
new GridFilter()
{
PropName = "A",
StringValue = "1",
Operator = "eq"
});
Assert.Throws <InvalidOperationException>(() =>
{
var query = filter.WrapFilter(Collection);
});
}
public void NotInTest()
{
var filter = new FilterTreeNode(
new GridFilter()
{
PropName = "A",
StringValue = "[1,5]",
Operator = "notin"
});
var query = filter.WrapFilter(Collection);
var result = query.ToArray();
var expectation = "Linq.GridQuery.Test.TestSubject[].Where(par => Not(value(System.Int32[]).Contains(par.A)))";
Assert.That(query.ToString(), Is.EqualTo(expectation));
Assert.That(result, Is.EquivalentTo(Collection.Skip(1).Take(1)));
}
public void CanHanldeEnums()
{
var filter = new FilterTreeNode(
new GridFilter()
{
PropName = "D",
StringValue = "3",
Operator = "eq"
});
var query = filter.WrapFilter(Collection);
var result = query.ToArray();
var expectation = "Linq.GridQuery.Test.TestSubject[].Where(par => (par.D == C))";
Assert.That(query.ToString(), Is.EqualTo(expectation));
Assert.That(result, Is.EquivalentTo(Collection.Skip(2)));
}
public void DoesNotContainTest()
{
var filter = new FilterTreeNode(
new GridFilter()
{
PropName = "B",
StringValue = "'C'",
Operator = "doesnotcontain"
});
var query = filter.WrapFilter(Collection);
var result = query.ToArray();
var expectation = "Linq.GridQuery.Test.TestSubject[].Where(par => IIF((par.B != null), Not(par.B.Contains(\"C\")), False))";
Assert.That(query.ToString(), Is.EqualTo(expectation));
Assert.That(result, Is.EquivalentTo(Collection.Take(1)));
}
public void EndsWithTest()
{
var filter = new FilterTreeNode(
new GridFilter()
{
PropName = "B",
StringValue = "'A'",
Operator = "endswith"
});
var query = filter.WrapFilter(Collection);
var result = query.ToArray();
var expectation = "Linq.GridQuery.Test.TestSubject[].Where(par => IIF((par.B != null), par.B.EndsWith(\"A\"), False))";
Assert.That(query.ToString(), Is.EqualTo(expectation));
Assert.That(result, Is.EquivalentTo(Collection.Take(1)));
}
public void LteTest()
{
var filter = new FilterTreeNode(
new GridFilter()
{
PropName = "A",
StringValue = "3",
Operator = "lte"
});
var query = filter.WrapFilter(Collection);
var result = query.ToArray();
var expectation = "Linq.GridQuery.Test.TestSubject[].Where(par => (par.A <= 3))";
Assert.That(query.ToString(), Is.EqualTo(expectation));
Assert.That(result, Is.EquivalentTo(Collection.Take(2)));
}
public void CanHanldeNullables()
{
var filter = new FilterTreeNode(
new GridFilter()
{
PropName = "C",
StringValue = "3",
Operator = "gt"
});
var query = filter.WrapFilter(Collection);
var result = query.ToArray();
var expectation = "Linq.GridQuery.Test.TestSubject[].Where(par => IIF(par.C.HasValue, (par.C.Value > 3), False))";
Assert.That(query.ToString(), Is.EqualTo(expectation));
Assert.That(result, Is.EquivalentTo(Collection.Skip(2)));
}
public void NotInTestNullableEnum()
{
var filter = new FilterTreeNode(
new GridFilter()
{
PropName = "E",
StringValue = "[1,3]",
Operator = "notin"
});
var query = filter.WrapFilter(Collection);
var result = query.ToArray();
var expectation =
"Linq.GridQuery.Test.TestSubject[].Where(par => IIF(par.E.HasValue, Not(value(Linq.GridQuery.Test.TestEnum[]).Contains(par.E.Value)), False))";
Assert.That(query.ToString(), Is.EqualTo(expectation));
Assert.That(result, Is.EquivalentTo(Collection.Skip(1).Take(1)));
}
public void SingleFitlerWorks()
{
var filter = new FilterTreeNode(
new GridFilter()
{
PropName = "A",
StringValue = "4",
Operator = "gt"
});
var query = filter.WrapFilter(Collection);
var result = query.ToArray();
var expectation = "Linq.GridQuery.Test.TestSubject[].Where(par => (par.A > 4))";
Assert.That(query.ToString(), Is.EqualTo(expectation));
Assert.That(query.Count, Is.EqualTo(1));
Assert.That(query.Single().A, Is.EqualTo(5));
}
public void AdditionalOperatorToExpressionConvertersProvidedOnPerInstanceBasisOverrideBaseOnesOfTheSameName()
{
var marker1 = "MARKER1";
var marker2 = "MARKER2";
var wasCalled = false;
Type typePassed = null;
Config.DefaultOperatorToExpressionConverters.Add(marker2, new OperatorHandler((propTypeUnwrapped, propTypeRaw, left, right) =>
{
throw new Exception("This should never be called.");
}));
var additionalOperatorToExpressionConverters =
new Dictionary <string, OperatorHandler>()
{
{ marker2, new OperatorHandler((propTypeUnwrapped, propTypeRaw, left, right) =>
{
wasCalled = true;
typePassed = propTypeUnwrapped;
return(Expression.Equal(Expression.Constant(marker1), Expression.Constant(marker1)));
}) }
};
var filter = new FilterTreeNode(
new GridFilter()
{
PropName = "A",
StringValue = "0",
Operator = marker2
},
operatorToExpressionConvertersOverrides: additionalOperatorToExpressionConverters);
var query = filter.WrapFilter(Collection);
var result = query.ToArray();
var expectation = "Linq.GridQuery.Test.TestSubject[].Where(par => (\"MARKER1\" == \"MARKER1\"))";
Assert.That(query.ToString(), Is.EqualTo(expectation));
Assert.That(wasCalled, Is.EqualTo(true));
Assert.That(typePassed, Is.EqualTo(typeof(Int32)));
Assert.That(result, Is.EquivalentTo(Collection));
}
public void ValueDeserializationFunctionOverrideCanBeSet()
{
var marker1 = "MARKER1";
string valCapture = null;
Type typeCapture = null;
Config.DefaultValueDeserialiationFunction = (val, type) =>
{
throw new InvalidOperationException("This should not be called.");
};
Func <string, Type, object> actuallyUsedFunc = (val, type) =>
{
valCapture = val;
typeCapture = type;
return(5);
};
var filter = new FilterTreeNode(
new GridFilter()
{
PropName = "A",
StringValue = marker1,
Operator = "eq"
},
actuallyUsedFunc);
var query = filter.WrapFilter(Collection);
var result = query.ToArray();
var expectation = "Linq.GridQuery.Test.TestSubject[].Where(par => (par.A == 5))";
Assert.That(filter.ValueDeserializationFunctionOverride, Is.EqualTo(actuallyUsedFunc));
Assert.That(valCapture, Is.EqualTo(marker1));
Assert.That(typeCapture, Is.EqualTo(typeof(int)));
Assert.That(query.ToString(), Is.EqualTo(expectation));
Assert.That(query.Count, Is.EqualTo(1));
Assert.That(query.Single().A, Is.EqualTo(5));
}
public SetMeritForm(FilterTreeNode filter)
{
InitializeComponent();
_filter = filter;
//Configure the merits for each radio button
_radioButtonMerits.Add(meritSwCompressorRadioButton, Merit.SWCompressor);
_radioButtonMerits.Add(meritHwCompressorRadioButton, Merit.HWCompressor);
_radioButtonMerits.Add(meritDoNotUseRadioButton, Merit.DoNotUse);
_radioButtonMerits.Add(meritUnlikelyRadioButton, Merit.Unlikely);
_radioButtonMerits.Add(meritNormalRadioButton, Merit.Normal);
_radioButtonMerits.Add(meritNormalPlus1RadioButton, Merit.Normal + 1);
_radioButtonMerits.Add(meritPreferredRadioButton, Merit.Preferred);
_radioButtonMerits.Add(meritPreferredPlusOneRadioButton, Merit.Preferred + 1);
_radioButtonMerits.Add(meritPreferredPlus255RadioButton, Merit.Preferred + 255);
customMeritTextBox.Text = ((uint)_filter.Merit).ToString("x");
filterNameLabel.Text = _filter.FriendlyName;
//Check the relevant radio button
bool matchFound = false;
foreach (RadioButton key in _radioButtonMerits.Keys)
{
if (_radioButtonMerits[key] == _filter.Merit)
{
key.Checked = true;
matchFound = true;
break;
}
}
if (!matchFound)
{
meritCustomRadioButton.Checked = true;
}
}
public void ThreeBranchesQueryWorks2()
{
var filter = new FilterTreeNode(
new FilterTreeNode(
new FilterTreeNode(
new GridFilter()
{
PropName = "A",
StringValue = "2",
Operator = "gt"
}),
LogicalOpertor.AND,
new FilterTreeNode(
new GridFilter()
{
PropName = "A",
StringValue = "4",
Operator = "lt"
})
),
LogicalOpertor.AND,
new FilterTreeNode(
new GridFilter()
{
PropName = "A",
StringValue = "5",
Operator = "eq"
}));
var query = filter.WrapFilter(Collection);
var result = query.ToArray();
var expectation = "Linq.GridQuery.Test.TestSubject[].Where(par => (((par.A > 2) And (par.A < 4)) And (par.A == 5)))";
Assert.That(query.ToString(), Is.EqualTo(expectation));
Assert.That(query.Count, Is.EqualTo(0));
}
public void GetLambdaExpressionThreeBranchesTest()
{
var filter = new FilterTreeNode(
new FilterTreeNode(
new FilterTreeNode(
new GridFilter()
{
PropName = "A",
StringValue = "2",
Operator = "gt"
}),
LogicalOpertor.AND,
new FilterTreeNode(
new GridFilter()
{
PropName = "A",
StringValue = "4",
Operator = "lt"
})
),
LogicalOpertor.AND,
new FilterTreeNode(
new GridFilter()
{
PropName = "A",
StringValue = "5",
Operator = "eq"
}));
var lambdaExpression = filter.GetLambdaExpression <TestSubject>();
var expectation = "par => (((par.A > 2) And (par.A < 4)) And (par.A == 5))";
Assert.That(lambdaExpression.ToString(), Is.EqualTo(expectation));
}
public FilterTreeNodeNot(FilterTreeNode a)
{
_a = a;
}
private void PopulateFilterDetails(FilterTreeNode filter)
{
PopulateFilterDetails((FilterDeviceTreeNode)filter);
AddFilterProperty("File Path", filter.FilePath, filter.FilePathException);
AddFilterProperty("Version", filter.Version, filter.VersionException);
AddFilterProperty("File Version", filter.FileVersion, filter.FileVersionException);
//The buttons are only valid for filters, not filter categories
showPropertyPageButton.Enabled =
unregisterButton.Enabled =
changeMeritButton.Enabled = true;
}
private void PopulateFiltersTreeWithFilter(TreeNode parentNode, FilterTreeNode filter)
{
TreeNode node = new TreeNode();
node.Text = filter.FriendlyName;
if (node.Text == null)
{
node.Text = String.Format("!! {0}", filter.FriendlyNameException);
}
node.Tag = filter;
parentNode.Nodes.Add(node);
}
public void AdditionalOperatorToExpressionConvertersCanBeSetForRootOfTreeAndFunctionOfEachBranchFlowsDowntreeForNodesWithoutTheirOwn()
{
var marker2 = "MARKER2";
var marker3 = "MARKER3";
Type typePassed = null;
var additionalOperatorToExpressionConverters1 =
new Dictionary <string, OperatorHandler>()
{
{ marker3, new OperatorHandler((propTypeUnwrapped, propTypeRaw, left, right) =>
{
typePassed = propTypeUnwrapped;
return(Expression.Equal(Expression.Constant(marker3), Expression.Constant(marker3)));
}) },
{
marker2, new OperatorHandler((propTypeUnwrapped, propTypeRaw, left, right) =>
{
throw new Exception("This should never be called.");
})
}
};
var additionalOperatorToExpressionConverters2 =
new Dictionary <string, OperatorHandler>()
{
{ marker2, new OperatorHandler((propTypeUnwrapped, propTypeRaw, left, right) =>
{
typePassed = propTypeUnwrapped;
return(Expression.Equal(Expression.Constant(marker2), Expression.Constant(marker2)));
}) }
};
var branchWithOwnFunction = new FilterTreeNode(
new FilterTreeNode(
new GridFilter()
{
PropName = "A",
StringValue = "1",
Operator = "eq"
}),
LogicalOpertor.OR,
new FilterTreeNode(
new GridFilter()
{
PropName = "A",
StringValue = "0",
Operator = marker2
}),
operatorToExpressionConvertersOverrides: additionalOperatorToExpressionConverters2);
var branchWithoutOwnFunction = new FilterTreeNode(
new FilterTreeNode(
new GridFilter()
{
PropName = "A",
StringValue = "2",
Operator = "eq"
}),
LogicalOpertor.OR,
new FilterTreeNode(
new GridFilter()
{
PropName = "A",
StringValue = "0",
Operator = marker3
}));
var filter = new FilterTreeNode(
branchWithOwnFunction,
LogicalOpertor.OR,
branchWithoutOwnFunction,
operatorToExpressionConvertersOverrides: additionalOperatorToExpressionConverters1);
var query = filter.WrapFilter(Collection);
var result = query.ToArray();
var expectation = "Linq.GridQuery.Test.TestSubject[].Where(par => (((par.A == 1) Or (\"MARKER2\" == \"MARKER2\")) Or ((par.A == 2) Or (\"MARKER3\" == \"MARKER3\"))))";
Assert.That(query.ToString(), Is.EqualTo(expectation));
Assert.That(query.Count, Is.EqualTo(3));
Assert.That(query.ElementAt(0).A, Is.EqualTo(1));
Assert.That(query.ElementAt(1).A, Is.EqualTo(3));
Assert.That(query.ElementAt(2).A, Is.EqualTo(5));
}
