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