public static void CollectionMath_Test()
{
var arr1 = new[] {1, 2, 3, 4, 5, 6};
var arr2 = new[] {2, 9};
var test1 = arr1.Intersect(arr2);
var test2 = arr1.Union(arr2);
var test3 = arr1.Except(arr2);
Console.WriteLine(arr1.Select(x => x.ToString()).Aggregate((x, y) => x + "," + y));
Console.WriteLine(arr2.Select(x => x.ToString()).Aggregate((x, y) => x + "," + y));
Console.WriteLine("--------------------------------------------------------------");
Console.WriteLine(test1.Select(x => x.ToString()).Aggregate((x, y) => x + "," + y));
Console.WriteLine(test2.Select(x => x.ToString()).Aggregate((x, y) => x + "," + y));
Console.WriteLine(test3.Select(x => x.ToString()).Aggregate((x, y) => x + "," + y));
}
public void FirstSequenceOnlyReadAsResultsAreRead()
{
var firstQuery = new[] { 10, 2, 0, 2 }.Select(x => 10 / x);
int[] second = { 1 };
var query = firstQuery.Intersect(second);
using (var iterator = query.GetEnumerator())
{
// We can get the first value with no problems
Assert.IsTrue(iterator.MoveNext());
Assert.AreEqual(1, iterator.Current);
// Getting at the *second* value of the result sequence requires
// reading from the first input sequence until the "bad" division
Assert.Throws<DivideByZeroException>(() => iterator.MoveNext());
}
}
public void TestIntersect() {
Func<bool> f = () => {
var a0 = new[] { 1, 2, 3, 3, 2, 1 };
var a1 = new[] { 2, 2 };
var r = a0.Intersect(a1).ToArray();
return r.Length == 1 && r[0] == 2;
};
this.Test(f, true);
}
public void Visit_visits_newly_exposes_contexts()
{
// Arrange
var fixture = new Fixture();
new RenderingContextCustomisation().Customize(fixture);
var contexts = Enumerable.Range(0,3).Select(x => fixture.Create<RenderingContext>()).ToArray();
RenderingContext
topContext = contexts[0],
secondContext = contexts[1],
thirdContext = contexts[2];
var handler = new Mock<IAttributeHandler>(MockBehavior.Strict);
handler
.Setup(x => x.Handle(topContext))
.Returns(new AttributeHandlingResult(new RenderingContext[0], true, new [] { secondContext }));
handler
.Setup(x => x.Handle(secondContext))
.Returns(new AttributeHandlingResult(new [] { thirdContext }, true));
var expectedElements = new [] { thirdContext };
var sut = new TalVisitor(handlers: new [] { handler.Object },
errorHandler: Mock.Of<IAttributeHandler>());
// Act
var result = sut.Visit(topContext);
// Assert
Assert.NotNull(result, "Result nullability");
Assert.IsTrue(expectedElements.Intersect(result).Count() == expectedElements.Count(),
"All expected elements contained");
Assert.IsTrue(result.Intersect(expectedElements).Count() == result.Count(),
"No unwanted elements contained");
}
public override Func<TwitterStatus, bool> GetBooleanValueProvider()
{
var supportedTypes = new[]
{
FilterExpressionType.Boolean,
FilterExpressionType.Numeric,
FilterExpressionType.String,
FilterExpressionType.Set,
};
var intersect = LeftValue.SupportedTypes.Intersect(RightValue.SupportedTypes);
if (intersect.Count() == 0)
throw new FilterQueryException("Value type is mismatched. Can't compare each other." + Environment.NewLine +
"Left argument is: " + LeftValue.SupportedTypes
.Select(t => t.ToString()).JoinString(", ") + Environment.NewLine +
"Right argument is: " + RightValue.SupportedTypes
.Select(t => t.ToString()).JoinString(", "),
this.ToQuery());
var type = supportedTypes.Intersect(intersect).First();
switch (type)
{
case FilterExpressionType.Boolean:
var lbp = LeftValue.GetBooleanValueProvider();
var rbp = RightValue.GetBooleanValueProvider();
return _ => lbp(_) == rbp(_);
case FilterExpressionType.Numeric:
var lnp = LeftValue.GetNumericValueProvider();
var rnp = RightValue.GetNumericValueProvider();
return _ => lnp(_) == rnp(_);
case FilterExpressionType.String:
var side = StringArgumentSide.None;
// determine side of argument
if (LeftValue is StringValue)
side = StringArgumentSide.Left;
else if (RightValue is StringValue)
side = StringArgumentSide.Right;
var lsp = LeftValue.GetStringValueProvider();
var rsp = RightValue.GetStringValueProvider();
return _ => StringMatch(lsp(_), rsp(_), side);
default:
throw new FilterQueryException("Unsupported type on equals :" + type.ToString(),
this.ToQuery());
}
}
