public void CreateItemReturningItem_WithNoFactory_Fails()
{
var id = new Mock<IIdentifier>().Object;
IEquationBuilder builder = new EquationBuilder();
IItem item;
builder.CreateItem(id, out item);
}
public void CreateItemReturningItem_WithFactoryAndUnknownIdentifier_Fails()
{
var id = new Mock<IIdentifier>().Object;
var factory = new Mock<IFactory>();
factory.Setup(o => o.CanCreate(id)).Returns(false);
IEquationBuilder builder = new EquationBuilder(new[] { factory.Object });
IItem item;
builder.CreateItem(id, out item);
}
public void Factory_PlugedInTheEquationBuilder_CanBeUsedToCreateSquareRoot()
{
var factory = new AdvancedMathOperatorsFactory();
var builder = new EquationBuilder(new[] { factory });
builder = builder.CreateItem<EquationBuilder>(AdvancedMathOperators.SquareRoot);
var tree = builder.ToImmutableTree();
var rootValue = tree.ValueOf(tree.GetRoot());
Assert.AreEqual("SquareRoot", rootValue);
}
public void EquationToStringTest()
{
IEquationBuilder equationBuilder = new EquationBuilder(new BracketOpener(), new SummandBuilder());
string inputEquation = "(5x+ 5y)/5 -x^2=1";
var equation = equationBuilder.Create(inputEquation);
equation.Processing();
Assert.AreEqual(equation.ToString(), "- x^2 + x + y - 1 = 0");
}
public void CreateItemReturningItem_WithFactoriesThatCanCreateSameItem_Fails()
{
var id = new Mock<IIdentifier>().Object;
var item = new Mock<IItem>().Object;
var factory = new Mock<IFactory>();
factory.Setup(o => o.CanCreate(id)).Returns(true);
factory.Setup(o => o.Create(id)).Returns(item);
IEquationBuilder builder = new EquationBuilder(new[] { factory.Object, factory.Object });
IItem createItem;
builder.CreateItem(id, out createItem);
}
public void EquationBuildAndProcessing()
{
IEquationBuilder equationBuilder = new EquationBuilder(new BracketOpener(), new SummandBuilder());
string inputEquation = "x^2 + 2y = 2((2x-1)/2 + 2.5(x + y^2) - 7.11)";
var expectedLeft = new List <Summand>
{
new Summand {
Multiplier = 1, Variables = new List <Variable> {
new Variable {
Exponent = 2, Letter = 'x'
}
}
},
new Summand {
Multiplier = -7, Variables = new List <Variable> {
new Variable {
Exponent = 1, Letter = 'x'
}
}
},
new Summand {
Multiplier = -5, Variables = new List <Variable> {
new Variable {
Exponent = 2, Letter = 'y'
}
}
},
new Summand {
Multiplier = 2, Variables = new List <Variable> {
new Variable {
Exponent = 1, Letter = 'y'
}
}
},
new Summand {
Multiplier = 15.22, Variables = new List <Variable>()
}
};
expectedLeft = expectedLeft.OrderByDescending(x => x).ToList();
var equation = equationBuilder.Create(inputEquation);
equation.Processing();
Assert.IsNotNull(equation);
Assert.IsTrue(expectedLeft.SequenceEqual(equation.LeftSide));
Assert.IsTrue(equation.RightSide.Count == 0);
}
public void CreateItemReturningItem_WithFactoryAndKnownIdentifier_ReturnsTheNewItem()
{
var id = new Mock<IIdentifier>().Object;
var item = new Mock<IItem>().Object;
var factory = new Mock<IFactory>();
factory.Setup(o => o.CanCreate(id)).Returns(true);
factory.Setup(o => o.Create(id)).Returns(item);
IEquationBuilder builder = new EquationBuilder(new[] { factory.Object });
IItem createItem;
builder.CreateItem(id, out createItem);
Assert.AreEqual(item, createItem);
}
static void Main(string[] args)
{
IBracketOpener bracketOpener = new BracketOpener();
ISummandBuilder summandBuilder = new SummandBuilder();
IEquationBuilder equationBuilder = new EquationBuilder(bracketOpener, summandBuilder);
IEquationIO equationIo;
if (args.Length == 0)
{
equationIo = new EquationConsoleIO(equationBuilder);
}
else
{
equationIo = new EquationFileIO(equationBuilder, args[0]);
}
equationIo.Begin();
Console.ReadKey();
}
public void Parentheses_WithExpressionAndFactory_AllowsCreatingNewItemsInsideExpression()
{
var id = new Mock<IIdentifier>().Object;
var item = new Mock<IItem>().Object;
var factory = new Mock<IFactory>(MockBehavior.Strict);
factory.Setup(o => o.CanCreate(id)).Returns(true);
factory.Setup(o => o.Create(id)).Returns(item);
IEquationBuilder builder = new EquationBuilder(new[] { factory.Object });
builder = builder.Parentheses(b => b.CreateItem(id));
factory.VerifyAll();
}
public void ToImmutableTree_WithTwoValues_ReturnsTreeWithRootAndTwoChildren()
{
IEquationBuilder builder = new EquationBuilder();
builder = builder
.Value(42)
.Value(84);
var tree = (builder as EquationBuilder).ToImmutableTree();
var children = tree.GetChildren(tree.GetRoot());
Assert.AreEqual(2, children.Count());
}
public void ToImmutableTree_WithParenthesesAndValue_ReturnsTreeWithParenthesesAndValue()
{
IEquationBuilder builder = new EquationBuilder();
builder = builder.Parentheses(b => b.Value(3));
var tree = (builder as EquationBuilder).ToImmutableTree();
var parenthesis = tree.GetChildren(tree.GetRoot()).First();
var value = tree.GetChildren(parenthesis).First();
Assert.AreEqual("()", tree.ValueOf(parenthesis));
Assert.AreEqual("3", tree.ValueOf(value));
}
public void ToImmutableTree_WithLiteral_ReturnsTreeWithRootAndChild()
{
IEquationBuilder builder = new EquationBuilder();
builder = builder.Literal("x");
var tree = (builder as EquationBuilder).ToImmutableTree();
var children = tree.GetChildren(tree.GetRoot());
Assert.AreEqual(1, children.Count());
}
public void ToImmutableTree_WithDivide_ReturnsTreeWithDivideOperator()
{
IEquationBuilder builder = new EquationBuilder();
builder = builder.Divide();
var tree = (builder as EquationBuilder).ToImmutableTree();
var children = tree.GetChildren(tree.GetRoot());
var divide = children.First();
Assert.AreEqual("/", tree.ValueOf(divide));
}
public void ToImmutableTree_WithDivideWithValueExpression_ReturnsTreeWithDivideOperatorAndValue()
{
IEquationBuilder builder = new EquationBuilder();
builder = builder.Divide(b => b.Value(3));
var tree = (builder as EquationBuilder).ToImmutableTree();
var divide = tree.GetChildren(tree.GetRoot()).First();
var value = tree.GetChildren(divide).First();
Assert.AreEqual("/", tree.ValueOf(divide));
Assert.AreEqual("3", tree.ValueOf(value));
}
public void ToImmutableTree_WithAdd_ReturnsTreeWithAddOperator()
{
IEquationBuilder builder = new EquationBuilder();
builder = builder.Add();
var tree = (builder as EquationBuilder).ToImmutableTree();
var children = tree.GetChildren(tree.GetRoot());
var add = children.First();
Assert.AreEqual("+", tree.ValueOf(add));
}
public void CreateItem_WithFactoryAndKnownIdentifier_ReturnsTheBuilder()
{
var id = new Mock<IIdentifier>().Object;
var item = new Mock<IItem>().Object;
var factory = new Mock<IFactory>();
factory.Setup(o => o.CanCreate(id)).Returns(true);
factory.Setup(o => o.Create(id)).Returns(item);
IEquationBuilder builder = new EquationBuilder(new[] { factory.Object });
var returnedBuilder = builder.CreateItem(id);
Assert.AreEqual(builder, returnedBuilder);
}
public void CreateItem_WithNoFactory_Fails()
{
var id = new Mock<IIdentifier>().Object;
IEquationBuilder builder = new EquationBuilder();
builder.CreateItem(id);
}
public void IsConformWithIEquationBuilderDynamicContract()
{
var builder = new EquationBuilder();
Assert.IsTrue(IEquationBuilderDynamicContractChecker.IsConform(builder));
}
public void ToImmutableTree_ForNotUsedBuilder_ReturnsTreeWithRoot()
{
IEquationBuilder builder = new EquationBuilder();
var tree = (builder as EquationBuilder).ToImmutableTree();
Assert.IsTrue(tree.KeyProvider.IsValid(tree.GetRoot()));
}
private void SnippentsThatDontBreakTheBuild()
{
{
var builder = new EquationBuilder();
builder
.Value(1)
.Add()
.Value(2);
}
{
var builder = new EquationBuilder();
builder
.Literal("x")
.Add()
.Literal("y");
}
{
var builder = new MarkupEquationBuilder();
builder
.Value(1)
.Add()
.Bold(b => b.Value(2))
.Add()
.Value(3);
}
{
var builder = new MarkupEquationBuilder();
builder
.Value(1)
.Add()
.Bold(b =>
{
b.Value(2)
.Add()
.Value(3);
})
.Add()
.Value(4);
}
{
var builder = new MarkupEquationBuilder();
builder
.Value(1)
.Add()
.Bold(b => b.Literal("x"))
.Add()
.Value(3);
}
{
var builder = new EquationBuilder();
builder
.Value(1)
.Add()
.Value(2)
.Add()
.Parentheses(b =>
{
b.Value(2)
.Add()
.Value(2);
});
}
{
var builder = new EquationBuilder();
builder
.Value(1)
.Divide()
.Parentheses(b =>
{
b.Value(2)
.Add()
.Value(3);
});
}
{
var builder = new EquationBuilder();
builder
.Value(1)
.Divide(b =>
{
b.Value(2)
.Add()
.Value(3);
});
}
{
var builder = new EquationBuilder();
var adding = true;
builder
.Value(1)
.If(adding,
onTrue: b => b.Add(),
onFalse: b => b.Divide())
.Value(2);
}
{
var builder = new EquationBuilder();
var needExtraValues = true;
builder
.Value(1)
.Add()
.If(needExtraValues,
onTrue: b => b.Value(3).Add().Value(4).Add())
.Value(2);
}
{
var builder = new EquationBuilder();
builder
.Map(Enumerable.Repeat(1, 10), (b, element) =>
b.Value(element).Add())
.Value(1);
}
{
var builder = new EquationBuilder();
builder
.Map(Enumerable.Range(100, 9),
action: (b, element, index) =>
b.Value(element)
.Divide()
.Value(index)
.Add())
.Value(110)
.Divide()
.Value(10);
}
{
var builder = new EquationBuilder();
builder
.Reduce(Enumerable.Range(0, 9),
seed: 0,
action: (previouse, element) => previouse + element,
onEnd: (b, final) => b.Value(final));
}
{
var builder = new EquationBuilder();
builder
.Reduce(Enumerable.Range(0, 9),
seed: 0,
action: (previouse, element, index) => previouse + element * index,
onEnd: (b, final) => b.Value(final));
}
}
