public void Accumulate_WithTwoEnumerations_AccumulatesOneIntoTheOther()
{
// arrange
var containers = new[] { new KeyValuePair<int, List<string>>(0, new List<string>()), new KeyValuePair<int, List<string>>(1, new List<string>()), new KeyValuePair<int, List<string>>(2, new List<string>()), new KeyValuePair<int, List<string>>(3, new List<string>()) };
var items = new[] {new KeyValuePair<int, string>(1, "A"), new KeyValuePair<int, string>(1, "B"), new KeyValuePair<int, string>(3, "C")};
// act
containers.Accumulate(items, container => container.Key, item => item.Key, (container, item) => container.Value.Add(item.Value));
// assert
Assert.AreEqual(0, containers.First().Value.Count);
var secondContainer = containers.ElementAt(1);
Assert.AreEqual(2, secondContainer.Value.Count);
Assert.AreEqual("A", secondContainer.Value[0]);
Assert.AreEqual("B", secondContainer.Value[1]);
Assert.AreEqual(0, containers.ElementAt(2).Value.Count);
var fourthContainer = containers.ElementAt(3);
Assert.AreEqual(1, fourthContainer.Value.Count);
Assert.AreEqual("C", fourthContainer.Value[0]);
}
public static Node BuildParametizedQuantifierNode(Token startToken, TreeBuilderState state)
{
var acceptedQuantifierTokenTypes = new[]
{
TokenType.Number,
TokenType.ParametizedQuantifierRangeSeparator,
TokenType.ParametizedQuantifierEnd
};
var remainingQuantifierTokens = state.ProcessingState.Tokens
.DequeueWhile(t => acceptedQuantifierTokenTypes.Contains(t.Type));
var quantifierTokens = new[] { startToken }.Concat(remainingQuantifierTokens);
int? min;
int? max;
var quantifierTokenTypes = quantifierTokens.Select(t => t.Type);
if (quantifierTokenTypes.SequenceEqual(new[]
{
TokenType.ParametizedQuantifierStart,
TokenType.Number,
TokenType.ParametizedQuantifierRangeSeparator,
TokenType.Number,
TokenType.ParametizedQuantifierEnd
}))
{
min = int.Parse(quantifierTokens.ElementAt(1).Data);
max = int.Parse(quantifierTokens.ElementAt(3).Data);
}
else if (quantifierTokenTypes.SequenceEqual(new[]
{
TokenType.ParametizedQuantifierStart,
TokenType.ParametizedQuantifierRangeSeparator,
TokenType.Number,
TokenType.ParametizedQuantifierEnd
}))
{
min = null;
max = int.Parse(quantifierTokens.ElementAt(2).Data);
}
else if (quantifierTokenTypes.SequenceEqual(new[]
{
TokenType.ParametizedQuantifierStart,
TokenType.Number,
TokenType.ParametizedQuantifierRangeSeparator,
TokenType.ParametizedQuantifierEnd
}))
{
min = int.Parse(quantifierTokens.ElementAt(1).Data);
max = null;
}
else if (quantifierTokenTypes.SequenceEqual(new[]
{
TokenType.ParametizedQuantifierStart,
TokenType.Number,
TokenType.ParametizedQuantifierEnd
}))
{
min = int.Parse(quantifierTokens.ElementAt(1).Data);
max = min;
}
else
{
return new LiteralNode(
Token.GetData(quantifierTokens),
startToken.StartIndex
);
}
return BuildQuantifierNode(quantifierTokens, state, min, max);
}
public void should_get_nth_element_using_element_at()
{
var sequence = new[] { 1, 2, 3, 4, 5 };
int thirdElement = sequence.ElementAt(2);
// please update variable value to fix the test.
const int expectedThirdElement = 0;
Assert.Equal(expectedThirdElement, thirdElement);
}
