public void DisjoinsCriteria()
{
var spec1 = new IntegerPredicate(i => i == 0);
var spec2 = new IntegerPredicate(i => i > 0);
var criteria1 = spec1.Criteria;
var criteria2 = spec2.Criteria;
var disjoinedSpec = new ExclusiveDisjunction<int>(spec1, spec2);
var disjoinedCriteria = disjoinedSpec.Criteria;
Assert.That(disjoinedCriteria.Body, Is.AssignableTo<BinaryExpression>());
var binary = (BinaryExpression)disjoinedCriteria.Body;
Assert.That(binary.NodeType, Is.EqualTo(ExpressionType.ExclusiveOr));
Assert.That(binary.Conversion, Is.Null);
Assert.That(binary.Left.ToString(), Is.EqualTo(criteria1.Body.ToString()));
Assert.That(binary.Right.ToString(), Is.EqualTo(criteria2.Body.ToString()));
Assert.That(binary.Method, Is.Null);
Assert.That(binary.IsLifted, Is.False);
Assert.That(binary.IsLiftedToNull, Is.False);
ExpressionWriter.Write(disjoinedCriteria);
}
public void SetUp()
{
_lowerValue = int.MinValue + 1;
_upperValue = int.MaxValue - 1;
_rows = new List <Row>();
_column = new ColumnBuilder().Build();
_predicate = new IntegerPredicate();
}
public void SelectsExclusiveDisjunction()
{
var spec1 = new IntegerPredicate(i => i > 1);
var spec2 = new IntegerPredicate(i => i > 0);
var disjoinedSpec = new ExclusiveDisjunction<int>(spec1, spec2);
Assert.That(disjoinedSpec.IsSatisfiedBy(2), Is.False);
Assert.That(disjoinedSpec.IsSatisfiedBy(1), Is.True);
Assert.That(disjoinedSpec.IsSatisfiedBy(-1), Is.False);
}
public void SelectsConjunction()
{
var spec1 = new IntegerGreaterThanZero();
var spec2 = new IntegerPredicate(i => i > -1);
var conjoinedSpec = new Conjunction<int>(spec1, spec2);
Assert.That(conjoinedSpec.IsSatisfiedBy(1), Is.True);
Assert.That(conjoinedSpec.IsSatisfiedBy(0), Is.False);
Assert.That(conjoinedSpec.IsSatisfiedBy(-1), Is.False);
}
public void NegatesCriteria()
{
var spec = new IntegerPredicate(i => i == 0);
var criteria = spec.Criteria;
var negatedSpec = new Negation<int>(spec);
var negatedCriteria = negatedSpec.Criteria;
Assert.That(negatedCriteria.Body, Is.TypeOf<UnaryExpression>());
var unary = (UnaryExpression)negatedCriteria.Body;
Assert.That(unary.NodeType, Is.EqualTo(ExpressionType.Not));
Assert.That(unary.Operand, Is.EqualTo(criteria.Body));
Assert.That(unary.Method, Is.Null);
Assert.That(unary.IsLifted, Is.False);
Assert.That(unary.IsLiftedToNull, Is.False);
ExpressionWriter.Write(negatedCriteria);
}
private void InstallLocalPredicates()
{
// Input/Output
_predicates["write/1"] = new WritePredicate();
_predicates["writeln/1"] = new WriteLnPredicate();
_predicates["nl/0"] = new NlPredicate();
_predicates["get0/1"] = new Get0Predicate();
_predicates["skip/1"] = new SkipPredicate();
_predicates["put/1"] = new PutPredicate();
// Comparison, numeric
_predicates["=\\=/2"] = new NotEqualsPredicate();
_predicates["=:=/2"] = new EqualsPredicate();
_predicates[">=/2"] = new GreaterThanEqualPredicate();
_predicates[">/2"] = new GreaterThanPredicate();
_predicates["=</2"] = new LessThanEqualPredicate();
_predicates["</2"] = new LessThanPredicate();
// Control
_predicates["call/1"] = new CallPredicate();
// Equality
_predicates["=/2"] = new UnifyPredicate();
_predicates["\\=/2"] = new NotUnifiablePredicate();
// Meta
_predicates["is/2"] = new IsPredicate();
_predicates["atom/1"] = new AtomPredicate();
_predicates["bound/1"] = new BoundPredicate();
_predicates["char/1"] = new CharPredicate();
_predicates["free/1"] = new FreePredicate();
_predicates["integer/1"] = new IntegerPredicate();
_predicates["nonvar/1"] = new NonVarPredicate();
_predicates["var/1"] = new VarPredicate();
// Object-Oriented Programming
_predicates["object/2"] = new object_2();
_predicates["invoke/3"] = new invoke_2();
_predicates["get_property/3"] = new get_property_3();
// .NET Reflection
}
public void ExistentiallyQuantifiesCriteria()
{
var spec = new IntegerPredicate(i => i == 0);
var criteria = spec.Criteria;
var anySpec = new ExistentialQuantification<int>(spec);
var anyCriteria = anySpec.Criteria;
Assert.That(anyCriteria.Body, Is.AssignableTo<MethodCallExpression>());
var call = (MethodCallExpression)anyCriteria.Body;
Assert.That(call.NodeType, Is.EqualTo(ExpressionType.Call));
Assert.That(call.Method, Is.EqualTo(typeof(Enumerable).GetMethods().Where(m => m.Name == "Any").ToArray()[1].MakeGenericMethod(new[] { typeof(int) })));
Assert.That(call.Object, Is.Null);
Assert.That(call.Arguments, Has.Count.EqualTo(2));
Assert.That(call.Arguments[0], Is.AssignableTo<ParameterExpression>());
Assert.That(call.Arguments[1], Is.EqualTo(criteria));
ExpressionWriter.Write(anyCriteria);
}
public void UniversallyQuantifiesCriteria()
{
var spec = new IntegerPredicate(i => i == 0);
var criteria = spec.Criteria;
var allSpec = new UniversalQuantification<int>(spec);
var allCriteria = allSpec.Criteria;
Assert.That(allCriteria.Body, Is.AssignableTo<MethodCallExpression>());
var call = (MethodCallExpression)allCriteria.Body;
Assert.That(call.NodeType, Is.EqualTo(ExpressionType.Call));
Assert.That(call.Method, Is.EqualTo(typeof(Enumerable).GetMethod("All").MakeGenericMethod(new[] { typeof(int) })));
Assert.That(call.Object, Is.Null);
Assert.That(call.Arguments, Has.Count.EqualTo(2));
Assert.That(call.Arguments[0], Is.AssignableTo<ParameterExpression>());
Assert.That(call.Arguments[1], Is.EqualTo(criteria));
ExpressionWriter.Write(allCriteria);
}
public void Criteria()
{
var spec = new IntegerPredicate(i => i == 0);
var criteria = spec.Criteria;
var proposition = new Proposition<int>(criteria);
var proposedCriteria = proposition.Criteria;
Assert.That(proposedCriteria.Body, Is.AssignableTo<BinaryExpression>());
var binary = (BinaryExpression)proposedCriteria.Body;
Assert.That(binary.NodeType, Is.EqualTo(ExpressionType.Equal));
Assert.That(binary.Method, Is.Null);
Assert.That(binary.IsLifted, Is.False);
Assert.That(binary.IsLiftedToNull, Is.False);
Assert.That(binary.Conversion, Is.Null);
Assert.That(binary.Left, Is.AssignableTo<ParameterExpression>());
Assert.That(binary.Right, Is.TypeOf<ConstantExpression>().With.Property("Value").EqualTo(0));
ExpressionWriter.Write(proposedCriteria);
}
public void ConvertsCriteria()
{
var spec = new IntegerPredicate(i => i == 0);
var converter = (Expression<Func<double, int>>)(d => Math.Sign(d));
var criteria = spec.Criteria;
var convertedSpec = new Conversion<double, int>(spec, converter);
var convertedCriteria = convertedSpec.Criteria;
Assert.That(convertedCriteria.Body, Is.AssignableTo<BinaryExpression>());
var binary = (BinaryExpression)convertedCriteria.Body;
Assert.That(binary.NodeType, Is.EqualTo(ExpressionType.Equal));
Assert.That(binary.Left, Is.EqualTo(converter.Body));
Assert.That(binary.Right, Is.EqualTo(((BinaryExpression)criteria.Body).Right));
Assert.That(binary.Method, Is.Null);
Assert.That(binary.IsLifted, Is.False);
Assert.That(binary.IsLiftedToNull, Is.False);
Assert.That(binary.Conversion, Is.Null);
ExpressionWriter.Write(convertedCriteria);
}
public void UniquelyQuantifiesCriteria()
{
var spec = new IntegerPredicate(i => i == 0);
var criteria = spec.Criteria;
var singleSpec = new UniqueQuantification<int>(spec);
var singleCriteria = singleSpec.Criteria;
Assert.That(singleCriteria.Body, Is.AssignableTo<BinaryExpression>());
var binary = (BinaryExpression)singleCriteria.Body;
Assert.That(binary.Conversion, Is.Null);
Assert.That(binary.IsLifted, Is.False);
Assert.That(binary.IsLiftedToNull, Is.False);
Assert.That(binary.Method, Is.Null);
Assert.That(binary.NodeType, Is.EqualTo(ExpressionType.Equal));
Assert.That(binary.Type, Is.EqualTo(typeof(bool)));
Assert.That(binary.Left, Is.AssignableTo<MethodCallExpression>());
Assert.That(binary.Right, Is.TypeOf<ConstantExpression>());
var call = (MethodCallExpression)binary.Left;
var constant = (ConstantExpression)binary.Right;
Assert.That(call.NodeType, Is.EqualTo(ExpressionType.Call));
Assert.That(call.Method, Is.EqualTo(typeof(Enumerable).GetMethods().Where(m => m.Name == "Count").ToArray()[1].MakeGenericMethod(new[] { typeof(int) })));
Assert.That(call.Object, Is.Null);
Assert.That(call.Arguments, Has.Count.EqualTo(2));
Assert.That(call.Arguments[0], Is.AssignableTo<ParameterExpression>());
Assert.That(call.Arguments[1], Is.EqualTo(criteria));
Assert.That(constant.Value, Is.EqualTo(1));
ExpressionWriter.Write(singleCriteria);
}
