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); }