231 строка
8.2 KiB
C#
231 строка
8.2 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Reflection;
|
|
|
|
#if XAMCORE_2_0
|
|
using Foundation;
|
|
#else
|
|
using MonoTouch.Foundation;
|
|
#endif
|
|
using NUnit.Framework;
|
|
|
|
namespace MonoTouchFixtures.Foundation
|
|
{
|
|
[TestFixture]
|
|
[Preserve (AllMembers = true)]
|
|
[assembly: Preserve (typeof (NSExpression))]
|
|
public class NSExpressionTest
|
|
{
|
|
List<string> properties = new List<string> { "Block", "ConstantValue", "KeyPath", "Function",
|
|
"Variable", "Operand", "Arguments", "Collection", "Predicate", "LeftExpression",
|
|
"RightExpression", "TrueExpression", "FalseExpression"};
|
|
|
|
void TestProperties (NSExpression expression, List<string> availableProperties)
|
|
{
|
|
foreach (var pName in properties) {
|
|
var type = typeof (NSExpression);
|
|
var pInfo = type.GetProperty (pName);
|
|
if (!availableProperties.Contains (pName)) {
|
|
Assert.Throws<InvalidOperationException> (() => {
|
|
// we want to make sure that is an invalid operation exception and not
|
|
// a reflection one
|
|
try {
|
|
pInfo.GetValue (expression);
|
|
} catch (TargetInvocationException e) {
|
|
throw e.GetBaseException ();
|
|
}
|
|
}, $"Expressions of type '{expression.ExpressionType}' does not support the property '{pName}'");
|
|
} else {
|
|
Assert.DoesNotThrow (() => {
|
|
pInfo.GetValue (expression);
|
|
}, $"Expressions of type '{expression.ExpressionType}' do support the property '{pName}'");
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
[Test]
|
|
public void FromConstant ()
|
|
{
|
|
using (var expression = NSExpression.FromConstant (new NSString ("Foo")))
|
|
using (var result = expression.EvaluateWith (null, null) as NSString)
|
|
Assert.AreEqual ("Foo", result.ToString ());
|
|
}
|
|
|
|
[Test]
|
|
public void FromKeyPath ()
|
|
{
|
|
using (var expression = NSExpression.FromKeyPath ("value"))
|
|
using (var result = expression.EvaluateWith (null, null) as NSString)
|
|
Assert.IsNull (result);
|
|
}
|
|
|
|
[Test]
|
|
public void FromFunctionTest ()
|
|
{
|
|
using (var expression = NSExpression.FromFunction ((o, e, c) => { return new NSString ("Foo"); }, new NSExpression [] { }))
|
|
using (var result = expression.EvaluateWith (null, null) as NSString)
|
|
Assert.AreEqual ("Foo", result.ToString ());
|
|
}
|
|
|
|
[Test]
|
|
public void FromFormatWithArgsTest ()
|
|
{
|
|
using (var expression = NSExpression.FromFormat ("%f*%f", new NSObject [] { new NSNumber (2.0), new NSNumber (2.0) }))
|
|
using (var result = expression.EvaluateWith (null, null) as NSNumber)
|
|
Assert.AreEqual (4.0, result.DoubleValue);
|
|
}
|
|
|
|
[Test]
|
|
public void FromFormatWithNoArgsTest ()
|
|
{
|
|
using (var expression = NSExpression.FromFormat ("2*2"))
|
|
using (var result = expression.EvaluateWith (null, null) as NSNumber)
|
|
Assert.AreEqual (4.0, result.DoubleValue);
|
|
}
|
|
|
|
[Test]
|
|
public void FromFormatConstant ()
|
|
{
|
|
using (var expression = NSExpression.FromFormat ("2"))
|
|
using (var result = expression.EvaluateWith (null, null) as NSNumber)
|
|
Assert.AreEqual (2, result.DoubleValue);
|
|
}
|
|
|
|
[Test]
|
|
public void AggregatePropertiesTest ()
|
|
{
|
|
var availableProperties = new List<string> { "Collection" };
|
|
using (var lower = NSExpression.FromConstant (new NSNumber (0)))
|
|
using (var upper = NSExpression.FromConstant (new NSNumber (5)))
|
|
using (var expression = NSExpression.FromAggregate (new NSExpression [] { lower, upper })) {
|
|
Assert.AreEqual (NSExpressionType.NSAggregate, expression.ExpressionType);
|
|
TestProperties (expression, availableProperties);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void UnionSetPropertiesTest ()
|
|
{
|
|
var availableProperties = new List<string> { "LeftExpression", "RightExpression"};
|
|
|
|
using (var llower = NSExpression.FromConstant (new NSNumber (0)))
|
|
using (var lupper = NSExpression.FromConstant (new NSNumber (5)))
|
|
using (var lh = NSExpression.FromAggregate (new NSExpression [] { llower, lupper }))
|
|
using (var rlower = NSExpression.FromConstant (new NSNumber (10)))
|
|
using (var rupper = NSExpression.FromConstant (new NSNumber (50)))
|
|
using (var rh = NSExpression.FromAggregate (new NSExpression [] { rlower, rupper }))
|
|
using (var expression = NSExpression.FromUnionSet (lh, rh)) {
|
|
Assert.AreEqual (NSExpressionType.UnionSet, expression.ExpressionType);
|
|
TestProperties (expression, availableProperties);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void IntersectSetPropertiesTest ()
|
|
{
|
|
var availableProperties = new List<string> { "LeftExpression", "RightExpression" };
|
|
|
|
using (var llower = NSExpression.FromConstant (new NSNumber (0)))
|
|
using (var lupper = NSExpression.FromConstant (new NSNumber (5)))
|
|
using (var lh = NSExpression.FromAggregate (new NSExpression [] { llower, lupper }))
|
|
using (var rlower = NSExpression.FromConstant (new NSNumber (10)))
|
|
using (var rupper = NSExpression.FromConstant (new NSNumber (50)))
|
|
using (var rh = NSExpression.FromAggregate (new NSExpression [] { rlower, rupper }))
|
|
using (var expression = NSExpression.FromIntersectSet (lh, rh)) {
|
|
Assert.AreEqual (NSExpressionType.IntersectSet, expression.ExpressionType);
|
|
TestProperties (expression, availableProperties);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void MinusSetPropertiesTest ()
|
|
{
|
|
var availableProperties = new List<string> { "LeftExpression", "RightExpression" };
|
|
|
|
using (var llower = NSExpression.FromConstant (new NSNumber (0)))
|
|
using (var lupper = NSExpression.FromConstant (new NSNumber (5)))
|
|
using (var lh = NSExpression.FromAggregate (new NSExpression [] { llower, lupper }))
|
|
using (var rlower = NSExpression.FromConstant (new NSNumber (10)))
|
|
using (var rupper = NSExpression.FromConstant (new NSNumber (50)))
|
|
using (var rh = NSExpression.FromAggregate (new NSExpression [] { rlower, rupper }))
|
|
using (var expression = NSExpression.FromMinusSet (lh, rh)) {
|
|
Assert.AreEqual (NSExpressionType.MinusSet, expression.ExpressionType);
|
|
TestProperties (expression, availableProperties);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void ConstantPropertiesTest ()
|
|
{
|
|
var availableProperties = new List<string> { "ConstantValue"};
|
|
using (var expression = NSExpression.FromFormat ("2")) {
|
|
Assert.AreEqual (NSExpressionType.ConstantValue, expression.ExpressionType);
|
|
TestProperties (expression, availableProperties);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void VariablePropertiesTest ()
|
|
{
|
|
var availableProperties = new List<string> { "Variable" };
|
|
using (var expression = NSExpression.FromVariable ("Variable")) {
|
|
Assert.AreEqual (NSExpressionType.Variable, expression.ExpressionType);
|
|
TestProperties (expression, availableProperties);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void KeyPathPropertiesTest ()
|
|
{
|
|
var availableProperties = new List<string> { "KeyPath", "Operand", "Arguments" };
|
|
using (var expression = NSExpression.FromKeyPath ("value")) {
|
|
Assert.AreEqual (NSExpressionType.KeyPath, expression.ExpressionType);
|
|
TestProperties (expression, availableProperties);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void FunctionPropertiesTest ()
|
|
{
|
|
var availableProperties = new List<string> { "Function", "Operand", "Arguments"};
|
|
using (var expression = NSExpression.FromFormat ("2*2")) {
|
|
Assert.AreEqual (NSExpressionType.Function, expression.ExpressionType);
|
|
TestProperties (expression, availableProperties);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void BlockPropertiesTest ()
|
|
{
|
|
var availableProperties = new List<string> { "Block", "Arguments"};
|
|
using (var expression = NSExpression.FromFunction ((o, e, c) => { return new NSString ("Foo"); }, new NSExpression [] { })) {
|
|
Assert.AreEqual (NSExpressionType.Block, expression.ExpressionType);
|
|
TestProperties (expression, availableProperties);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void EvaluatedObjectPropertiesTest ()
|
|
{
|
|
var availableProperties = new List<string> { };
|
|
var mySearchKey = new NSString ("James");
|
|
using (var predicate = NSPredicate.FromFormat ("ANY employees.firstName like 'Matthew'") as NSComparisonPredicate)
|
|
using (var expression = predicate.LeftExpression.Operand) { // NSExpressionType.EvaluatedObject;
|
|
Assert.AreEqual (NSExpressionType.EvaluatedObject, expression.ExpressionType);
|
|
TestProperties (expression, availableProperties);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void AnyKeyPropertiesTest ()
|
|
{
|
|
var availableProperties = new List<string> { };
|
|
using (var expression = NSExpression.FromAnyKey ()) {
|
|
Assert.AreEqual (NSExpressionType.AnyKey, expression.ExpressionType);
|
|
TestProperties (expression, availableProperties);
|
|
}
|
|
}
|
|
}
|
|
}
|