public void SeveralExpressionsInSingleCallToByEvaluating(
IEvaluationEngine engine,
int answer)
{
"establish an evaluation engine with expression aggregator"._(() =>
{
engine = new EvaluationEngine();
engine.Solve <HowManyFruitsAreThere, int>()
.AggregateWithExpressionAggregator(0, (aggregate, value) => aggregate + value);
});
"when defining several expressions with a single call to by evaluating"._(() =>
{
engine.Solve <HowManyFruitsAreThere, int>()
.ByEvaluating(q => new[] { new FruitCountExpression {
NumberOfFruits = 2
}, new FruitCountExpression {
NumberOfFruits = 3
} });
answer = engine.Answer(new HowManyFruitsAreThere());
});
"it should evaluate all expressions for the question"._(() =>
{
answer.Should().Be(5);
});
}
public void SeveralCallsWithSingleExpressionToSolve(
IEvaluationEngine engine,
int answer)
{
"establish an evaluation engine with expression aggregator"._(() =>
{
engine = new EvaluationEngine();
engine.Solve <HowManyFruitsAreThere, int>()
.AggregateWithExpressionAggregator(0, (aggregate, value) => aggregate + value);
});
"when defining several expressions with individual calls to solve"._(() =>
{
engine.Solve <HowManyFruitsAreThere, int>()
.ByEvaluating(q => new FruitCountExpression {
NumberOfFruits = 2
});
engine.Solve <HowManyFruitsAreThere, int>()
.ByEvaluating(q => new FruitCountExpression {
NumberOfFruits = 3
});
answer = engine.Answer(new HowManyFruitsAreThere());
});
"it should evaluate all expressions for the question"._(() =>
{
answer.Should().Be(5);
});
}
public void AggregatorStrategy(
IEvaluationEngine engine,
IAggregator <int, int, Missing> aggregator,
int answer)
{
"establish an evaluatione engine"._(() =>
{
engine = new EvaluationEngine();
aggregator = A.Fake <IAggregator <int, int, Missing> >();
A.CallTo(() => aggregator.Aggregate(A <IEnumerable <IExpression <int, Missing> > > ._, Missing.Value, A <Context> ._)).Returns(TheAnswer);
});
"when defining aggregator strategy"._(() =>
{
engine.Solve <HowManyFruitsAreThere, int>()
.WithAggregatorStrategy()
.AggregateWith(aggregator);
answer = engine.Answer(new HowManyFruitsAreThere());
});
"it should use aggregator strategy to answer the question"._(() =>
{
answer.Should().Be(TheAnswer);
});
}
public void LoadModule(
IEvaluationEngine testee)
{
"establish an evaluation engine"._(() =>
{
testee = new EvaluationEngine();
testee.Solve <HowManyFruitsAreThere, int>()
.AggregateWithExpressionAggregator(0, (aggregate, value) => aggregate + value)
.ByEvaluating(q => new FruitCountExpression {
Kind = "Apples", NumberOfFruits = NumberOfApples
});
});
"when loading a module into an evaluation engine"._(() =>
{
IEvaluationEngineModule module = new FruitModule();
testee.Load(module);
});
"it should use definitions from module to answer questions too"._(() =>
{
int answer = testee.Answer(new HowManyFruitsAreThere());
answer.Should().Be(NumberOfApples + NumberOfAnanas);
});
}
public void ParameterlessQuestion(
IEvaluationEngine evaluationEngine,
int answer)
{
const int NumberOfApples = 3;
const int NumberOfBananas = 2;
"establish an evaluation engine"._(() =>
{
evaluationEngine = new EvaluationEngine();
});
"when calling answer on evaluation engine"._(() =>
{
evaluationEngine.Solve <HowManyFruitsAreThere, int>()
.AggregateWithExpressionAggregator(0, (aggregate, value) => aggregate + value)
.ByEvaluating(q => new FruitCountExpression {
Kind = "Apples", NumberOfFruits = NumberOfApples
})
.ByEvaluating(q => new FruitCountExpression {
Kind = "Bananas", NumberOfFruits = NumberOfBananas
});
answer = evaluationEngine.Answer(new HowManyFruitsAreThere());
});
"it should aggregate the result of all expressions into a single result"._(() =>
{
answer.Should().Be(NumberOfApples + NumberOfBananas);
});
}
public void AskingParent(
string parentAnswer,
IEvaluationEngine parentEngine,
IEvaluationEngine childEngine)
{
"establish an hierarchical evaluation engine"._(() =>
{
parentEngine = new EvaluationEngine();
childEngine = new EvaluationEngine(parentEngine);
parentEngine.Solve <Question, string>()
.AggregateWithExpressionAggregator(ParentAggregator, (aggregate, value) => aggregate + value)
.ByEvaluating((q, p) => ParentExpression);
childEngine.Solve <Question, string>()
.AggregateWithExpressionAggregator(ChildAggregator, (aggregate, value) => aggregate + value)
.ByEvaluating((q, p) => ChildExpression);
});
"when calling answer on a parent evaluation engine"._(() =>
{
parentAnswer = parentEngine.Answer(new Question());
});
"it should use parent aggregator"._(() =>
{
parentAnswer.Should().Contain(ParentAggregator);
});
"it should use expressions only from parent"._(() =>
{
parentAnswer.Should().NotContain(ChildExpression);
});
}
public void ParametrizedQuestion()
{
const string Parameter = "hello world of questions and answers.";
IEvaluationEngine evaluationEngine = null;
WordCountExpression expression = null;
"establish"._(() =>
{
evaluationEngine = new EvaluationEngine();
expression = new WordCountExpression();
evaluationEngine.Solve <HowManyWordsDoesThisTextHave, int, string>()
.AggregateWithSingleExpressionAggregator()
.ByEvaluating(q => expression);
});
"when calling answer on evaluation engine with a parameter"._(() =>
{
evaluationEngine.Answer(new HowManyWordsDoesThisTextHave(), Parameter);
});
"it should pass parameter to the evaluation expressions"._(() =>
{
expression.ReceivedParameter.Should().Be(Parameter);
});
}
public void InlineExpressions(
IEvaluationEngine engine,
int answer)
{
"establish an evaluation engine with expression aggregator"._(() =>
{
engine = new EvaluationEngine();
engine.Solve <HowManyFruitsAreThere, int>()
.AggregateWithExpressionAggregator(0, (aggregate, value) => aggregate + value);
});
"when defining inline expressions in the call to by evaluating"._(() =>
{
engine.Solve <HowManyFruitsAreThere, int>()
.ByEvaluating((q, p) => 2)
.ByEvaluating((q, p) => 3);
answer = engine.Answer(new HowManyFruitsAreThere());
});
"it should evaluate all expressions for the question"._(() =>
{
answer.Should().Be(5);
});
}
public DoorSensor(
IVhptDoor door,
IStateMachine<States, Events> stateMachine,
IAsynchronousFileLogger fileLogger,
IVhptTravelCoordinator travelCoordinator,
IEvaluationEngine evaluationEngine)
{
this.door = door;
this.stateMachine = stateMachine;
this.fileLogger = fileLogger;
this.travelCoordinator = travelCoordinator;
this.evaluationEngine = evaluationEngine;
}
public void Calculation()
{
IEvaluationEngine engine = null;
Logger logExtension = null;
"establish"._(() =>
{
logExtension = new Logger();
engine = new EvaluationEngine();
engine.SetLogExtension(logExtension);
engine.Solve <HowManyFruitsAreThereStartingWith, int, char>()
.AggregateWithExpressionAggregator(0, (aggregate, value) => aggregate + value)
.ByEvaluating(q => new ParametrizedFruitExpression {
Kind = "Apple", Count = 1
})
.When(q => true)
.ByEvaluating(q => new[] { new ParametrizedFruitExpression {
Kind = "Ananas", Count = 2
}, new ParametrizedFruitExpression {
Kind = "Banana", Count = 4
} })
.ByEvaluating((q, p) => p == 'B' ? 8 : 0)
.When(q => false)
.ByEvaluating(q => new ParametrizedFruitExpression {
Kind = "Unknown"
});
});
"when an answer is calculated"._(() =>
{
engine.Answer(new HowManyFruitsAreThereStartingWith(), 'A');
});
"it should log how answer was derived"._(() =>
{
logExtension.FoundAnswerLog
.Should().Contain(HowManyFruitsAreThereStartingWith.Description, "answered question")
.And.Contain("aggregator strategy", "used strategy")
.And.Contain("expression aggregator with seed '0' and aggregate function (aggregate, value) => (aggregate + value)", "used aggregator")
.And.Contain("Parameter = A", "provided parameter")
.And.Contain("Answer = 3", "calculated answer")
.And.Contain("1 Apple returned 1", "used expression with result")
.And.Contain("2 Ananas returned 2", "used expression with result")
.And.Contain("4 Banana returned 0", "used expression with result")
.And.Contain("inline expression = (q, p) => IIF((Convert(p) == 66), 8, 0) returned 0", "used expression with result")
.And.NotContain("Unknown", "unknwon expression should not be evaluated due to unfulfilled constraint");
});
}
public void AskingChild(
string childAnswer,
IEvaluationEngine parentEngine,
IEvaluationEngine childEngine)
{
"establish an hierarchical evaluation engine"._(() =>
{
parentEngine = new EvaluationEngine();
childEngine = new EvaluationEngine(parentEngine);
parentEngine.Solve <Question, string>()
.AggregateWithExpressionAggregator(ParentAggregator, (aggregate, value) => aggregate + value)
.ByEvaluating((q, p) => ParentExpression);
childEngine.Solve <Question, string>()
.AggregateWithExpressionAggregator(ChildAggregator, (aggregate, value) => aggregate + value)
.ByEvaluating((q, p) => ChildExpression);
});
"when calling answer on a child evaluation engine"._(() =>
{
childAnswer = childEngine.Answer(new Question());
});
"it should override parent aggregator with child aggregator"._(() =>
{
childAnswer.Should().Contain(ChildAggregator);
});
"it should use expressions from child and parent"._(() =>
{
childAnswer
.Should().Contain(ParentExpression)
.And.Contain(ChildExpression);
});
"it should evaluate expressions from parent first"._(() =>
{
childAnswer.EndsWith(ParentExpression + ChildExpression, StringComparison.Ordinal)
.Should().BeTrue();
});
}
public void Constraints(
IEvaluationEngine engine,
string answer)
{
const string NoConstraint = "N";
const string WithTrueConstraint = "T";
const string WithFalseConstraint = "F";
"establish a solving strategy with constraints"._(() =>
{
engine = new EvaluationEngine();
engine.Solve <WhatIsTheText, string>()
.AggregateWithExpressionAggregator(string.Empty, (aggregate, value) => aggregate + value)
.ByEvaluating((q, p) => NoConstraint)
.When(q => false)
.ByEvaluating((q, p) => WithFalseConstraint)
.When(q => true)
.ByEvaluating((q, p) => WithTrueConstraint);
});
"when calling answer"._(() =>
{
answer = engine.Answer(new WhatIsTheText());
});
"it should evaluate expressions without constraints"._(() =>
{
answer.Should().Contain(NoConstraint);
});
"it should evaluate expressions with fulfilled constraints"._(() =>
{
answer.Should().Contain(WithTrueConstraint);
});
"it should ignore expressions with constraints that are not fulfilled"._(() =>
{
answer.Should().NotContain(WithFalseConstraint);
});
}
public void CustomStrategy(
IEvaluationEngine engine,
int answer)
{
"establish an evaluatione engine"._(() =>
{
engine = new EvaluationEngine();
});
"when defining an own strategy"._(() =>
{
engine.Solve <HowManyFruitsAreThere, int>()
.With(new SpecialStrategy());
answer = engine.Answer(new HowManyFruitsAreThere());
});
"it should use own strategy instead of default strategy to answer the question"._(() =>
{
answer.Should().Be(TheAnswer);
});
}
public void MissingAggregator()
{
IEvaluationEngine engine = null;
Exception exception = null;
"establish"._(() =>
{
engine = new EvaluationEngine();
engine.Solve <HowManyFruitsAreThere, int>();
});
"when calling answer on evaluation engine and no aggregator is specified"._(() =>
{
exception = Catch.Exception(() => engine.Answer(new HowManyFruitsAreThere()));
});
"it should throw invalid operation exception"._(() =>
{
exception.Should().BeOfType <InvalidOperationException>();
});
}
SolveHowCoolIsTheEvaluationEngine(this IEvaluationEngine engine)
{
return(engine.Solve <HowCoolIsTheEvaluationEngine, string>());
}
public LeastSquaresResolutionStrategy(IEvaluationEngine engine)
{
_engine = engine;
_minimizationStrategy = _engine.CreatemMinimizationStrategy("LeastSquares");
}
/// <summary>
/// Initializes a new instance of the <see cref="Questioner"/> class.
/// </summary>
/// <param name="evaluationEngine">The evaluation engine.</param>
public Questioner(IEvaluationEngine evaluationEngine)
{
this.evaluationEngine = evaluationEngine;
}
/// <summary>
/// Initializes a new instance of the <see cref="Answerer"/> class.
/// </summary>
/// <param name="evaluationEngine">The evaluation engine.</param>
public Answerer(IEvaluationEngine evaluationEngine)
{
this.evaluationEngine = evaluationEngine;
}
public X2ResolutionStrategy(IEvaluationEngine engine)
{
_engine = engine;
_minimizationStrategy = _engine.CreatemMinimizationStrategy("X2");
}
/// <summary>
/// Initializes a new instance of the <see cref="Questioner"/> class.
/// </summary>
/// <param name="evaluationEngine">The evaluation engine.</param>
public Questioner(IEvaluationEngine evaluationEngine)
{
this.evaluationEngine = evaluationEngine;
}
/// <summary>
/// Initializes a new instance of the <see cref="Answerer"/> class.
/// </summary>
/// <param name="evaluationEngine">The evaluation engine.</param>
public Answerer(IEvaluationEngine evaluationEngine)
{
this.evaluationEngine = evaluationEngine;
}
SolveHowManyVowelsAreInThisText(this IEvaluationEngine engine)
{
return(engine.Solve <HowManyVowelsAreInThisText, int, string>());
}
public FuzzyPreferenceProgramming(IEvaluationEngine engine)
{
_engine = engine;
}
public MainEigenvectorResolutionStrategy(IEvaluationEngine engine)
{
_engine = engine;
}
