public void InitialBaselineValueIsUsedInInitialDeltaEvaluation(int initial)
{
var assignable = PipelineTestHelper.Assignable(initial);
var sut = new LazyDeltaPipelineStage <int, int>("", Extractor, assignable);
PipelineAssert.Value(sut, 0);
}
public void InputValueIsPassedThrough(int value)
{
var input = value.AsPipelineConstant();
var sut = new ThreadSafePipelineStage <int>(input);
PipelineAssert.Value(sut, value);
}
public void StagePassesPreviousValueThrough()
{
var previous = 10.AsPipelineConstant();
var exclusive = 100.AsPipelineConstant();
var sut = new MutuallyExclusivePipelineStage <int>(previous, exclusive);
PipelineAssert.Value(sut, previous.GetValue());
}
public void CacheRetrievesValueWhenInvalid()
{
var assignable = GetAssignable(1);
var cache = CreateCache(assignable);
Assert.IsFalse(cache.IsValid);
PipelineAssert.Value(cache, 1);
Assert.IsTrue(cache.IsValid);
}
public void NewValueIsPropagatedToDependentStages(int newValue)
{
var sut = Create(0);
var test = sut.AttachTestStage();
sut.SetValue(newValue);
PipelineAssert.Value(sut, newValue);
PipelineAssert.Value(test, newValue);
}
public void OutputIsTakenFromTheSelectedInput(int selected, int[] inputValues, int expected)
{
var select = AssignablePipelineStage.Create("Select", selected);
var inputs = CreateInputs(inputValues.Select(i => i.AsPipelineConstant()).ToArray());
var sut = new MultiplexingPipelineStage <int, int>("Name", select, inputs);
PipelineAssert.Value(sut, expected);
}
public void ExtractorIsUsedToCalculateNewDelta(int old, int @new, int expected)
{
var input = PipelineTestHelper.Assignable(old);
var sut = new LazyDeltaPipelineStage <int, int>("", Extractor, input);
var test = sut.AttachTestStage();
input.SetValue(@new);
test.AssertInvalidations(1);
PipelineAssert.Value(sut, expected);
}
public void CacheInvalidateSendsInvalidationToPipelineDependencies()
{
var cache = CreateCache(1.AsPipelineConstant());
PipelineAssert.Value(cache, 1);
var test = cache.AttachTestStage();
cache.InvalidateCache();
test.AssertInvalidations(1);
}
public void CacheInvalidateInvalidatesCache()
{
var assignable = GetAssignable(1);
var cache = CreateCache(assignable);
Assert.IsFalse(cache.IsValid);
PipelineAssert.Value(cache, 1);
Assert.IsTrue(cache.IsValid);
cache.InvalidateCache();
Assert.IsFalse(cache.IsValid);
}
public void ValueIsTakenFromCurrentSource()
{
var sut = new SourceSelectPipelineStage <string>("", "Hello, World?".AsPipelineConstant());
PipelineAssert.Value(sut, "Hello, World?");
sut.SetSource("Whazzup?".AsPipelineConstant());
PipelineAssert.Value(sut, "Whazzup?");
sut.SetSourceWithoutInvalidating("Yo!".AsPipelineConstant());
PipelineAssert.Value(sut, "Yo!");
}
public void CacheRetrievesNewValueFromPreviousStageWhenItIsInvalidated()
{
var assignable = GetAssignable(1);
var cache = CreateCache(assignable);
PipelineAssert.Value(cache, 1);
Assert.IsTrue(cache.IsValid);
assignable.SetValue(2);
Assert.IsFalse(cache.IsValid);
PipelineAssert.Value(cache, 2);
}
public void LinearPipelineIsInvalidatedInOrder()
{
var assignable = Assignable(0);
var t1 = assignable.AttachTestStage();
var t2 = PipelineOperations.Create("", a => a, t1).AttachTestStage();
var t3 = t2.WithCache().AttachTestStage();
var t4 = PipelineOperations.Create("", a => a, t3).AttachTestStage();
assignable.SetValue(1);
t1.AssertInvalidatedBefore(t2);
t2.AssertInvalidatedBefore(t3);
t3.AssertInvalidatedBefore(t4);
PipelineAssert.Value(t4, 1);
}
public void DataRetrievalAlwaysCallsTheSpecifiedFunctionOnGetValueCall()
{
var value = new ValueRepository(2);
var sut = new DataRetrievalPipelineStage <int>("name", value.GetValue);
PipelineAssert.Value(sut, value.Value);
Assert.AreEqual(1, value.NumCalls);
sut.GetValue();
sut.GetValue();
sut.GetValue();
sut.GetValue();
Assert.AreEqual(5, value.NumCalls);
}
public void NewValueAndChangedStageAtTheSameTimeHasTheIntendedReaction(PipelineSuspensionState initial, PipelineSuspensionState state, int invalidations)
{
var stateStage = Suspender(initial);
var value = new AssignablePipelineStage <int>("", 1);
var sut = new SuspendingPipelineStage <int>(value, stateStage);
var test = sut.AttachTestStage();
value.SetValueWithoutInvalidating(2);
stateStage.SetValueWithoutInvalidating(state);
PipelineCore.Invalidate(stateStage, value);
test.AssertInvalidations(invalidations);
PipelineAssert.Value(sut, 2);
}
public void SmallPipelineTest1()
{
var value1 = Assignable(1);
var value2 = Assignable(2);
var multiply = PipelineOperations.Create("", (a, b) => a * b, value1, value2).AttachTestStage();
var cache = multiply.WithCache().AttachTestStage();
var equality = cache.WithEqualityCheck().AttachTestStage();
multiply.AssertNotInvalidatedNorRetrieved();
cache.AssertNotInvalidatedNorRetrieved();
equality.AssertNotInvalidatedNorRetrieved();
var value = equality.GetValue();
multiply.AssertInvalidationsAndRetrievals(0, 1);
cache.AssertInvalidationsAndRetrievals(0, 1);
equality.AssertInvalidationsAndRetrievals(0, 1);
PipelineAssert.Value(multiply, 2);
PipelineAssert.Value(cache, 2);
PipelineAssert.Value(equality, 2);
multiply.AssertInvalidationsAndRetrievals(0, 2);
cache.AssertInvalidationsAndRetrievals(0, 3);
equality.AssertInvalidationsAndRetrievals(0, 2);
value1.SetValue(3);
multiply.AssertInvalidationsAndRetrievals(1, 3);
cache.AssertInvalidationsAndRetrievals(1, 4);
equality.AssertInvalidationsAndRetrievals(1, 2);
PipelineAssert.Value(equality, 6);
value1.SetValueWithoutInvalidating(6);
value2.SetValueWithoutInvalidating(1);
PipelineCore.Invalidate(value1, value2);
multiply.AssertInvalidationsAndRetrievals(2, 4);
cache.AssertInvalidationsAndRetrievals(2, 6);
equality.AssertInvalidationsAndRetrievals(1, 3);
PipelineAssert.Value(equality, 6);
GC.KeepAlive(equality);
}
public void SmallPipelineTest2()
{
var value1 = Assignable(2);
var value2 = Assignable(3);
var value3 = Assignable(-10);
var constant1 = 100.AsPipelineConstant();
var constant2 = (-1).AsPipelineConstant();
var op1 = PipelineOperations.Create("", (a, b) => a * a + b, value1, constant1);
var op2 = PipelineOperations.Create("", (a, b, c) => (a - b) * c + 1, value2, value1, constant2);
var result = PipelineOperations.Create("", (a, b, c) => a + b + c, op1, op2, value3);
PipelineAssert.Value(result, 94);
}
public void SettingANewInputForTheCurrentlySelectedInputCausesInvalidationAndGetsTheNewValue()
{
var select = AssignablePipelineStage.Create("Select", 0);
var input0 = AssignablePipelineStage.Create("Input 0", 0);
var input1 = AssignablePipelineStage.Create("Input 1", 0);
var newInput0 = AssignablePipelineStage.Create("Input 0 (new)", 100);
var inputs = CreateInputs(input0, input1);
var sut = new MultiplexingPipelineStage <int, int>("Name", select, inputs);
var test = sut.AttachTestStage();
sut.SetInput(0, newInput0);
test.AssertInvalidations(1);
PipelineAssert.Value(sut, 100);
}
public void CacheDoesNotRetrieveValueWhileValid()
{
var assignable = GetAssignable(1);
var test = assignable.AttachTestStage();
var cache = CreateCache(test);
Assert.IsFalse(cache.IsValid);
PipelineAssert.Value(cache, 1);
Assert.IsTrue(cache.IsValid);
test.AssertRetrievals(1);
PipelineAssert.Value(cache, 1);
Assert.IsTrue(cache.IsValid);
test.AssertRetrievals(1);
}
public void EachNewInvalidationPicksUpNewInformation()
{
var a = new AssignablePipelineStage <int>("", 1);
var sut = new PipelinePropagationInformationStage <int>("", inv => a.GetValue(), a.GetValue(), a);
var test = sut.AttachTestStage();
PipelineAssert.Value(sut, 1);
a.SetValue(2);
test.AssertInvalidations(1);
PipelineAssert.Value(sut, 2);
PipelineAssert.Value(sut, 2);
a.SetValue(5);
test.AssertInvalidations(2);
PipelineAssert.Value(sut, 5);
PipelineAssert.Value(sut, 5);
}
public void CacheIsInvalidatedOnInvalidation()
{
var assignable = GetAssignable(1);
var test = assignable.AttachTestStage();
var cache = CreateCache(test);
Assert.IsFalse(cache.IsValid);
PipelineAssert.Value(cache, 1);
Assert.IsTrue(cache.IsValid);
test.AssertRetrievals(1);
cache.Invalidate();
Assert.IsFalse(cache.IsValid);
PipelineAssert.Value(cache, 1);
Assert.IsTrue(cache.IsValid);
test.AssertRetrievals(2);
}
public void DetachableStagePassesPreviousStagesValueThrough(int i)
{
var sut = new DetachablePipelineStage <int>(i.AsPipelineConstant());
PipelineAssert.Value(sut, i);
}
public void InitialDeltaValueIsGivenBeforeAnyInvalidations(int value)
{
var sut = new DeltaPipelineStage <int, int>("", Extractor, 1.AsPipelineConstant(), value);
PipelineAssert.Value(sut, value);
}
public void InitialInformationIsGivenWhenNoInvalidationHasHappened()
{
var sut = new PipelinePropagationInformationStage <string>("", inv => "Hello, World!", "");
PipelineAssert.Value(sut, "");
}
public void TheConstantValueIsCorrectlyReflected(string value) => PipelineAssert.Value(new ConstantPipelineStage <string>(value), value);
public void EagerStagePassesThroughValue(int i)
{
var sut = new EagerPipelineStage <int>(i.AsPipelineConstant());
PipelineAssert.Value(sut, i);
}
