public void Test_MultipleDependency(bool filter, bool persistor, bool needOutput, bool delay, bool targetDelay)
{
bool selectorCalled = false;
bool filterCalled = false;
bool persistorCalled = false;
var target = new Dummy();
var targetResult = new Dummy();
Computation c_Target = null;
dependency.Selector = comp =>
{
selectorCalled = true;
var l = new List <object[]>();
var output = new object[] { target };
l.Add(output);
return(l);
};
if (filter)
{
dependency.Filter = comp =>
{
filterCalled = true;
return(true);
};
}
if (persistor)
{
dependency.Persistor = (p, t) =>
{
Assert.AreEqual("b", p);
Assert.IsNotNull(t);
var en = t.GetEnumerator();
Assert.IsTrue(en.MoveNext());
Assert.AreEqual(targetResult, en.Current);
Assert.IsFalse(en.MoveNext());
persistorCalled = true;
};
}
dependency.NeedOutput = needOutput;
if (delay)
{
c_Test.DelayOutput(new OutputDelay()
{
DelayLevel = 1
});
}
if (targetDelay)
{
c_Target = context.Computations.Add(ruleDependent, target);
c_Target.DelayOutput(new OutputDelay()
{
DelayLevel = 1
});
}
else
{
c_Target = context.Computations.Add(ruleDependent, target, targetResult);
}
dependency.HandleDependency(c_Test);
if (delay && needOutput)
{
Assert.IsFalse(selectorCalled, "The selector has been called too early");
Assert.IsFalse(filterCalled, "The filter has been called too early");
}
if (delay)
{
c_Test.InitializeOutput(c_Test.Output);
}
Assert.IsTrue(selectorCalled, "The selector has not been called");
if (filter)
{
Assert.IsTrue(filterCalled, "The filter has not been called");
}
Assert.AreEqual(3, context.Computations.Count);
if (persistor)
{
if (targetDelay)
{
Assert.IsFalse(persistorCalled, "The persistor has been called too early!");
c_Target.InitializeOutput(targetResult);
}
Assert.IsTrue(persistorCalled, "The persistor has not been called");
}
}
private void Test_SingleDependency(bool filter, bool persistor, bool needOutput, bool delay, bool targetDelay)
{
bool selectorCalled = false;
bool filterCalled = false;
bool persistorCalled = false;
Computation c = null;
var target = new Dummy();
var targetResult = new Dummy();
dependency.Selector = comp =>
{
selectorCalled = true;
return(new object[] { target });
};
if (filter)
{
dependency.Filter = comp =>
{
filterCalled = true;
return(true);
};
}
if (persistor)
{
dependency.Persistor = (p, t) =>
{
Assert.AreEqual("b", p);
Assert.AreEqual(targetResult, t);
persistorCalled = true;
};
}
dependency.NeedOutput = needOutput;
if (delay)
{
c_Test.DelayOutput(new OutputDelay()
{
DelayLevel = 1
});
}
if (targetDelay)
{
c = context.Computations.Add(ruleDependent, target);
c.DelayOutput(new OutputDelay()
{
DelayLevel = 1
});
}
else
{
targetResult = null;
}
dependency.HandleDependency(c_Test);
if (delay && needOutput)
{
Assert.IsFalse(selectorCalled, "The selector has been called too early");
Assert.IsFalse(filterCalled, "The filter has been called too early");
}
if (delay)
{
c_Test.InitializeOutput(c_Test.Output);
}
Assert.IsTrue(selectorCalled, "The selector has not been called");
if (filter)
{
Assert.IsTrue(filterCalled, "The filter has not been called");
}
Assert.AreEqual(3, context.Computations.Count);
if (persistor)
{
if (targetDelay)
{
Assert.IsFalse(persistorCalled, "The persistor has been called too early");
c.InitializeOutput(targetResult);
}
Assert.IsTrue(persistorCalled, "The persistor has not been called");
}
}