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