public void AddAssignmentWithSameKeyShouldThrow()
{
var item = new ConstructorAssignment("ParameterName", new CodeAssignStatement(), new CodeMemberField(), typeof(string));
testObject.AddAssignment(item);
Assert.AreEqual(1, testObject.Count);
Assert.Throws<ArgumentException>(() => testObject.AddAssignment(item));
Assert.AreEqual(1, testObject.Count);
var item2 = new ConstructorAssignment("ParameterName", new CodeAssignStatement(), new CodeMemberField(), typeof(string));
Assert.Throws<ArgumentException>(() => testObject.AddAssignment(item2));
Assert.AreEqual(1, testObject.Count);
}
public void AddAssignmentTest()
{
var expected = new ConstructorAssignment("ParameterName", new CodeAssignStatement(), new CodeMemberField(), typeof(string));
testObject.AddAssignment(expected);
Assert.AreEqual(1, testObject.Count);
var actual = testObject["ParameterName"];
Assert.AreEqual(expected, actual);
var expected2 = new ConstructorAssignment("OtherParameterName", new CodeAssignStatement(), new CodeMemberField(), typeof(string));
testObject.AddAssignment(expected2);
actual = testObject["OtherParameterName"];
Assert.AreEqual(2, testObject.Count);
Assert.AreEqual(expected2, actual);
actual = testObject["ParameterName"];
Assert.AreEqual(expected, actual);
}
/// <summary>
/// Tries to find a matching constructor assignment for a parameter.
/// </summary>
/// <param name="parameter">The name of the parameter to find the constructor assignment for.</param>
/// <param name="constructorAssignment">The found constructor assignment. Is <c>null</c> when none is found.</param>
/// <param name="caseSensitive">if set to <c>true</c> if case sensitive parameter name matching should be used.</param>
/// <returns>
/// <c>true</c> if a matching constructor assignment was found; otherwise <c>false</c>.
/// </returns>
public bool TryFindConstructorAssignment(
string parameter, out ConstructorAssignment constructorAssignment, bool caseSensitive)
{
Guard.NotNullOrEmpty(() => parameter, parameter);
// Guard.NotNull(() => this.assignments, this.assignments);
if (CtorAssignments == null)
{
constructorAssignment = null;
return(false);
}
Func <string, string, bool> comparer;
if (caseSensitive)
{
comparer = (x, y) => x == y;
}
else
{
comparer = (x, y) => x.ToLower() == y.ToLower();
}
foreach (var ctorAssignments in CtorAssignments)
{
foreach (var assignment in ctorAssignments)
{
if (comparer(assignment.ParameterName, parameter))
{
constructorAssignment = assignment;
return(true);
}
}
}
constructorAssignment = null;
return(false);
}
public void PropertyItemIndexNormalBehavior()
{
// Test read access of 'Indexer' Property.
var expected = new ConstructorAssignment("ParameterName", new CodeAssignStatement(), new CodeMemberField(), typeof(string));
testObject.AddAssignment(expected);
var actual = testObject["ParameterName"];
Assert.AreEqual(expected, actual);
}
public void PropertyItemIndexWithNotPresentKey()
{
// Test read access of 'Indexer' Property with a key that is not present.
var actual = testObject["NotPresent"];
Assert.IsNull(actual);
var item = new ConstructorAssignment("ParameterName", new CodeAssignStatement(), new CodeMemberField(), typeof(string));
testObject.AddAssignment(item);
actual = testObject["AnotherNotPresent"];
Assert.IsNull(actual);
}
private void CreateMocker(
CodeTypeDeclaration testClassDeclaration,
CodeMemberMethod setUpMethod,
CodeMemberField mockRepositoryMemberField,
List<CodeAssignStatement> mockAssignments,
Type paraType,
string paraName,
ConstructorAssignment data)
{
if(data != null && data.MemberFieldName != data.ParameterName)
{
}
// reuse already present field assignments.
var mockMemberField = testClassDeclaration
.Members.OfType<CodeMemberField>()
.Where(e => e.Name == paraName)
.FirstOrDefault();
var mockMemberFieldCreated = false;
if (mockMemberField == null)
{
mockMemberField = AddTestMemberField(
testClassDeclaration, paraType.FullName, paraName);
mockMemberFieldCreated = true;
}
var mockAssignment = this.AddMockObject(mockRepositoryMemberField, paraType.FullName, paraName);
if (mockMemberFieldCreated)
{
// none found, add a new assignment.
setUpMethod.Statements.Add(mockAssignment);
}
else
{
if (data != null)
{
data.AssignStatement.Right = mockAssignment.Right;
}
}
mockAssignments.Add(mockAssignment);
}
/// <summary>
/// Builds a assignment info for the specified constructor.
/// </summary>
/// <param name="bindingAttr">A bit mask comprised of one or more <see cref="BindingFlags"/>
/// that specify how the search is conducted. -or- Zero, to return <c>null</c>.</param>
/// <param name="constructor">The constructor to build the parameter assignment info's for.</param>
/// <returns>
/// An <see cref="AssignmentInfoCollection"/> initialized with the data from the specified
/// <paramref name="constructor"/>.
/// </returns>
private AssignmentInfoCollection BuildAssignmentInfoForConstructor(
BindingFlags bindingAttr, ConstructorInfo constructor)
{
// var ctorParameterTypesInterface = new List<ParameterInfo>();
// var ctorParameterTypesStd = new List<ParameterInfo>();
var ctorParameterTypes = new ParameterInfoCollection();
var ctorParameters = constructor.GetParameters();
foreach (var para in ctorParameters)
{
{
// if (!para.ParameterType.IsGenericType)
ctorParameterTypes.AddParameterInfo(para);
/*if (para.ParameterType.IsInterface)
* {
* hasInterfaceInCtorParameters = true;
* ctorParameterTypesInterface.Add(para);
* }
* else
* {
* ctorParameterTypesStd.Add(para);
* }*/
}
}
// BuildAssignmentInfoForConstructor
var assignmentInfoCollection = new AssignmentInfoCollection {
UsedConstructor = constructor
};
var addTypesFrom = ctorParameterTypes;
/*var addTypesFrom = ctorParameterTypes.StandardTypes;
*
* // Todo: do not use bindingAttr here, use the MemberVisibility enumeration
* if ((bindingAttr & BindingFlags.NonPublic) == BindingFlags.NonPublic)
* {
* addTypesFrom = ctorParameterTypes;
* }*/
foreach (var paraInfo in addTypesFrom)
{
if (!paraInfo.ParameterType.IsGenericType)
{
var memberField = CreateMemberField(paraInfo.ParameterType.FullName, paraInfo.Name);
// var fieldAssignment = CodeMethodComposer.CreateAndInitializeMemberField(
// paraInfo.ParameterType, paraInfo.Name);
// var assignment = new ConstructorAssignment(
// paraInfo.Name, fieldAssignment, memberField, paraInfo.ParameterType);
var fieldAssignment = CodeMethodComposer.CreateAndInitializeMemberField(
paraInfo.ParameterType, memberField.Name);
var assignment = new ConstructorAssignment(
memberField.Name, fieldAssignment, memberField, paraInfo.ParameterType);
assignmentInfoCollection.AddAssignment(assignment);
}
else
{
var genericTypeDefinition = paraInfo.ParameterType.GetGenericTypeDefinition();
if (TestObjectMemberField.Type.BaseType == "DefaultMemberBuilderFactory")
{
}
if (CheckForItemizable(paraInfo, genericTypeDefinition))
{
var genArgs = paraInfo.ParameterType.GetGenericArguments();
if (genArgs.Length == 1)
{
var memberFieldName = paraInfo.Name + "Item";
var memberField = CreateMemberField(genArgs[0].FullName, memberFieldName);
var fieldAssignment = CodeMethodComposer.CreateAndInitializeMemberField(
genArgs[0], memberField.Name);
var assignment = new ConstructorAssignment(
memberField.Name, fieldAssignment, memberField, genArgs[0]);
// assignmentInfoCollection.AddAssignment(assignment);
// AddAssignStatement(fieldAssignment);
var collectionFieldName = paraInfo.Name;
var collectionField = CreateMemberField(paraInfo.ParameterType.FullName, collectionFieldName);
var collectionAssignment = CodeMethodComposer.CreateAndInitializeCollectionField(
/*paraInfo.ParameterType,*/ collectionFieldName, memberFieldName);
var collection = new ConstructorAssignment(
collectionFieldName, collectionAssignment, collectionField, paraInfo.ParameterType);
collection.CreateAssignments.Add(assignment);
assignmentInfoCollection.AddAssignment(collection);
}
}
if (typeof(IEnumerable).IsAssignableFrom(paraInfo.ParameterType))
{
}
if (paraInfo.ParameterType.IsAssignableFrom(typeof(IEnumerable <>)))
{
}
}
}
return(assignmentInfoCollection);
}
