public void ShouldParse_NullableTypeDeclaration()
{
// Arrange
var unit = _fixture.Compile("int? x;");
// Act
var expression = _translator.Translate(unit);
// Assert
ExpressionAssert.Declaration(expression, typeof(int?), "x");
}
public void ShouldParse_ArrayDeclaration_WithExplicitType()
{
// Arrange
var unit = _fixture.Compile("int[] x;");
// Act
var expression = _translator.Translate(unit);
// Assert
ExpressionAssert.Declaration(expression, typeof(int[]), "x");
}
public void ShouldParse_LiteralExpression(string script, object expectedLiteral)
{
// Arrange
var unit = _fixture.Compile(script);
// Act
var expression = _translator.Translate(unit);
// Assert
ExpressionAssert.Constant(expression, expectedLiteral);
}
public void ShouldParse_AsCast()
{
// Arrange
var unit = _fixture.Compile("5 as object");
// Act
// Act
var expression = _translator.Translate(unit);
// Assert
var convertExpression = ExpressionAssert.AsConvert(expression, typeof(object));
ExpressionAssert.Constant(convertExpression.Operand, 5);
}
public void ShouldParse_InstancePropertyAccess()
{
// Arrange
var unit = _fixture.Compile("DateTime x; var y = x.Ticks;");
// Act
var expression = _translator.Translate(unit);
// Assert
var expressions = ExpressionAssert.AsMultiline(expression);
var binaryExpression = ExpressionAssert.AsBinaryAssign(expressions[1]);
var member = ExpressionAssert.AsMember(binaryExpression.Right);
ExpressionAssert.Parameter(member.Expression, typeof(DateTime), "x");
Assert.Equal("Ticks", member.Member.Name);
Assert.Equal(typeof(DateTime), member.Member.DeclaringType);
}
public void ShouldParse_InstanceMethodCall()
{
// Arrange
var unit = _fixture.Compile("int x = 5; x.ToString();");
// Act
var expression = _translator.Translate(unit);
// Assert
var expressions = ExpressionAssert.AsMultiline(expression);
var methodCall = ExpressionAssert.AsMethodCall(expressions[1]);
ExpressionAssert.Parameter(methodCall.Object, typeof(int), "x");
Assert.Equal("ToString", methodCall.Method.Name);
Assert.Equal(typeof(int), methodCall.Method.DeclaringType);
Assert.Empty(methodCall.Arguments);
}
public void Translate_CallsMatchOnCodeSpanTranslator()
{
var span = SpanHelper.BuildSpan("a");
var sut = new StatementTranslator(this._codeSpanTranslator.Object);
sut.Translate(span, this._templateBuilder.Object);
this._codeSpanTranslator.Verify(c => c.Match(span));
}
public void Translate_FoundMatchingCodeSpanTranslator_CallsTranslater()
{
this._codeSpanTranslator.Setup(c => c.Match(It.IsAny <Span>())).Returns(true);
var span = SpanHelper.BuildSpan("a");
var sut = new StatementTranslator(this._codeSpanTranslator.Object);
sut.Translate(span, this._templateBuilder.Object);
this._codeSpanTranslator.Verify(c => c.Translate(span.Content, this._templateBuilder.Object));
}
public void Translate_GivenCodeWithLineBreaks_CleanLineBreaksWhenHandingToTranslator()
{
this._codeSpanTranslator.Setup(c => c.Match(It.IsAny <Span>())).Returns(true);
var span = SpanHelper.BuildSpan("a\r\nb");
var sut = new StatementTranslator(this._codeSpanTranslator.Object);
sut.Translate(span, this._templateBuilder.Object);
this._codeSpanTranslator.Verify(c => c.Translate("ab", It.IsAny <ITemplateBuilder>()));
}
public void Translate_NoMatchingCodeSpanTranslator_DoNotCallTranslater()
{
this._codeSpanTranslator.Setup(c => c.Match(It.IsAny <Span>())).Returns(false);
var span = SpanHelper.BuildSpan("a");
var sut = new StatementTranslator(this._codeSpanTranslator.Object);
sut.Translate(span, this._templateBuilder.Object);
this._codeSpanTranslator.Verify(c => c.Translate(It.IsAny <string>(), It.IsAny <ITemplateBuilder>()), Times.Never());
}
public void ShouldParse_Type(string script, Type expectedType, string expectedVarName)
{
// Arrange
var unit = _fixture.Compile(script);
// Act
var expression = _translator.Translate(unit);
// Assert
ExpressionAssert.Declaration(expression, expectedType, expectedVarName);
}
public void ShouldParse_Not()
{
// Arrange
var unit = _fixture.Compile("!true;");
// Act
var expression = _translator.Translate(unit);
// Assert
var unaryExpression = ExpressionAssert.AsUnary(expression, ExpressionType.Not);
ExpressionAssert.Constant(unaryExpression.Operand, true);
}
public void Translate_MultipleMatchingCodeSpanTranslator_CallsFirstTranslater()
{
Mock <ICodeSpanTranslator> secondTranslator = new Mock <ICodeSpanTranslator>();
secondTranslator.Setup(c => c.Match(It.IsAny <Span>())).Returns(true);
this._codeSpanTranslator.Setup(c => c.Match(It.IsAny <Span>())).Returns(true);
var span = SpanHelper.BuildSpan("a");
var sut = new StatementTranslator(this._codeSpanTranslator.Object, secondTranslator.Object);
sut.Translate(span, this._templateBuilder.Object);
this._codeSpanTranslator.Verify(c => c.Translate(span.Content, this._templateBuilder.Object));
secondTranslator.Verify(c => c.Translate(It.IsAny <string>(), It.IsAny <ITemplateBuilder>()), Times.Never());
}
public void ShouldParse_If_WithEmptyBody()
{
// Arrange
var unit = _fixture.Compile("if(true) { }");
// Act
var expression = _translator.Translate(unit);
// Assert
var ifStatement = ExpressionAssert.AsConditional(expression);
ExpressionAssert.Constant(ifStatement.Test, true);
var trueExpressions = ExpressionAssert.AsBlock(ifStatement.IfTrue);
Assert.Empty(trueExpressions);
ExpressionAssert.Default(ifStatement.IfFalse);
}
public void ShouldParse_GenericTypeDeclaration_WithSingleParam()
{
// Arrange
var unit = _fixture.Compile("List<string> x;");
// Act
var expression = _translator.Translate(unit);
// Assert
ExpressionAssert.Declaration(expression, typeof(List <string>), "x");
}
public void ShouldParse_TupleDeclaration_Explicit_WithInitializer()
{
// Arrange
var unit = _fixture.Compile("Tuple<int, int> x = (5, 6);");
// Act
var expression = _translator.Translate(unit);
// Assert
var binaryExpression = ExpressionAssert.AsBinaryAssign(expression);
ExpressionAssert.Declaration(binaryExpression.Left, typeof(Tuple <int, int>), "x");
var rightExpression = ExpressionAssert.AsTuple(binaryExpression.Right);
Assert.Equal(2, rightExpression.Rank);
ExpressionAssert.Constant(rightExpression.Expressions[0], 5);
ExpressionAssert.Constant(rightExpression.Expressions[1], 6);
}
public void ShouldParse_Addition()
{
// Arrange
var unit = _fixture.Compile("5 + 6");
// Act
// Act
var expression = _translator.Translate(unit);
// Assert
var binaryExpression = ExpressionAssert.AsBinary(expression, ExpressionType.Add);
ExpressionAssert.Constant(binaryExpression.Left, 5);
ExpressionAssert.Constant(binaryExpression.Right, 6);
}
public void Translate_GivenNullTemplateBuilder_ThrowsArgumentNullException()
{
var sut = new StatementTranslator();
sut.Translate(new Span(new SpanBuilder()), null);
}
public void Translate_GivenNullSpan_ThrowsArgumentNullException()
{
var sut = new StatementTranslator();
sut.Translate(null, this._templateBuilder.Object);
}
public void ShouldParse_While_WithEmptyBody()
{
// Arrange
var unit = _fixture.Compile("while(true) { }");
// Act
var expression = _translator.Translate(unit);
// Assert
var whileStatement = ExpressionAssert.AsWhileLoop(expression);
ExpressionAssert.Constant(whileStatement.Condition, true);
var loopExpressions = ExpressionAssert.AsBlock(whileStatement.Body);
Assert.Empty(loopExpressions);
}