public void ObjectFaultPropagation()
{
var numbers = new ObservableCollection <int>(Enumerable.Range(0, 10));
var otherNumbers = new ObservableCollection <int>(Enumerable.Range(0, 10));
var john = TestPerson.CreateJohn();
using (var expr = ActiveExpression.Create((p1, p2, p3) => (p3.Name.Length == 0 ? p1 : p2)[0], numbers, otherNumbers, john))
{
Assert.IsNull(expr.Fault);
john.Name = null;
Assert.IsNotNull(expr.Fault);
john.Name = "John";
Assert.IsNull(expr.Fault);
}
}
public void Equals()
{
var john = TestPerson.CreateJohn();
var emily = TestPerson.CreateEmily();
using (var expr1 = ActiveExpression.Create(p1 => p1.Name ?? string.Empty, john))
using (var expr2 = ActiveExpression.Create(p1 => p1.Name ?? string.Empty, john))
using (var expr3 = ActiveExpression.Create(p1 => p1.Name ?? "Another String", john))
using (var expr4 = ActiveExpression.Create(p1 => p1.Name ?? string.Empty, emily))
{
Assert.IsTrue(expr1.Equals(expr2));
Assert.IsFalse(expr1.Equals(expr3));
Assert.IsFalse(expr1.Equals(expr4));
}
}
public void Equals()
{
var john = TestPerson.CreateJohn();
var emily = TestPerson.CreateEmily();
using (var expr1 = ActiveExpression.Create((p1, p2) => CombinePeople(p1, p2), john, emily))
using (var expr2 = ActiveExpression.Create((p1, p2) => CombinePeople(p1, p2), john, emily))
using (var expr3 = ActiveExpression.Create((p1, p2) => ReversedCombinePeople(p1, p2), john, emily))
using (var expr4 = ActiveExpression.Create((p1, p2) => CombinePeople(p1, p2), emily, john))
{
Assert.IsTrue(expr1.Equals(expr2));
Assert.IsFalse(expr1.Equals(expr3));
Assert.IsFalse(expr1.Equals(expr4));
}
}
public void Equals()
{
var john = TestPerson.CreateJohn();
var emily = TestPerson.CreateEmily();
using (var expr1 = ActiveExpression.Create((p1, p2) => p1.Name.Length > 0 ? p1.Name : p2.Name, john, emily))
using (var expr2 = ActiveExpression.Create((p1, p2) => p1.Name.Length > 0 ? p1.Name : p2.Name, john, emily))
using (var expr3 = ActiveExpression.Create((p1, p2) => p2.Name.Length > 0 ? p2.Name : p1.Name, john, emily))
using (var expr4 = ActiveExpression.Create((p1, p2) => p1.Name.Length > 0 ? p1.Name : p2.Name, emily, john))
{
Assert.IsTrue(expr1.Equals(expr2));
Assert.IsFalse(expr1.Equals(expr3));
Assert.IsFalse(expr1.Equals(expr4));
}
}
public void Equals()
{
var john = TestPerson.CreateJohn();
var emily = TestPerson.CreateEmily();
using (var expr1 = ActiveExpression.Create(p1 => p1.Name != null || p1.Name.Length > 0, john))
using (var expr2 = ActiveExpression.Create(p1 => p1.Name != null || p1.Name.Length > 0, john))
using (var expr3 = ActiveExpression.Create(p1 => p1.Name == null && p1.Name.Length == 0, john))
using (var expr4 = ActiveExpression.Create(p1 => p1.Name != null || p1.Name.Length > 0, emily))
{
Assert.IsTrue(expr1.Equals(expr2));
Assert.IsFalse(expr1.Equals(expr3));
Assert.IsFalse(expr1.Equals(expr4));
}
}
public void FaultPropagation()
{
var john = TestPerson.CreateJohn();
var emily = TestPerson.CreateEmily();
using (var expr = ActiveExpression.Create((p1, p2) => p1.Name.ToString() ?? p2.Name.ToString(), john, emily))
{
Assert.IsNull(expr.Fault);
john.Name = null;
Assert.IsNotNull(expr.Fault);
emily.Name = null;
john.Name = "John";
Assert.IsNull(expr.Fault);
}
}
public void Inequality()
{
var john = TestPerson.CreateJohn();
var emily = TestPerson.CreateEmily();
using (var expr1 = ActiveExpression.Create(p1 => p1.Name.Length + 2, john))
using (var expr2 = ActiveExpression.Create(p1 => p1.Name.Length + 2, john))
using (var expr3 = ActiveExpression.Create(p1 => p1.Name.Length - 2, john))
using (var expr4 = ActiveExpression.Create(p1 => p1.Name.Length + 2, emily))
{
Assert.IsFalse(expr1 != expr2);
Assert.IsTrue(expr1 != expr3);
Assert.IsTrue(expr1 != expr4);
}
}
public void ThreeArgumentInequality()
{
var john = TestPerson.CreateJohn();
var emily = TestPerson.CreateEmily();
var charles = new TestPerson("Charles");
using (var expr1 = ActiveExpression.Create((a, b, c) => a + b + c, john, emily, charles))
using (var expr2 = ActiveExpression.Create((a, b, c) => a + b + c, john, emily, charles))
using (var expr3 = ActiveExpression.Create((a, b, c) => a + c + b, john, emily, charles))
using (var expr4 = ActiveExpression.Create((a, b, c) => a + b + c, charles, emily, john))
{
Assert.IsFalse(expr1 != expr2);
Assert.IsTrue(expr1 != expr3);
Assert.IsTrue(expr1 != expr4);
}
}
public void FaultPropagation()
{
var john = TestPerson.CreateJohn();
var emily = TestPerson.CreateEmily();
using (var expr = ActiveExpression.Create((p1, p2) => p1.Name.Length > 0 || p2.Name.Length > 0, john, emily))
{
Assert.IsNull(expr.Fault);
john.Name = null;
Assert.IsNotNull(expr.Fault);
emily.Name = null;
john.Name = string.Empty;
Assert.IsNotNull(expr.Fault);
emily.Name = "Emily";
Assert.IsNull(expr.Fault);
}
}
public void ObjectChanges()
{
var john = TestPerson.CreateJohn();
var men = new ObservableCollection <TestPerson> {
john
};
var emily = TestPerson.CreateEmily();
var women = new ObservableCollection <TestPerson> {
emily
};
using (var expr = ActiveExpression.Create((p1, p2) => (p1.Count > 0 ? p1 : p2)[0], men, women))
{
Assert.AreSame(john, expr.Value);
men.Clear();
Assert.AreSame(emily, expr.Value);
}
}
public void PropertyChanges()
{
var john = TestPerson.CreateJohn();
var values = new BlockingCollection <int>();
using (var expr = ActiveExpression.Create(p1 => - p1.Name.Length, john))
{
var disconnect = expr.OnPropertyChanged(ae => ae.Value, value => values.Add(value));
values.Add(expr.Value);
john.Name = "J";
john.Name = "John";
john.Name = "Jon";
john.Name = "Jhn";
john.Name = string.Empty;
disconnect();
}
Assert.IsTrue(new int[] { -4, -1, -4, -3, 0 }.SequenceEqual(values));
}
public void ArgumentChanges()
{
var reversedNumbersList = Enumerable.Range(1, 10).Reverse().ToImmutableList();
var john = TestPerson.CreateJohn();
var values = new BlockingCollection <int>();
using (var expr = ActiveExpression.Create((p1, p2) => p1[p2.Name.Length], reversedNumbersList, john))
{
var disconnect = expr.OnPropertyChanged(ae => ae.Value, value => values.Add(value));
values.Add(expr.Value);
john.Name = "J";
john.Name = "Joh";
john.Name = string.Empty;
john.Name = "Johnny";
john.Name = "John";
disconnect();
}
Assert.IsTrue(new int[] { 6, 9, 7, 10, 4, 6 }.SequenceEqual(values));
}
public void FaultPropagationIfTrue()
{
var john = TestPerson.CreateJohn();
john.Name = null;
var emily = TestPerson.CreateEmily();
emily.Name = null;
using (var expr = ActiveExpression.Create((p1, p2) => p2.Name == null ? p1.Name.Length : p2.Name.Length, john, emily))
{
Assert.IsNotNull(expr.Fault);
emily.Name = "Emily";
Assert.IsNull(expr.Fault);
emily.Name = null;
Assert.IsNotNull(expr.Fault);
john.Name = "John";
Assert.IsNull(expr.Fault);
}
}
public void PropertyChanges()
{
var john = TestPerson.CreateJohn();
var emily = TestPerson.CreateEmily();
var values = new BlockingCollection <int>();
using (var expr = ActiveExpression.Create((p1, p2) => p1.Name.Length + p2.Name.Length, john, emily))
{
var disconnect = expr.OnPropertyChanged(ae => ae.Value, value => values.Add(value));
values.Add(expr.Value);
john.Name = "J";
emily.Name = "E";
john.Name = "John";
john.Name = "J";
emily.Name = "Emily";
emily.Name = "E";
disconnect();
}
Assert.IsTrue(new int[] { 9, 6, 2, 5, 2, 6, 2 }.SequenceEqual(values));
}
public void Inequality()
{
var john = TestPerson.CreateJohn();
var men = new List <TestPerson> {
john, null
};
var emily = TestPerson.CreateEmily();
var women = new List <TestPerson> {
emily, null
};
using (var expr1 = ActiveExpression.Create(p1 => p1[0], men))
using (var expr2 = ActiveExpression.Create(p1 => p1[0], men))
using (var expr3 = ActiveExpression.Create(p1 => p1[1], men))
using (var expr4 = ActiveExpression.Create(p1 => p1[0], women))
{
Assert.IsFalse(expr1 != expr2);
Assert.IsTrue(expr1 != expr3);
Assert.IsTrue(expr1 != expr4);
}
}
public void PropertyChanges()
{
var john = TestPerson.CreateJohn();
var emily = TestPerson.CreateEmily();
var values = new BlockingCollection <string>();
using (var expr = ActiveExpression.Create((p1, p2) => string.IsNullOrEmpty(p1.Name) ? p2.Name : p1.Name, john, emily))
{
var disconnect = expr.OnPropertyChanged(ae => ae.Value, value => values.Add(value));
values.Add(expr.Value);
john.Name = "J";
john.Name = "John";
john.Name = null;
emily.Name = "E";
emily.Name = "Emily";
emily.Name = null;
emily.Name = "Emily";
john.Name = "John";
disconnect();
}
Assert.IsTrue(new string[] { "John", "J", "John", "Emily", "E", "Emily", null, "Emily", "John" }.SequenceEqual(values));
}
public void ThreeArgumentValueChanges()
{
var john = TestPerson.CreateJohn();
var emily = TestPerson.CreateEmily();
var charles = new TestPerson("Charles");
var values = new BlockingCollection <string>();
using (var expr = ActiveExpression.Create((a, b, c) => $"{a.Name} {b.Name} {c.Name}", john, emily, charles))
{
var disconnect = expr.OnPropertyChanged(ae => ae.Value, value => values.Add(value));
values.Add(expr.Value);
john.Name = "J";
emily.Name = "E";
charles.Name = "C";
disconnect();
}
Assert.IsTrue(new string[]
{
"John Emily Charles",
"J Emily Charles",
"J E Charles",
"J E C"
}.SequenceEqual(values));
}
TestPerson ReversedCombinePeople(TestPerson a, TestPerson b) => new TestPerson
{
Name = $"{b.Name} {a.Name}"
};
TestPerson CombinePeople(TestPerson a, TestPerson b) => new TestPerson
{
Name = $"{a.Name} {b.Name}"
};
