public void CreateTestStubForMethodTest() { CodeMemberMethod codeMemberMethod = null; // TODO: Initialize to an appropriate value CodeMethodComposer.CreateTestStubForMethod(codeMemberMethod); Assert.Inconclusive("A method that does not return a value cannot be verified."); }
public void AppendAssertInconclusiveTest() { var method = new CodeMemberMethod(); var expectedText = "The assert text"; CodeMethodComposer.AppendAssertInconclusive(method, expectedText); var actualMethodStatements = method.Statements; Assert.AreEqual(2, actualMethodStatements.Count); Assert.IsInstanceOfType <CodeExpressionStatement>(actualMethodStatements[1]); var actualExpr = (CodeExpressionStatement)method.Statements[1]; Assert.IsInstanceOfType <CodeMethodInvokeExpression>(actualExpr.Expression); var actualInvoke = (CodeMethodInvokeExpression)actualExpr.Expression; Assert.IsInstanceOfType <CodeMethodReferenceExpression>(actualInvoke.Method); var actualRef = actualInvoke.Method; Assert.IsInstanceOfType <CodeTypeReferenceExpression>(actualRef.TargetObject); var actualtypeRef = (CodeTypeReferenceExpression)actualRef.TargetObject; Assert.IsInstanceOfType <CodeTypeReference>(actualtypeRef.Type); var actualtype = actualtypeRef.Type; Assert.AreEqual("Assert", actualtype.BaseType); Assert.IsInstanceOfType <CodePrimitiveExpression>(actualInvoke.Parameters[0]); var actualPrimExpr = (CodePrimitiveExpression)actualInvoke.Parameters[0]; Assert.AreEqual(expectedText, actualPrimExpr.Value); }
public void CreateAndInitializeMemberFieldTest() { Type type = null; // TODO: Initialize to an appropriate value string memberField = string.Empty; // TODO: Initialize to an appropriate value CodeAssignStatement expected = null; // TODO: Initialize to an appropriate value CodeAssignStatement actual; actual = CodeMethodComposer.CreateAndInitializeMemberField(type, memberField); Assert.AreEqual(expected, actual); Assert.Inconclusive("Verify the correctness of this test method."); }
public void CreateAndInitializeCollectionFieldTest() { var memberfield = "theMember"; var actual = CodeMethodComposer.CreateAndInitializeCollectionField(memberfield, "init1", "init2"); Assert.IsInstanceOfType <CodeAssignStatement>(actual); actual = CodeMethodComposer.CreateAndInitializeCollectionField(memberfield, "init1", "init2"); var assignment = (CodeSnippetExpression)actual.Right; Assert.AreEqual("new[] { init1,init2 }", assignment.Value); }
public void CreateExpressionByTypeTest() { var memberField = "myFieldName"; var type = typeof(string); var actual = CodeMethodComposer.CreateExpressionByType(type, memberField); Assert.IsInstanceOfType <CodePrimitiveExpression>(actual); Assert.AreEqual("Value of myFieldName", ((CodePrimitiveExpression)actual).Value); type = typeof(Type); actual = CodeMethodComposer.CreateExpressionByType(type, memberField); Assert.IsInstanceOfType <CodeTypeOfExpression>(actual); Assert.AreEqual("System.Object", ((CodeTypeOfExpression)actual).Type.BaseType); }
public void CreateTestStubForMethodTest() { var method = new CodeMemberMethod(); method.Name = "TheMethodName"; CodeMethodComposer.CreateTestStubForMethod(method); var expectedComment = "TODO: Implement unit test for TheMethodName"; AssertEx.That( method.ContainsComment(expectedComment), "Comment '{0}' not found in: {1}", expectedComment, method.ContainsCommentMsg()); AssertEx.That( method.ContainsAttribute("Test"), "Attribute 'Test' not found in: {0}", method.ContainsAttributeMsg()); AssertEx.That(method.HasReturnTypeOf(typeof(void))); }
/// <summary> /// Creates a constructor test method. /// </summary> /// <param name="context">The build context of the test method member.</param> /// <param name="methodName">Name of the method.</param> /// <param name="testObjectName">Name of the test object.</param> /// <param name="createExpr">A <see cref="CodeObjectCreateExpression"/> building the test object.</param> /// <returns>A new test method, forming the constructor test.</returns> private CodeMemberMethod CreateConstructorTest( IMemberBuildContext context, string methodName, string testObjectName, out CodeObjectCreateExpression createExpr) { var cm = new CustomConstructorCodeMemberMethod { Name = methodName, Attributes = MemberAttributes.Public | MemberAttributes.Final }; CodeMethodComposer.CreateTestStubForMethod(cm); createExpr = this.BuildTestObject(context.TestObjectType.Name, testObjectName, cm); context.TestClassDeclaration.Members.Add(cm); context.BuildResult.ClassMethodsToAdd.Add(cm); return(cm); }
public void CreateAndInitializeMemberFieldTest() { var type = typeof(string); var memberfield = "theMember"; var actual = CodeMethodComposer.CreateAndInitializeMemberField(type, memberfield); Assert.IsInstanceOfType <CodeAssignStatement>(actual); object expectedValue = true; Type expectedType = expectedValue.GetType(); actual = CodeMethodComposer.CreateAndInitializeMemberField(expectedType, memberfield); var assignment = (CodePrimitiveExpression)actual.Right; Assert.AreEqual(true, assignment.Value); Assert.AreEqual(expectedType, assignment.Value.GetType()); expectedValue = typeof(CodeMethodComposerTest); expectedType = expectedValue.GetType(); actual = CodeMethodComposer.CreateAndInitializeMemberField(expectedType, memberfield); var assignment2 = (CodeObjectCreateExpression)actual.Right; Assert.AreEqual(expectedType.FullName, assignment2.CreateType.BaseType); expectedValue = 35; expectedType = expectedValue.GetType(); actual = CodeMethodComposer.CreateAndInitializeMemberField(expectedType, memberfield); assignment = (CodePrimitiveExpression)actual.Right; Assert.AreEqual(1234, assignment.Value); Assert.AreEqual(expectedType, assignment.Value.GetType()); expectedValue = new InfoApe(); expectedType = expectedValue.GetType(); actual = CodeMethodComposer.CreateAndInitializeMemberField(expectedType, memberfield); assignment2 = (CodeObjectCreateExpression)actual.Right; Assert.AreEqual(expectedType.FullName, assignment2.CreateType.BaseType); // Todo: implement all CLR-Types. }
/// <summary> /// Handle property related stuff before type generation. /// </summary> /// <param name="context">The context. Todo: remove it with specialized parameters after development.</param> /// <param name="typeMember">The type member.</param> /// <param name="builderData">The builder data.</param> /// <param name="testObjectName">Name of the test object member field.</param> /// <param name="propertyName">Name of the property.</param> /// <exception cref="NotImplementedException">The context of the builder does not supply a valid /// <see cref="ISetupAndTearDownCreationContext"/>.</exception> /// <exception cref="NotImplementedException">The context of the builder does not supply a valid /// <see cref="TestObjectComposer"/>.</exception> protected virtual void ComputeCodeMemberProperty( IMemberBuildContext context, CodeMemberMethod typeMember, IBuilderData builderData, string testObjectName, string propertyName) { var propertyData = builderData as PropertyBuilderData; if (propertyData == null) { return; } var setAccessor = propertyData.SetAccessor; var getAccessor = propertyData.GetAccessor; if (getAccessor == null) { return; } if (setAccessor == null) { // create the actual and expected var's here. // actualRef // expectedRef } var propName = propertyData.PropertyName; // devel: how to create a string initializer from possible constructor setups of the 'SetUp' method. var co = context.SetUpTearDownContext as ISetupAndTearDownCreationContext; if (co == null) { throw new NotImplementedException("The context of the builder does not supply a valid ISetupAndTearDownCreationContext."); } // Todo: put these used methods into the interfaces of TestObjectComposer and maybe modify // ISetupAndTearDownContext that it provides the co.TestObjectCreator. ... or fix all this in the // pre-build?!! var creator = co.TestObjectCreator as TestObjectComposer; if (creator == null) { throw new NotImplementedException("The context of the builder does not supply a valid TestObjectBuilder."); } ConstructorAssignment ctorAssignment; var found = creator.TryFindConstructorAssignment(propName, out ctorAssignment, false); CodeExpression ctorAssignmentRight = CodeMethodComposer.CreateExpressionByType(getAccessor.ReturnType, propertyData.PropertyName); // CodeExpression ctorAssignmentRight = new CodePrimitiveExpression("Insert expected object here"); var assertionKind = "AreEqual"; if (found) { // use the value of the ctor initializer. //ctorAssignmentRight = ctorAssignment.AssignStatement.Right; // use the field reference itself. ctorAssignmentRight = ctorAssignment.AssignStatement.Left; assertionKind = "AreSame"; } typeMember.Statements.Add(new CodeSnippetStatement(string.Empty)); typeMember.Statements.Add(new CodeCommentStatement("Test read access of '" + propName + "' Property.")); var expectedAsign = new CodeVariableDeclarationStatement( "var", "expected", ctorAssignmentRight); typeMember.Statements.Add(expectedAsign); var testObjRef = new CodeTypeReferenceExpression(testObjectName); var testPropRef = new CodePropertyReferenceExpression(testObjRef, propName); var actualAsign = new CodeVariableDeclarationStatement("var", "actual", testPropRef); typeMember.Statements.Add(actualAsign); var assertExpr = new CodeMethodInvokeExpression( new CodeTypeReferenceExpression("Assert"), assertionKind, new CodeVariableReferenceExpression("expected"), new CodeVariableReferenceExpression("actual")); typeMember.Statements.Add(assertExpr); }
public void CreateTestStubForMethodWithEmptyNameThrows() { var method = new CodeMemberMethod(); Assert.Throws <ArgumentException>(() => CodeMethodComposer.CreateTestStubForMethod(method)); }